When your current license has a fixed end date, there is no time to deal with surprises halfway through the build. A marketing automation migration to Mautic goes smoothly when the plan surfaces those surprises before anyone starts building. We learned this the practical way: we moved a German B2B distributor from Marketo to Mautic in two months and went live before the old contract ran out. Here are the seven planning rules we took from that project. They apply whether you are coming from Marketo, HubSpot or Pardot.
Rule 1: start from the contract end date
Ask for the date the current license ends in the very first call, and plan backwards from there.
You cannot move a license deadline, so the only thing you can move is the scope. Our client had about two months from signature to go-live, with summer holidays on both sides in between. The table below shows how we laid the project out, starting from the deadline and working back:
| Stage | What happens | What it waits on |
|---|---|---|
| Buffer | A few working days before the license ends, kept free | Nothing. It absorbs delays |
| Cutover | Final import, delta import, integration switch, first live sends | Passed dry runs and acceptance |
| Acceptance testing | Client’s marketers click through every flow, we fix | A test environment with migrated data |
| Dry runs | Full import and campaign setup on test, repeated until clean | Field map and finished build |
| Build | Fields, segments, templates, campaigns, forms, integration | Discovery output |
| Discovery | Inventory, field model, automations, integration, sending | License date and account access |
| DevOps (parallel) | Server, Amazon SES, DNS, dedicated IP | Starts on day one |
| After go-live | IP warm-up, phase two features | Real sending from Mautic |
Once the timeline is clear, the next decision is what has to run on day one. We use a simple test: if something sends email or records consent automatically, and it would stop silently the moment the old platform is switched off, it belongs on day one.
In this project, day one covered:
- about 95,000 contacts with their consent history,
- the weekly newsletter,
- the shop activation flows,
- double opt-in with a voucher code in the welcome email,
- the integration that feeds Mautic from the client’s ERP and CRM.
Event mailings went to phase two. After go-live we built a reusable event pattern for them: invitation email, landing page, registration form and thank-you page. The old event history stayed in the Marketo archive.
Rule 2: ask for the inventory, not the number of flows
“We have a weekly newsletter and two automated flows.” Most briefs sound like this, and it is rarely the whole story. Marketing teams think in campaigns, not in platform objects, and the platform always holds more than the team remembers.
Before we price a migration, we ask for read-only access or the internal documentation, walk through the Marketing Activities tree and count the objects:
| What to count | Why it drives effort |
|---|---|
| Programs and smart campaigns | Each maps to a Mautic campaign or segment. Flow steps are visible only in the Marketo UI |
| Engagement program streams | One program becomes several Mautic campaigns with gates and hand-offs, so emails never overlap |
| Emails and templates | Each email gets rebuilt in the Mautic builder and compared with the original |
| Smart lists and static lists | They become segments. Filters need translation, and some have no direct equivalent |
| Forms and landing pages | They get rebuilt and need their own subdomain and DNS records |
| My Tokens, snippets, Velocity scripts | Logic in tokens and scripts gets rewritten in Twig |
| Webhooks | Each one becomes a custom campaign action or part of the integration |
| Custom fields | Each field needs a mapping decision. Fill rates tell you which ones to drop |
| Program member fields | The Lead API does not return them, so they need a separate path or stay in the archive |
| Operational programs | Bounce handling, activity dates and inactivity flows run in the background. The marketing team rarely mentions them |
Our audit of this client’s account turned up far more than two flows:
- five automations behind the “two flows”,
- double opt-in with reminders and voucher codes delivered by a webhook,
- content that changes by location,
- a second brand with its own header and footer,
- event programs with forms and landing pages,
- salutation logic in Velocity script,
- housekeeping programs for bounce categories, activity dates and inactivity,
- an engagement program with 22 active emails in three streams.
The field export showed 213 custom fields. A fill rate check flagged about 30 of them as dead weight (social fields, inferred location, placeholders) before the mapping even started. None of this is unusual for an account that has been running for years. It is simply the only honest basis for an estimate.
Rule 3: make discovery its own phase
Discovery is the most valuable phase of a migration. For an account like the one above it takes several meetings and a fair amount of email back and forth. We price discovery separately and fix the migration price only after it, so the scope reflects what actually runs in the account rather than what the brief said.
A typical discovery agenda looks like this:
| Meeting | Who joins from the client | Output |
|---|---|---|
| Scope walk-through | Marketing lead | Confirmed inventory, day-one list, phase-two list |
| Field model | Marketing, CRM or ERP owner | Field map, source of truth for each group of fields |
| Automations | The marketer who runs the flows | One diagram per flow: entry, emails, waits, conditions, exit |
| Integration | Middleware or IT team | Data direction, matching identifiers, API calls they plan to use |
| Consent | Marketing, data protection | Double opt-in rules, how consent history moves |
| Sending and DNS | IT, DNS owner | Amazon SES account owner, IP type, list of DNS records |
The written output is a migration plan, a field map and a fixed scope.
People versus companies
This decision deserves its own meeting. Which data lives on the contact, which on the company, and which system is the source of truth for each?
In this project the business data sits on a separate company record, matched by the ERP customer number. About 64 fields live there. A contact can belong to several companies, with one of them marked as primary.
That model changes how Mautic behaves in ways that are easy to miss:
- A positive segment filter on a company field matches a contact if any of its companies matches.
- Each filter row is checked separately, so two company conditions can be satisfied by two different companies of the same contact.
- A negative filter (“no company has X”) needs a workaround: a positive helper segment plus a “segment membership: not in” filter.
- When several contacts of one company hold different values for a field, moving that field to the company keeps only one value.
We settle the company model before the first import, because every segment, campaign condition and integration call depends on it.
The integration meeting matters for the same reason. Middleware developers may be planning API calls the marketing team has never mentioned, so we ask them directly. In this project the client’s own team owns the middleware. We delivered API and data model documentation, a Postman collection and developer support, and they did the rest.
Rule 4: give DevOps its own line
The marketing team never sees DevOps work, which makes it easy to leave out of an estimate. In a Mautic migration it takes a real share of the effort:
- the server or hosting setup, cron jobs and queue workers, backups and monitoring,
- the Amazon SES account, production access and sending limits,
- the dedicated IP and its pool,
- SPF, DKIM and DMARC records, plus the subdomains for the Mautic admin, landing pages and forms,
- the bounce and complaint webhook from SES to Mautic through Amazon SNS,
- tests of that webhook with the SES mailbox simulator.
All of it gates the go-live, so we put it in the offer as a separate item and name the client’s DNS owner up front.
DNS needs the longest lead time of all. We prepare the records in a day, but the client’s IT applies them when it can. In this project that took 19 days in the middle of summer. We now plan two to three weeks for DNS and send the record list in the first week of the build.
Rule 5: plan acceptance testing with the client’s team
Our testers know Mautic. The client’s marketers know their own campaigns, how the old platform behaved and what each email is supposed to do. Acceptance testing needs both.
That is why it needs a proper setup, not just a slot in the schedule:
- a test environment with a copy of the migrated data,
- a named person on the client side, with about two weeks reserved to click through every flow,
- a test script per automation: how a contact enters, which email comes when, what makes it exit,
- one round of fixes after the feedback, then a short retest.
Our own testing runs first. Email templates get a pixel-by-pixel comparison with the originals. The double opt-in flow runs end to end, voucher code included. SES simulator addresses confirm that bounces and complaints land in Mautic as Do Not Contact records with the right reason.
One more thing to do before the cutover: export three months of the old platform’s deliverability numbers. Without that baseline, nobody can answer the question “is it better or worse now?”.
Rule 6: schedule the IP warm-up after go-live
A dedicated IP builds its reputation from real sending, and real sending only starts after the cutover. So the warm-up belongs to the first weeks after go-live, not to the project timeline before it.
Amazon SES offers two dedicated IP modes, and they warm up differently:
- Standard dedicated IP. SES follows a fixed schedule of about 45 days. During that time part of your email goes through shared IPs, regardless of your volume.
- Managed dedicated IP. SES decides the split between your dedicated IPs and the shared pool based on your real sending, separately for each mailbox provider. An IP that is warm for Gmail can still be cold for Outlook.
This project uses a managed dedicated IP. The client sends one large newsletter a week, so the warm-up moves more slowly than it would with daily sending. We split the first big sends into growing waves and set the Mautic send batch size to stay under the account quota (here 50,000 emails a day at 14 per second).
Put the warm-up in the offer, and check whether a dedicated IP fits the sending pattern at all. AWS itself recommends the shared pool for senders who do not send large volumes regularly. We describe the details in our post on Mautic with Amazon SES.
Rule 7: keep one person from discovery to delivery
A migration touches three systems at once: the old platform, Mautic and the sending service. Discovery builds up detailed knowledge of the client’s setup, and that knowledge should stay with the person who built it.
Three rules we follow:
- The person who runs discovery stays on the project until go-live.
- During discovery, that person has time reserved for this project and nothing else.
- Sales hands over in a meeting with the project manager and the developer, walking through the scope and the open questions. A folder of emails and call transcripts is a supplement, not the handover.
Continuity matters after go-live too. In this project the same team runs the managed Mautic server under a maintenance plan, so the people who built the flows are the ones answering questions about them.
How our developers use AI coding agents
Our developers use AI coding agents to analyze platform exports and APIs quickly and to draft repeatable migration scripts. The developer stays in charge: they decide the mapping, review every script and approve every run.
In this project the repository held instructions for the agent, a validation checklist and working notes. The migration pipeline is plain Python. Some Marketo assets have no API, so the developer copied them from the UI into files by hand. The scripts run the same way on test and on production, which makes each dry run cheap to repeat. The agent speeds up the work, but the understanding of what the client needs stays with the team.
How should the cutover work?
Plan the cutover with a way back. The old platform keeps running until the new one has proven itself.
Our cutover runs in this order:
- Main import on production, using the same scripts that passed the dry runs.
- Count checks against the source: contacts, Do Not Contact records, consent fields, segment sizes.
- First Mautic sends to internal and small segments, checked for rendering, tracking and delivery.
- The integration switches from Marketo to Mautic.
- Delta import of every contact that changed after the main import. New sign-ups and fresh unsubscribes matter most here.
- Live sends in waves while the IP warms up.
- A full export archive of the old platform before the license ends.
The rollback path stays open until step 6 runs clean. Marketo keeps running until the Mautic sends are validated, and the integration can point back to it if a blocking issue appears.
A planning checklist
Run through this list before you send an offer for a marketing automation migration:
- License end date of the current platform, and a buffer before it
- Day-one list and phase-two list, agreed in writing
- Read-only access or internal documentation of the current setup
- Full inventory: programs, streams, emails, forms, landing pages, tokens, scripts, webhooks, operational programs, integrations
- Field export with fill rates, a person-versus-company decision and a source of truth per field group
- Integration contacts on the client side, with data direction and matching identifiers
- Consent rules: double opt-in, consent dates, how unsubscribes and bounces move
- Sending setup: SES account owner, shared or dedicated IP, standard or managed, sending pattern
- DNS owner, record list sent in week one, two to three weeks of lead time
- Deliverability baseline exported from the old platform
- Test environment and a named tester on the client side, with time in the schedule
- Cutover plan with a delta import and a rollback path
- Separate items in the offer: discovery, DevOps, acceptance testing, warm-up after go-live, training
- One named person from discovery to go-live
FAQ
How long does a Marketo to Mautic migration take? It depends on the inventory. This project took two months from contract to go-live for about 95,000 contacts, five automations and an ERP and CRM integration. A smaller account can move faster. A larger one usually needs a phase two.
Can we migrate in phases? Yes. Move everything that sends email or records consent on day one. Event programs, rarely used campaigns and reporting can follow after go-live.
What happens to consent and unsubscribes? Unsubscribes, bounces and blocked addresses become Mautic Do Not Contact records with a reason. The double opt-in flag and consent dates move to contact fields. New subscribers confirm in Mautic, which records the flag and the date itself.
Do we need a dedicated IP? Usually only if you send large volumes regularly. For small or irregular volumes the Amazon SES shared pool is often the better choice. Decide it during discovery.
Can we keep the old event history? Marketo program member fields do not come out through the Lead API, and Mautic has no concept of program membership. We keep that history in the Marketo archive and set up a new event pattern in Mautic.
Want a realistic plan for your migration?
We ran this project for Meesenburg, a German building hardware distributor. Mautic replaced Marketo as the old contract ran out, and about 95,000 contacts, the newsletter, the shop flows and the CRM integration moved with it. Read the full Marketo to Mautic migration case study.
Send us your contract end date and a rough picture of your setup. We will come back with a discovery plan and an honest timeline. Plan your Mautic migration with us.
Tags
Written by
Mautomic Team
Mautic experts sharing insights on marketing automation, custom development, and open-source technology.