Illustration representing the process from Figma email design to HTML email development

Figma to HTML Email: What Happens After the Design Is Approved?

The email design is finished. Everyone’s happy, the copy is approved, the imagery is in place and, after a heroic amount of commenting, the Figma file is finally signed off.

At that point, it can feel like the difficult part is over. The design exists, so surely the next step is simply to turn it into HTML and send it.

In reality, that handover is where a different kind of work begins.

Turning a Figma email design into a working HTML email isn’t the same as converting a website design into code. The finished email needs to behave across Gmail, Outlook, Apple Mail, mobile devices, dark mode, different screen sizes and varying levels of HTML and CSS support. It also needs to survive blocked images, fallback fonts, dynamic content and whatever platform it eventually gets loaded into.

The Figma file shows what the email should look like. Email development works out how to preserve that design intent once it leaves the artboard and enters the inbox.

Can you convert a Figma design directly to HTML email?

There are tools and plugins that can generate HTML from a Figma design, and they can be useful as part of an email production workflow. But generating code isn’t really the difficult part.

A design tool operates in a controlled environment. An email doesn’t.

Figma lets you position elements exactly where you want them, use almost any font, create complex layouts and build visual treatments without worrying about how Outlook, Gmail or another email client might interpret them later. HTML email has to deal with all of those practical limitations.

So the real Figma to HTML email process isn’t simply design → export → done.

There’s another production layer involving design review, responsive planning, HTML development, email-client fallbacks, platform implementation, testing and QA. That extra work is what turns a visual design into an email that can actually be used.

Step 1: Review the Figma email design

Before writing any code, the design needs to be reviewed as an email rather than simply as a piece of creative.

That means looking at the overall width, number of columns, typography, spacing, backgrounds, buttons, image treatment and how the layout is expected to behave on smaller screens. It also means identifying areas that might need a fallback in Outlook or a different treatment in dark mode.

This doesn’t mean compromising the creative before development has even started. It means identifying the areas where the design and the realities of email need to meet.

The best time to discover that a particular layout is difficult to reproduce reliably is before the build has started, not once the campaign is due to go live.

Step 2: Work out what happens on mobile

A desktop Figma design only tells half the story.

Once that layout reaches a smaller screen, decisions need to be made about how columns stack, how images scale, how spacing changes and whether the order of the content still makes sense.

A good example is a desktop layout where one row contains an image followed by copy, and the next contains copy followed by an image. If both rows simply stack automatically on mobile, the content order can become awkward. Instead of getting a clean image → copy → image → copy sequence, you can end up with image → copy → copy → image.

That isn’t really a development problem. It’s a design decision created by responsive behaviour.

Responsive email development therefore isn’t simply about making the desktop design narrower. Sometimes the hierarchy and content order itself needs to change. Thinking about that before development begins creates a much cleaner handover and avoids the developer having to make design decisions after the creative has already been approved.

Step 3: Decide what should be live HTML

One of the biggest production decisions is deciding which parts of the design should remain live HTML and which should be exported as image assets.

It is rarely a good idea to flatten an entire email into one large image. Live text is generally more flexible, more accessible and more useful when images are blocked. Buttons are also usually better built as functioning HTML elements rather than having the label baked into an image.

At the same time, photography, product imagery, illustrations and more complex branded graphics naturally belong as image assets.

Most good email builds are a combination of the two. The aim is to preserve the visual design without turning the entire communication into one inaccessible picture.

Step 4: Prepare and optimise the assets

The imagery inside the Figma file isn’t always ready to use in the finished email.

Assets need to be exported at sensible dimensions, compressed appropriately and checked for anything that might create problems once the design enters a real inbox.

Transparent images are a good example. A dark logo on a transparent background may look perfect on a white Figma frame but become difficult to see if an email client changes the background in dark mode.

File weight matters too. There’s very little value in loading an unnecessarily huge image if the recipient is only ever going to see it at a much smaller size.

Good email production involves a lot of small decisions like this. None of them are particularly glamorous, but they’re what help keep the finished email fast, stable and visually consistent.

Step 5: Build the HTML email structure

This is where HTML email starts to look quite different from modern web development.

Email layouts still commonly use table-based structures because they remain one of the most reliable ways to create layouts across email clients with very different levels of HTML and CSS support.

That can look old-fashioned to someone coming from a front-end web background, but the goal is different. We’re not trying to build the most elegant website codebase. We’re trying to build an email that survives as many relevant inboxes as possible.

In email development, reliability usually beats novelty.

This is one of the reasons specialist HTML email development exists. The job isn’t simply knowing HTML and CSS; it’s knowing how those technologies behave inside email.

Step 6: Add responsive behaviour

Once the core structure has been built, the email needs to adapt to different screen sizes.

That can mean stacking columns, changing spacing, scaling images, adjusting typography, changing alignment or even reordering content. Some elements may also need different treatment on mobile if the desktop layout doesn’t translate cleanly.

This is why mobile behaviour is much easier when it has been considered in the original design. If a developer has to invent the entire responsive experience after approval, part of the design process is effectively happening after the design is supposed to be finished.

A good Figma email handoff makes those decisions as clear as possible.

Step 7: Account for Outlook

Sooner or later, Outlook enters the conversation.

Classic Outlook for Windows has historically used Microsoft’s Word-based rendering engine, which means some HTML and CSS techniques that behave perfectly well elsewhere need different treatment or fallbacks.

That can affect background images, buttons, spacing, columns, fonts and a range of CSS properties.

Sometimes the right answer is an Outlook-specific workaround. Sometimes it’s a simpler fallback. The important thing is understanding the difference between a harmless visual difference and something that actually stops the email from working.

An email doesn’t need to look pixel-perfect in every inbox, but it does need to remain readable, usable and recognisably on-brand.

We’ve gone into this in much more depth in our guide to Outlook email rendering.

Step 8: Consider dark mode

Dark mode adds another layer of complexity because some email clients transform colours, backgrounds and text when the user has a darker display setting enabled.

That means checking vulnerable areas such as logos, transparent imagery, contrast, buttons and coloured content blocks. In some clients, developers can provide specific dark-mode styling, but support isn’t consistent everywhere.

Again, this is much easier when it’s considered during design rather than bolted on after the build is finished.

We cover the subject in much more detail in our guide to dark mode email design.

Step 9: Add links, tracking and dynamic content

A finished email isn’t just a visual layout. It also has to function.

That means adding links, checking calls to action and incorporating whatever tracking, personalisation or platform-specific features the campaign requires.

Depending on the project, that might include merge fields, conditional content, unsubscribe functionality, preference-centre links, dynamic recommendations or tracking parameters.

Some of this may live inside the sending platform rather than the base HTML, which is why it helps to know where the email will ultimately be used before development is complete.

Step 10: Build it into the email platform

A finished HTML file still needs somewhere to live.

Depending on the project, the email might be built directly inside Klaviyo, Mailchimp, HubSpot, Salesforce Marketing Cloud, Marketo or another platform. In other cases, the final HTML may simply be handed over to the client’s internal team.

Different platforms handle templates, personalisation, editable content and reusable modules differently, so the final implementation often needs to reflect the environment in which the email will actually be used.

The visual design can remain consistent, but the production approach may vary.

Step 11: Test the email

This is the bit that can’t be skipped.

A design looking right in Figma doesn’t prove the build works, and an HTML file looking correct in a browser doesn’t prove it works in an inbox.

The finished email needs to be checked across the relevant clients, devices and environments, with particular attention paid to layout, spacing, typography, images, links, responsive behaviour, dark mode, fallbacks and tracking.

That doesn’t mean every email needs to be tested in every inbox ever created. The right testing plan should reflect the audience, the project and the environments that matter.

But it does mean opening the email in your own Gmail account and declaring it finished isn’t enough.

Step 12: Fix what testing finds

Testing usually finds something, and that’s not a failure. That’s the reason you test.

It might be a line wrapping differently in Outlook, a button needing an alternative treatment, a spacing issue on mobile or a dark-mode combination that doesn’t quite work.

The build gets adjusted and tested again.

Email development is iterative. The goal isn’t to write perfect code at the first attempt and never touch it again. The goal is to reach a stable, reliable finished result.

Step 13: Deliver something the client can actually use

The final deliverable depends on how the email is going to be used.

It might be a finished HTML file, a platform-ready campaign, a reusable template, a set of modular email components or part of a wider email design system.

If the email needs to be reused, the build also has to consider what happens after handover. Which areas need to be editable? Can somebody update the content without breaking the layout? Are the modules flexible enough for future campaigns?

A technically perfect template isn’t particularly useful if nobody understands how to use it.

For brands producing email regularly, this is where reusable email templates can make the production process considerably more efficient.

Figma email design vs HTML email

The difference between the two environments is easiest to understand when you stop thinking about development as a direct conversion.

Figma gives you a controlled canvas. You decide exactly where things go, which font is used and how every element appears.

HTML email has to deal with multiple screen sizes, responsive behaviour, fallback fonts, working links, dynamic content, dark mode and email clients with different rendering rules.

So the job isn’t really to copy the Figma file pixel for pixel.

The job is to preserve the design intent while making it work in the inbox.

Can AI or a plugin convert Figma to HTML email automatically?

Yes, to an extent — and these tools will continue to get better.

There are Figma plugins, email builders and AI-assisted development tools that can accelerate parts of the process. If you’re producing email regularly, there’s no sensible reason to pretend automation can’t be useful.

But generating HTML from a visual layout isn’t the hardest part anymore. The bigger challenge is generating something that behaves reliably in the awkward reality of email.

A generated build still needs questions answered. What happens on mobile? What happens in Outlook? What happens in dark mode? Are the fonts supported? Are the image assets optimised? Does the sending platform need editable modules or dynamic content? Are the links and tracking correct? Has anybody actually tested the finished email?

That’s the distinction between generating code and producing an email.

Automation can absolutely make production faster. What it doesn’t remove is the need to understand the environment you’re producing for.

What makes a good Figma email handoff?

A good Figma handoff doesn’t need to explain every pixel, but it should make the important behavioural decisions clear.

Ideally, the file should show the desktop layout, intended mobile behaviour, typography, spacing, button styles, image assets, links and any content that changes between versions.

If something behaves differently on mobile or requires a particular fallback, it helps enormously if that has already been considered.

The aim isn’t to create documentation for the sake of documentation. It’s to reduce guesswork between the people designing the email and the people responsible for making it work.

What if you only have the Figma design?

That’s absolutely fine.

You don’t need an existing HTML template or email-platform build before bringing in a specialist developer. An approved Figma file can be enough to start the production process.

From there, the design can be reviewed, any potential issues can be discussed and the most appropriate development approach can be agreed based on where the email needs to be used.

For agencies, this can be an especially useful way to work. Your internal team can retain ownership of the concept, copy, brand and creative direction, then hand over the approved Figma design to a specialist email production partner for responsive development, testing and delivery.

That production support can happen quietly behind the scenes as an extension of your team. It might be a single campaign when internal resource is stretched or ongoing white-label email production across multiple clients.

You handle the creative relationship. We handle what happens between the approved Figma file and the finished inbox-ready email.

How Email Squad turns Figma into HTML email

At Email Squad, we’re interested in both sides of the process.

The design matters, but so does what happens to it afterwards.

We can take an approved Figma email design and handle the responsive HTML development, email-client fallbacks, platform implementation, QA and testing needed to turn it into a finished email. Or we can handle the complete process from the initial email campaign design onwards.

The advantage is that design and development aren’t treated as two completely separate disciplines. The technical reality of email is considered early enough to avoid unnecessary compromises later.

Because the job isn’t really to make a Figma file into HTML.

It’s to make the design work as an email.

If you’ve already got the design ready to go, take a look at our HTML Email Development service and send it over.

Need a hand with this? See our Figma to HTML email service.

FAQ

Yes. An approved Figma email design can be developed into responsive HTML and adapted for the email platform where it will be used. The process also involves considering mobile behaviour, email-client compatibility, fallbacks and testing rather than simply exporting the visual design as code.

Plugins and other tools can generate HTML from Figma designs, but generated code isn’t automatically production-ready email HTML. It still needs to account for email-client support, responsive behaviour, Outlook, dark mode, platform requirements and QA.

Not necessarily, but defining the intended mobile behaviour makes development more predictable. If only a desktop design exists, decisions still need to be made about stacking, spacing, typography, image scaling and content order on smaller screens.

Table-based layouts remain widely used in HTML email because they provide more predictable rendering across email clients with different levels of HTML and CSS support, particularly restrictive or older environments.

Yes. Depending on the project, an email can be developed and implemented within platforms such as Klaviyo, Mailchimp, HubSpot, Salesforce Marketing Cloud and Marketo, with the build adapted to the platform’s templating and content requirements.

Yes. Production email should be QA tested for layout, responsive behaviour, links, images, typography, fallbacks and relevant email-client behaviour before delivery or launch.

Got the design? We’ll take it from here.

Send us your Figma file, tell us where the email needs to go and we’ll handle the development, testing and delivery.

Email Squad mascot pointing to the right

    Your Name*
    Your Email*

    Telephone*
    Company*

    Your Message*