Moving Marketo email templates to Mautic is mostly a design job, not a copy job. Our client, a German B2B distributor, sent its weekly newsletter from one long Marketo template that held every section the team had ever needed. We rebuilt it in the Mautic email builder as a library of about ten blocks. Here is how we do it, stage by stage, with the checks we run before the first real send.
Why rebuild a Marketo template as a block library?
The client’s Marketo template was one long email. It contained every possible section: hero, articles, product tiles, event teasers, banners, contact boxes. Every week the team cloned it and deleted what it did not need. It worked. It was also slow, and a deleted section was gone until the next clone.
A straight copy of that HTML into Mautic would have carried the same habit into a new tool. We took a different route. We split the template into reusable blocks and loaded them into the Mautic email builder, which runs on GrapesJS. Now the team drags sections in from the side panel instead of deleting them.
The weekly routine stayed the same. The team clones last week’s newsletter, swaps the content, adds or removes a block and sends. Nobody had to learn a new way of building a newsletter. That matters more than any feature when a migration runs against a licence deadline.
How do Marketo email assets map to Mautic?
Marketo and Mautic name things differently, and some Marketo objects have no direct twin. This is the mapping we work from:
| Marketo | Mautic equivalent | What changes |
|---|---|---|
| Email template (Design Studio) | Email theme (a folder with config.json and Twig files) | The theme holds the base layout. Mark it for the GrapesJS builder in config.json. |
| Template modules | Builder blocks and sections | Blocks are copied into the email when you drop them in. |
| Snippets (shared header, footer) | Theme blocks, or fixed parts of the theme layout | A Marketo snippet is a live reference. A Mautic block is a copy. Content that must change everywhere lives in the theme. |
| My Tokens (program level) | Contact field tokens with fallbacks, email settings, Twig variables | Mautic has no program-level tokens. Each token gets a new home. |
| Velocity email scripts | Twig logic in the email body | Core tokens offer only a fallback value. Conditions need a Twig extension. |
| Dynamic content (segmentation based) | Dynamic content with contact filters | Mautic picks a variant per contact from filters on fields, segments or tags. |
| Landing page templates | Page themes ("features": ["page"]) | Pages and forms can stay on the client’s own subdomain. |
The snippet row changes how a team maintains shared content. In Marketo you edit a snippet once and every email that uses it updates. In Mautic, a block dragged into last week’s newsletter is part of that email. If the legal address changes, you change it in the theme or in the newest newsletter, and the next clone carries it forward.
The Velocity row is where most of the logic hides. We cover it in stage 5.
For the full picture of what transfers from Marketo and what needs a rebuild, see our post Marketo to Mautic migration: what transfers and what you have to rebuild.
Stage 1: inventory templates, snippets and tokens
Start with a list, not with HTML. The Marketo API returns email templates, snippets and the My Tokens folder. It also returns email HTML in two forms: fullContent with tokens resolved and content with the raw markup. Pull both. The raw version shows you which tokens each email uses. The resolved version shows you what the contact actually saw.
Some assets do not come through the API cleanly. Our developer copied those from the Marketo interface into files, so the whole inventory sat in one repository.
For each asset we record:
- where it is used (newsletter, flow emails, event mailings),
- which modules or sections it contains,
- which tokens and scripts it calls,
- which brand it belongs to,
- whether anyone sent it in the last months.
The last column cuts the work. A template nobody uses does not need a Mautic version. In this project one template carried almost everything, with header and footer snippets per brand. The My Tokens folder held the salutation script and a few simple values such as the sender and the copyright year.
Stage 2: decide the block set
Now look at the sent emails, not at the template. Which sections did the team actually keep, week after week? In our client’s newsletters about ten modules covered nearly every issue. Those became the library.
For a weekly B2B newsletter the set usually looks like this:
- header with logo (one per brand),
- hero image with headline and button,
- text block with headline,
- article with image left or right,
- two-column product or article tiles,
- full-width banner,
- button row,
- event teaser with date and location,
- contact person box,
- footer (one per brand).
Three decision rules keep the library small:
- A block earns its place by use. If a section appeared in fewer than a handful of sent emails, it does not get a block. A text block with an image covers it.
- Variants beat options. Two clear blocks (“image left”, “image right”) are easier for editors than one block with hidden settings.
- Brand lives in the header and footer. Content blocks stay neutral, so both brands can share them.
Stage 3: build the base template
The base template is a Mautic email theme. It holds the outer layout: background, content width, fonts, the preheader, and the fixed parts of the footer such as the unsubscribe and web view links. Mautic provides tokens for those links ({unsubscribe_url}, {webview_url}), so the theme can place them once.
You can write a theme in plain HTML or in MJML. MJML blocks move freely in the GrapesJS builder. HTML themes stay table based, which keeps the markup close to a Marketo original but makes blocks harder to rearrange. Check how your Mautic setup handles dynamic content for the markup you choose before you commit to it.
We did not retype the Marketo HTML. Our developer built converters that took the Marketo modules, removed Marketo-specific attributes and classes, replaced Marketo tokens such as {{lead.First Name}} with Mautic tokens such as {contactfield=firstname}, and wrote the result into theme blocks.
Then came the comparison. For every template we rendered the Marketo original and the Mautic version at the same widths, took screenshots and compared them pixel by pixel. The diff image marks every area that differs. A shifted button, a different line height, a missing border: each shows up as a coloured patch. The developer reviewed every diff and fixed the block, not the single email. An AI coding agent helped write the converters and the diff scripts. The developer decided what counted as a match and approved each result.
Run the comparison at a desktop width and a mobile width. Most differences hide in the mobile layout.
Stage 4: add brand variants
The client runs a second brand with its own colors. In Marketo it used the same template with different header and footer snippets and different module colors.
In Mautic the second brand got its own header and footer on the same base. Everything in between stays shared. When the team builds an email for the second brand, it drops in that brand’s header and footer blocks. The content blocks pick up the brand’s accent color through a small set of style choices in the block.
Keep brand variants on one base for as long as the layouts match. Two separate themes double the testing for every change. Split into a second theme only when the layout itself differs, for example a different content width or a different font stack.
Stage 5: personalization and salutations
German B2B email depends on a correct salutation. “Sehr geehrter Herr Müller” and “Sehr geehrte Frau Müller” differ in more than the title, because the adjective changes too. A wrong or empty salutation in the first line is the fastest way to look careless.
In Marketo the logic sat in a Velocity script stored in My Tokens. It worked roughly like this: if the salutation and the last name exist, write the formal greeting with the last name. If first and last name exist but no salutation, write “Hallo” with the full name. We ported the script, including its list of placeholder values that should count as empty.
Mautic core tokens support a fallback value, for example {contactfield=firstname|there}, and nothing more. For conditions we use Twig in the email body, which needs a Twig extension or a small patch. The ported logic looks like this:
{% set s = contact.salutation|default('')|trim %}
{% set fn = contact.firstname|default('')|trim %}
{% set ln = contact.lastname|default('')|trim %}
{% set placeholders = ['test', 'x', '.', '-'] %}
{% if ln|lower in placeholders %}{% set ln = '' %}{% endif %}
{% if fn|lower in placeholders %}{% set fn = '' %}{% endif %}
{% if s == 'Herr' and ln %}Sehr geehrter Herr {{ ln }},
{% elseif s == 'Frau' and ln %}Sehr geehrte Frau {{ ln }},
{% elseif fn and ln %}Hallo {{ fn }} {{ ln }},
{% else %}Sehr geehrte Damen und Herren,
{% endif %}
Variable names depend on the extension you use, so treat this as a pattern. Put the salutation in one block and use that block everywhere. Do not paste a copy of the logic into each email.
The other My Tokens need homes too. The sender name and address live in the email settings. The copyright year can come from Twig. Anything that belongs to the contact comes from a contact field token with a fallback.
Mautic can also change content based on contact data, for example a footer that shows different details to different groups of contacts. Dynamic content picks the variant at send time from filters you set on fields, segments or tags. Test every variant with a real test contact, because the builder preview shows only the default.
Stage 6: test across email clients
Your list decides the test matrix. For a German B2B audience we test in:
- Outlook desktop on Windows, which renders with the Word engine and ignores much modern CSS,
- Outlook on the web and the new Outlook,
- Gmail on the web and in the Android and iOS apps,
- Apple Mail on macOS and iOS, in light and dark mode,
- GMX, WEB.DE and T-Online webmail, which German consumers and small businesses use widely.
Preview tools help, but send tests to real inboxes from the production sending setup as well. Real sends show what the sending domain, link tracking and the mailbox provider do to the email. We run the checklist below on every block, then on two or three full newsletters built from those blocks.
Stage 7: train the team
Training works best when it repeats the team’s real week. We run it on a copy of last week’s newsletter:
- Clone the newsletter.
- Replace the hero, edit two articles, delete one block.
- Drag a new block in from the side panel.
- Switch to the second brand’s header and footer.
- Send a test to a test segment and check it on a phone.
- Schedule the send to the real segment.
We leave a short runbook next to the training: which block does what, where the salutation block lives, how to send a test, and whom to ask. The marketers who tested the migrated emails already know the blocks by then, so training usually takes one session.
Design rules for every block
Each block has to meet these rules before it goes into the theme.
Responsive
- Design for a 600 px content width on desktop.
- Stack columns below phone width. Two tiles side by side become two rows.
- Make buttons at least 44 px tall and wide enough for a thumb. Build them from table cells, so Outlook draws them too.
- Use web-safe fallback fonts after any brand font.
- Keep font sizes at 14 px or more for body text and 20 px or more for headlines on mobile.
Dark mode
- Expect some clients to invert colors and others to leave them alone. Design for both.
- Give logos a transparent background with a light outline or a light version, so a dark logo does not vanish on a dark background.
- Avoid pure black text on pure white. Slightly softer values survive inversion better.
- Add the
color-schememeta tags and aprefers-color-schemestyle block for clients that support them. - Never put important text inside images. Inverted backgrounds around a text image look broken.
Image sizes
- Export images at twice the display width (1,200 px for a full-width image) and set the display width in the HTML.
- Keep each image small, ideally under 200 KB.
- Give every image alt text that still makes sense when images are blocked.
- Watch the total HTML size. Gmail clips messages above about 102 KB and hides the rest, including your footer and unsubscribe link.
Plain-text part
- Every email needs a plain-text version. Mautic can generate it from the HTML in the email’s advanced settings.
- Check it after any structural change. Generated text can keep hidden preheader text or lose button labels.
- Make sure the salutation and the unsubscribe link appear in the text version as well.
A QA checklist before the first send
Run this for every block and for each full email before it goes to a real segment:
- Rendering. The email matches the approved design in every client of the test matrix, in light and dark mode.
- Mobile. Columns stack, images scale, buttons are tappable, nothing scrolls sideways.
- Links. Every link opens the right page, tracking works, UTM parameters are present where the team uses them.
- Unsubscribe and web view. Both links work and lead to the right brand’s pages.
- Tokens with empty values. Send to test contacts with an empty first name, an empty last name and an empty company. No raw token, no “Hallo ,” with a stray comma.
- Salutation fallbacks. Test each branch: “Herr” with last name, “Frau” with last name, names without a salutation, placeholder names, nothing at all.
- Dynamic content. Each variant reaches a test contact that matches its filter. The default shows for everyone else.
- Brand variants. The second brand’s header, footer, colors and links appear together, never mixed with the first brand’s.
- Plain text. Readable, with salutation and unsubscribe link.
- Size. HTML stays well under the Gmail clipping limit.
- Sender. From name, from address and reply-to match the brand.
- Subject and preheader. Both display fully on a phone.
Keep a set of test contacts in Mautic with these edge cases on purpose. You will use them for every new block.
What happens to forms and landing pages?
The client’s newsletter sign-up, account preferences, thank-you pages and event landing pages ran in Marketo on the client’s own subdomain. They stay there with Mautic. Marketo landing page templates become Mautic page themes, and the forms become Mautic forms on those pages. The Mautic admin panel runs on a separate subdomain.
Old links in emails and on the website keep working, and contacts see an address they know. For the steps that run after a sign-up, see our post on double opt-in with voucher codes in Mautic.
FAQ
Can I import Marketo email templates into Mautic directly? Not as working templates. You can export the HTML through the Marketo API, but Marketo modules, snippets and tokens need conversion. We convert the HTML into a Mautic theme and blocks, then compare the result with the original pixel by pixel.
Does Mautic have snippets like Marketo? Not as live references. A builder block is copied into the email. Shared content that must change everywhere at once belongs in the theme layout.
How many blocks should the library have? As many as the team uses. For a weekly newsletter that is often around ten. Count the sections in the last few months of sent emails and start there.
Can Mautic handle German salutations? Yes. Simple tokens give you a fallback value. Gender-specific greetings with fallbacks need Twig logic in the email, through an extension or a small patch.
Will the team need long training? Usually not, if the weekly routine stays the same. Cloning last week’s newsletter and dragging blocks in from the side panel is close to how most Marketo teams already work.
Want your Marketo templates rebuilt in Mautic?
This is one of the building blocks of our Marketo to Mautic migration for Meesenburg.
Send us one of your current templates and a few recent newsletters. We will propose a block set and show you how your team’s weekly routine will look in Mautic. Talk to the Mautomic team.
Tags
Written by
Mautomic Team
Mautic experts sharing insights on marketing automation, custom development, and open-source technology.