Your cold email campaign is live. Your subject lines are solid. Your copy converts. But then someone opens your email on Gmail and sees a mangled mess - broken formatting, text running off the screen, images stacked weirdly, or buttons that look nothing like what you designed.
Welcome to the cold email rendering problem. This is the gap between "your email looks good in your inbox" and "your email looks good in every inbox." Most people ignore it until they realize recipients are bouncing because they can't read the email on mobile, or the call-to-action is unclickable.
Here's what actually matters for Gmail rendering, and what you can do about it starting today.
Gmail's Rendering Engine Works Differently Than You Think
Gmail doesn't render HTML the way Outlook does, or Apple Mail, or mobile clients. Gmail strips out a lot of CSS - especially anything that uses external stylesheets or certain types of inline styling. It also has quirks around width constraints, font support, and how it handles images.
The practical impact: an email that looks perfect in your design tool can look completely broken in Gmail. And since Gmail is where your B2B prospects are checking email, this matters.
Gmail's webmail interface renders emails at a max-width of about 600px on desktop. On mobile, it's even narrower - typically 320-480px depending on the device. Gmail also strips out external font files, so any custom fonts you loaded from Google Fonts will fall back to system fonts (Arial, Times New Roman, Georgia). This is why your carefully chosen font choice doesn't matter in Gmail - it won't load.
The Core Rendering Rules That Actually Affect Your Email
1. Build for 600px max-width on desktop
Your email template needs to be designed around a 600px container, not 800px or 1000px. If you build wider than this, Gmail will squash it or force horizontal scrolling on desktop. On mobile, Gmail will then scale it down further, making text unreadable.
This means your email design tool should have a 600px canvas as the maximum, not a suggestion. Check your template settings. If you're using a builder like Stripo or Dyspatch, set the width to 600px and never exceed it.
2. Use inline CSS, not external stylesheets
Gmail strips external stylesheets. This means any CSS you load from a separate file will be ignored. You need inline styles - `style=""` attributes directly on your HTML tags.
This also means you can't rely on media queries for mobile responsiveness the way you would on a website. You need to build emails that work acceptably at both 600px and 320px without CSS media queries doing the heavy lifting.
3. Test images carefully - they're the biggest rendering problem
Images are the #1 cause of rendering issues in Gmail cold emails. Here's why: if an image is wider than the email's max-width, Gmail will scale it down, which can distort it. If you're using image-based buttons or CTAs, they might become unclickable on mobile. If you rely on image text (like a banner with text inside the image), it becomes unreadable when scaled.
The fix: keep all images at or below 600px wide. Use alt text on every image - not just for accessibility, but because Gmail will show the alt text if an image fails to load, which happens more often than people realize. Never put critical copy or CTAs inside images. If you need a button, build it in HTML with a styled link, not as an image.
What Gmail Actually Strips Out (And What It Keeps)
Gmail will strip:
- External stylesheets and font files
- JavaScript (all of it - don't even try)
- Some CSS properties like `position: fixed`, `z-index`, and certain `box-shadow` properties
- Certain background images on divs (though background images on table cells usually work)
Gmail will keep:
- Inline styles on most standard CSS properties (color, font-size, padding, margin, background-color)
- Tables and table-based layouts
- Basic links and CTAs
- Images with proper sizing
This is why email templates are built around tables and inline styles - it's the most Gmail-compatible approach, even though it feels archaic if you're used to building web pages.
A Practical Rendering Checklist
Before you send a cold email campaign, test the actual email in Gmail (not a preview tool - the real thing). Open it in the Gmail webmail client on desktop. Then open it on a mobile device in Gmail's mobile app. Here's what to check:
- Does text run off the edge of the screen? If yes, you're probably exceeding 600px width.
- Are images squashed or distorted? If yes, they're too wide or don't have explicit width attributes.
- Is the CTA button clickable and clearly visible? If it's image-based, test on mobile - it might be too small to tap.
- Do fonts look reasonable? Gmail will show system fonts, not your custom font choice.
- Is there unexpected spacing or gaps between sections? This usually means your table structure is off or padding isn't specified inline.
- Does the color scheme hold up? Some email clients invert colors on dark mode - test this if you're using dark backgrounds.
If something looks broken, the issue is almost always one of three things: width exceeding 600px, images without explicit sizing, or CSS that Gmail stripped out.
The Real Rendering Impact on Cold Email Performance
Broken rendering directly affects your metrics. A cold email that looks mangled on mobile will have lower click-through rates. If your CTA button is unclickable or unreadable, people won't click it - they'll just delete the email. Recipients using dark mode might see white text on white background because you didn't test it.
Rendering issues also affect deliverability indirectly. If Gmail's rendering engine has to work harder to parse your email, or if it detects certain problematic CSS patterns, it can trigger spam filters. This isn't as direct as deliverability infrastructure problems, but poor rendering + thin content + tracking pixels can push you toward the spam folder.
The second-order effect: unclickable CTAs mean fewer conversions, which means your cold email provider thinks your copy sucks when really your template is broken. You optimize the wrong thing and never hit your benchmarks.
Tools That Actually Help With Rendering
Use MJML (Mailgun Juice Markup Language) or Foundation for Emails if you're building templates yourself. These frameworks are specifically designed for email rendering across clients. They handle the table/inline-CSS mess for you and do a better job of cross-client compatibility than most email builders.
If you're using a pre-built template from an email platform, test it in Gmail before you use it for campaigns. Don't assume it renders correctly just because it came from the platform.
Litmus Email Analytics will show you how your email renders in 70+ clients including different versions of Gmail (webmail, mobile app, etc.). It's worth the cost for cold email campaigns because you'll catch rendering issues before you send to 1,000 prospects.
Where This Gets Complicated at Scale
If you're sending 100 emails a week, testing rendering manually for each campaign is annoying but doable. If you're sending 1,000+ cold emails per month across multiple campaigns with variations, testing becomes a real bottleneck. You need templating systems that guarantee Gmail compatibility, automated rendering checks, and the ability to swap templates without breaking anything.
This is also where the overall cold email process matters - you need rendering to be built into your template standard, not checked ad-hoc. When you're managing campaigns for multiple clients or running multiple sequences, consistency and automation become the difference between "this usually renders okay" and "every email renders correctly, every time."
At BEC Growth, we handle the infrastructure side of this - templating, rendering checks, testing across clients, and updates as Gmail changes its rendering engine. The value isn't in knowing that 600px is the max-width; it's in not having to think about whether your next campaign will look broken in Gmail.