New Outlook, same headache 

We all rejoiced with the announcement of the One Outlook project set up to unify Outlook across platforms. The release of the New Outlook for Windows, which uses Chromium-based rendering rather than MS Word's, was a great sign. At first glance, it seems very similar to the rendering of Outlook.com in a Chromium browser.

However, in the email world, we have learned that we can’t have nice things, and since its release, there have been a few rumblings of an issue with the New Outlook.

This issue was first raised with me as a border radius issue. An element had a radius set on the top 2 corners border-radius: 20px 20px 0 0; but when it rendered in Outlook it converted it to radius on all 4 corners border-radius: 20px;.

We’ve also seen reports of shorthand background properties breaking. And all head <style>s being ignored.

Others have seen media queries not being triggered, I’ve seen this too. It’s often most noticeable on mobile first designs where a desktop media query isn’t being triggered.

There is a range of potential issues that show up but a few things they have in common:

• These issues only ever appear in the preview pane. If you double click on the email to open it in its own window, then the issues no longer appear.
• Sometimes the correct rendering will appear at first for a split second before the broken version is shown.
• These are CSS issues. We haven’t yet seen any issues related to HTML.
• These issues are inconsistent. One email may appear broken and an identical one may work as expected.

Until recently, I had no idea; however, in a conversation over on the EmailGeeks Slack group, it turns out Brian Thies (a well-known name in the email community) had already been digging into this using DevTools and shared some of his findings. With his permission, I’ve included some of these findings below.

From what he’s seen, there are likely two separate things happening.

The first is an issue with WebView2, the browser engine that New Outlook uses to render emails. If WebView2 hasn’t been installed or updated correctly, it can lead to rendering issues in the preview pane.

However, that doesn’t fully explain the behavior people are seeing.

In many cases, the email renders correctly for a few seconds before breaking. That suggests something else is happening after the initial render.

Brian noticed that New Outlook appears to run a post-processing step after the email loads. This is likely responsible for UI features like the “expand” button and text interactions, but it may also be modifying the email itself.

This suggests that Outlook may be rewriting styles after load, potentially as part of a CSS inlining process, but in a way that strips or alters certain properties.

Putting this together, the behavior starts to make more sense:

• The email initially renders correctly (before post-processing)
• Then a script runs that modifies the DOM
• And that’s when layouts shift or styles break

It’s also possible that these two things are connected. As Brian put it:

This points to a combination of factors:

• Issues with how Outlook’s rendering engine (WebView2) is installed or behaving on some machines
• And a post-processing step that modifies the email after it initially renders

There isn’t any specific fix we’ve found, but if you want to, there are a few things you could do to simplify aspects of your email design to minimise the issues. These could include:

• Using a single column design to avoid column stacking issues.
• Avoiding background images, use inline images instead
• Keep properties like border-radius even on all sides.
• If you are using a mobile first approach you could switch to desktop first, which would help here, but that could also cause issues in a number of mobile email clients. So instead look to keep styles more consistent between desktop and mobile.

The adjustments you need to make will depend on the issues you are seeing.

I would like to dig into this issue further to better understand it, and potentially see if there are any clever tricks to avoid it or to fall back more gracefully. However, when I set aside some time to do that, I no longer had the issue. I know Brian is looking to investigate this more, too, and likely some other folks in the industry will be doing the same. I do love how collaborative our industry can be.

My general feelings and advice to others are this: it's an edge case; it’s not happening for every user; the issues are minimal (in the cases I’ve seen). I also feel like this is temporary. I’m not seeing it on my machine anymore; others who have updated no longer see it. My plan is to keep an eye on things but not panic or make any big changes yet.

Why does my email render correctly at first, then break in New Outlook?

In many cases, the email renders correctly on initial load, then changes a moment later. This suggests New Outlook is running a post-processing step after rendering—likely modifying the DOM or rewriting styles—which can cause layouts or CSS to break.

Are these rendering issues happening in all versions of Outlook?

No. These issues are specific to the New Outlook for Windows, particularly in the preview pane. Other versions of Outlook (including the classic desktop app) don’t show the same behavior.

Do these issues affect the full email view or just the preview pane?

So far, the issues appear limited to the preview pane. When the email is opened in its own window, it typically renders correctly.

Is there a reliable fix for these issues?

There isn’t a single confirmed fix yet. Most workarounds involve simplifying email design—such as avoiding complex layouts, keeping styles consistent, and reducing reliance on specific CSS features.

Should I change my email designs because of this?

Not necessarily. This appears to be an edge case and may already be resolving for some users after updates. It’s worth monitoring, but not something that requires major changes. However if you are seeing consistent issues that make the content harder to consume, you may want to think about trying some changes.

Are these issues consistent across all emails?

No. The behavior is inconsistent—some emails may render incorrectly while identical ones display as expected. This makes it harder to debug and suggests multiple factors are involved.