Fixing Broken Bulleted Lists in Gmail for Mobile 2026

You hit "Send" on a meticulously formatted project update from your desktop, confident that the bullet points organize your critical data perfectly. Then, you check your phone while waiting for coffee, open the sent folder, and see a wall of text where your list used to be. The indentation is gone, the bullets have vanished, and your carefully structured hierarchy now looks like a stream-of-consciousness ramble.

This isn't just an aesthetic annoyance; it’s a communication failure. In the world of mobile email 2026, where over 60% of professional correspondence is triaged on a handheld device, broken formatting means your email gets skimmed, misunderstood, or archived. The issue isn't usually your writing—it's the invisible war between modern rendering engines and legacy HTML handling.

The Anatomy of a Broken List

To fix the problem, you first have to understand the mechanism behind the breakage. When you create a bulleted list in a modern web editor or an AI tool like ChatGPT, the underlying code usually looks like a standard HTML Unordered List (<ul>) containing List Items (<li>).

On a desktop browser, this renders predictably because the browser has ample width and sophisticated CSS support. However, Gmail mobile lists break because the Gmail app (on both iOS and Android) is notoriously aggressive about stripping out "extraneous" code to save data and ensure security.

Here is exactly what happens in the rendering engine:

CSS Stripping: Gmail's mobile renderer often strips the <head> section of an email's HTML, where global styles live. If your bullets rely on a class defined in the header (e.g., .list-style-type: disc), that instruction is deleted.
Margin vs. Padding Collisions: Desktop clients often handle indentation via margin-left. Mobile clients, specifically Gmail, have inconsistent support for margins on list items. If the client resets the margin to zero to fit a narrow viewport, your indentation disappears.
The "Mso" Factor: If you are pasting from Outlook or Word, you are importing Microsoft Office-specific XML schemas (mso-list:l0 level1 lfo1). Gmail doesn't speak this language. It ignores the tags entirely, leaving you with plain paragraphs.

Pro Tip: Never assume that what you see in the "Compose" window is what the recipient receives. The Compose window is a rich-text editor running in a full browser environment; the recipient's view is a sanitized, stripped-down render.

Why AI-Generated Text Exacerbates the Issue

If you are using AI to draft emails, you are likely encountering this issue more frequently. Large Language Models (LLMs) generate text in Markdown. When you copy that Markdown from a browser interface (like Claude or ChatGPT) into an email client, you are performing a "rich paste."

The clipboard carries over the HTML interpretation of that Markdown. Often, these web interfaces use complex <div> wrappers or specific span classes to style their lists visually. When you paste that into Gmail, you are pasting a web-app specific structure into an email client that doesn't have the stylesheet to interpret it.

The result is often the "double bullet" (where the HTML list bullet and a hard-coded text bullet appear side-by-side) or the "zero indent" (where the text aligns perfectly left, making the bullets look like typos).

The "Plain Text Reset" Strategy

The most reliable way to fix bullet points is to stop relying on the email client's HTML interpretation of a rich paste. If you are struggling with complex formatting that keeps breaking, you need to strip the hidden code tags.

The workflow for a bulletproof list involves removing the <ul> and <li> tags entirely and replacing them with hard-coded characters.

Paste as Plain Text: Use Ctrl+Shift+V (Windows) or Cmd+Shift+V (Mac) to paste your text. This strips all HTML formatting.
Manually Insert Bullets: Use a specific keyboard character for the bullet (•) or a hyphen (-).
Hard Returns: Ensure there is a full paragraph break between items.

While this feels manual, it is the only way to guarantee 100% consistency across every device. A hard-coded text character cannot be stripped by a rendering engine because it is content, not code.

The Outlook-to-Gmail Pipeline

The friction between Outlook and Gmail is responsible for the majority of formatting tickets I see. Outlook uses Word as its rendering engine. Word creates lists using a mix of VML (Vector Markup Language) and proprietary XML.

When you send a list from Outlook to a Gmail user, or when you copy from Outlook Web to a Gmail compose window, you are essentially asking a browser to interpret a Word document.

The Specific Mechanism of Failure

Outlook defines lists using mso-list styles.

<p class=MsoListParagraph style='mso-list:l0 level1 lfo1'>
<![if !supportLists]>
<span style='mso-list:Ignore'>o<span style='font:7.0pt "Times New Roman"'>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span></span>
<![endif]>
List Item Text
</p>

Gmail's mobile renderer looks at that <![if !supportLists]> conditional comment and often decides to ignore the list styling entirely, or worse, renders the conditional fallback text awkwardly.

To ensure gmail formatting survives the trip from Outlook, you must force the list to be simple HTML. If you are in Outlook, use the "Simplify Formatting" option before sending, or use a third-party cleaner to scrub the Microsoft-specific tags.

Dark Mode: The Invisible List

We cannot talk about mobile email 2026 without addressing Dark Mode. By now, nearly 40% of mobile users view emails in Dark Mode.

Here is the technical trap: When you copy-paste a list from a website or a document, you often copy the color attribute. If the text was black (#000000) on the source, that hex code travels with the text.

When a user opens that email in Dark Mode:

The background turns dark (e.g., #1F1F1F).
The text should invert to white.
However, because the text has an inline style explicitly setting it to #000000, the client respects that code.
Result: Black text on a dark background. Invisible lists.

Insight: Gmail's auto-inversion algorithm is smart, but it is easily defeated by explicit inline styles. If your HTML contains style="color: black", Gmail assumes you really want it black, even in Dark Mode. Always strip text color attributes before sending.

Technical Fix: Inline Styles for the Brave

If you absolutely must use true HTML lists (because you need hanging indents where the second line of text aligns with the start of the first line, not the bullet), you cannot rely on global CSS. You must use inline styles.

This is the only code structure that reliably renders a hanging indent list on Gmail mobile apps:

<ul style="padding-left: 20px; margin-top: 0; margin-bottom: 0;">
  <li style="margin-bottom: 10px; padding-left: 0;">Your list item here</li>
  <li style="margin-bottom: 10px; padding-left: 0;">Your second item here</li>
</ul>

Why this works:

Padding-left on UL: Gmail respects padding on the container more consistently than margins on the list items.
Zeroing Margins: By explicitly setting margins to 0 or specific pixel values, you override the browser's default agent stylesheet, which varies wildly between iOS and Android Webview.

Mobile-First List Design Checklist

When formatting for mobile, your goal is readability in a narrow viewport (often 320px to 400px wide). Lists that look dense on a desktop monitor become unreadable blocks on a phone.

Follow these rules for mobile email 2026 compatibility:

Increase Line Height: Set line-height to at least 1.5. Mobile users need vertical breathing room to track lines of text.
Limit Horizontal Depth: Do not go deeper than two levels of nested bullets. On a mobile screen, a third-level indent often leaves only two or three words per line, creating a vertical ribbon of text that is impossible to read.
Add Vertical Spacing: Add padding-bottom: 8px or a simple <br> between list items. Tightly packed lists are difficult to tap if the list contains links.

A Concrete Before and After

Let's look at a real-world example of how a pasted list fails and how to correct it.

The "Dirty" Paste (What breaks): You copy a list from a Google Doc directly into Gmail.

The Code: Contains <span style="font-weight: 400; background-color: transparent;"> wrappers and generic <li> tags relying on Google Docs' internal CSS classes.
The Mobile Result: Bullets are tiny or missing. Text is flush left. If the Google Doc had a white background, the text might have a white background block behind it in Dark Mode, looking like a ransom note.

The Cleaned Structure (What works): You run the text through a cleaner or strip formatting.

The Code:

<ul style="padding-left: 24px;">
  <li style="margin-bottom: 8px;">First key point clearly defined</li>
  <li style="margin-bottom: 8px;">Second key point with breathing room</li>
</ul>

The Mobile Result: Clean indentation. Native bullet points that scale with the font size. Text color that adapts to the user's theme.

Dealing with "Phantom" Indentation

Have you ever sent an email where the bullet points are aligned, but the text is indented an extra inch to the right? This is usually caused by the text-indent CSS property.

Some web editors use text-indent: -1.5em combined with a padding-left to create a bullet effect without using a list tag. When this translates to mobile:

The negative indent is often ignored or calculated differently based on screen width.
The padding remains.
The text ends up floating in the middle of the screen.

If you see this happening, inspect your source or use a text cleaner. You are looking for negative values in text-indent or margin-left. Delete them.

The PasteClean Method

We built PasteClean because we were tired of manually editing HTML to fix these issues. The tool automates the logic described above. It parses your clipboard content, identifies the "dirty" HTML tags that confuse mobile renderers (like mso-list, complex span wrappers, and fixed pixel widths), and replaces them with semantic, email-safe HTML.

It specifically rewrites lists into the inline-styled format that Gmail for Android and iOS prefers. It ensures that <ul> tags have the correct padding and that <li> tags are stripped of conflicting background colors. It’s not magic; it’s just applying strict sanitation rules to the messy code generated by modern browsers and AI tools.

Conclusion

Formatting email for mobile isn't about making it look "pretty"—it's about structural integrity. When you rely on the default clipboard behavior, you are gambling that the recipient's rendering engine matches yours. In the fragmented landscape of 2026 devices, that's a bet you will lose.

By understanding the limitations of the Gmail mobile rendering engine—specifically its hatred of external CSS and confusion over Microsoft XML—you can force your lists to render correctly. Whether you choose to hard-code inline styles or use a tool to scrub your text, the goal is the same: strip the complexity, respect the