Marketing automation migration with AI: 200+ email templates
A marketing automation migration run as a pipeline: AI cleans up 200+ near-duplicate email templates and moves them, with human checks and a reversible cutover.
This case is based on a real client, with details changed to protect them.
A marketing automation migration moves campaigns, customer journeys and email templates from one marketing tool to another without changing what customers receive.
A marketing team runs campaigns across several brands:
- The campaign logic and customer journeys live in a CRM journey platform.
- The email templates live in a separate tool, say Iterable.
- Over a couple of years, with many people editing and no one in charge of a template standard, the template tool grew to more than 200 near-duplicate templates.
The team cannot keep up. A CRM manager built a spreadsheet-and-script tool that generates templates faster. It is a good idea, and it solves about a tenth of the problem.
The team is now looking at a move to a cleaner tool (Customer.io is a common choice), and nobody wants to start it. Migrating 200+ messy templates manually is a large, risky project.
The problem from first principles
Why the templates multiply. Copying a template and changing the subject line takes a minute. Turning the change into a parameter on a shared template takes an afternoon, and someone has to be in charge of that template. With no one in charge, every edit is a copy, so the count only goes up.
Why the migration stalls. A manual migration costs effort per template, and there are 200+ of them. Every mistake can reach a live audience. So the project looks large and risky at the same time, and nobody starts it.
What changes the math. 3 facts about this job:
- Both tools have APIs and webhooks, the interfaces that let code read and write templates and get notified when something changes. So the templates are data a program can read.
- The volume part, reading 200 templates and seeing which ones are the same, is pattern matching, which models do well.
- The risky part is a small number of judgment calls, and a dry run plus a diff can put each one in front of a person before anything goes live.
So the approach is: move the volume to code and a model, keep the judgment calls with a person, and make every step reversible.
| Manual project | Pipeline | |
|---|---|---|
| Reading and grouping 200+ templates | A person, one by one | A model, then a person checks the groups |
| Field and token mapping | A person works it out | A model proposes, a person approves |
| Seeing what will change | After it is live | A diff from a sandbox dry run |
| Undoing a mistake | Fix each one manually | Roll back the cutover |
Why it is a good enablement project
The campaign platform and the template tool were bought to make the team faster. Now the team spends its week maintaining them instead of running campaigns, so the tools have become a cost the marketing ops function carries.
It passes both tests I use for choosing which projects to build:
- It can name its number: the hours the CRM team loses to template work every week, plus the cost and risk of a manual migration.
- It can be automated, because both tools have APIs and webhooks.
On this kind of job, AI drives about 80 to 90% of the cleanup and the migration, and a person validates and moves the last 10 to 20%.1
Clean up first, then migrate
The obvious plan is to treat the migration as the project: point everything at Customer.io and move. That plan carries 200 tangled templates into the new tool and recreates the same problem there.
I do it in the other order. First clean up inside the current tools until the template set is small, deduplicated and well named. Then move that clean set.
There are 2 reasons for this order:
- The cleanup has value on its own. The current tools work as intended again and the team's daily work gets lighter, before the risky migration starts.
- It earns trust. The team sees a real result first, and that is what gets agreement for the bigger move.
The migration pipeline, stage by stage
The cleanup and the migration run as the same kind of pipeline:
- read through an API,
- transform with a model,
- write through an API,
- with a person checking wherever a judgment call is needed.
The 6 stages:
- Extract. Pull every template and every piece of campaign logic out of the source tools through their APIs. This is ordinary engineering and fully automated. It gives you the raw material as structured data.
- Understand and cluster. A model reads the templates and groups the near-duplicates, which shows the real size of the problem. In this case the 200 came down toward 20.
- Dedupe and standardize. For each group, pick the canonical version, the 1 template the others become, and turn the differences into parameters instead of separate templates. A model drafts the canonical template and the parameter list. A person approves the groups where the variations differ in ways that matter.
- Map. The target tool models things differently from the source, so fields, personalization tokens and journey steps need mapping. A model proposes the mapping from both tools' schemas. A person approves it, because this is where the 2 tools disagree about what a thing means.
- Dry run. Generate everything in the target tool against a copy or a sandbox, with no live audience, and produce a diff of exactly what will exist and what will change. Nothing touches prod yet.
- Review and cut over. A person reviews the diff and a sample of migrated campaigns that would reach real customers, then approves the cutover, the switch from the old tool to the new one. The cutover is reversible: if something is wrong, you roll back.
What clustering finds
200 templates that look different are usually a much smaller set of real templates plus drift:
- a changed subject line,
- a tweaked footer,
- a one-off promo nobody removed.
Each kind of drift becomes a parameter on 1 canonical template.
Step through it
The demo below steps through the same stages. Each stage shows what the AI does, what a person checks, and how the effort splits.
Interactive: step through an AI-driven martech migration
Where the 80 to 90% comes from, and the other 10 to 20%
So much of this can be automated for 2 reasons:
- Every stage reads and writes through an API.
- The hard part, making sense of 200 messy templates, is pattern matching, which models do well.
Extraction, generation, mapping proposals and the dry-run diff are all machine work.
The human part is judgment, and it sits in 4 places:
- Choosing which near-duplicate is the canonical one when they differ.
- Approving a field mapping where the 2 tools model something differently and a wrong choice would break personalization.
- Checking the sample of migrated campaigns that will reach real customers.
- Signing off the reversible cutover.
That is about 10 to 20% of the work, and it is where a mistake would reach an audience, so it is worth doing manually.
The split follows what each side does well. Nobody edits 200 templates manually, and every customer-facing change gets a review.
The cleanup is the first result
The first deliverable is the cleanup, well before the migration finishes. When the 200 variations come down to about 20 parameterized templates inside the existing tools, the CRM team's week gets lighter right away:
- They stop searching through near-duplicates.
- The spreadsheet workaround is no longer needed.
- The tools work the way they were meant to when the team bought them.
That result stands on its own, and it is also what earns the trust and the budget for the migration.
This sequence is why I treat it as an enablement project and not a one-off IT ticket. Besides moving data between tools, the work is:
- find an expensive, repetitive problem,
- put a number on it,
- deliver an early result that makes people's work better,
- use that to earn the next, bigger piece.
The economics of the migration, and how its cost is tied to the marketing budget that pays for it, follow the model in running AI enablement as a P&L.
Key takeaways
- Campaign logic in one tool and hundreds of ungoverned templates in another is a good AI enablement project: it can name its number and the tools' APIs make it automatable.
- Clean up before you migrate. The cleanup has value on its own and earns the trust for the bigger move.
- Run the cleanup and the migration as a single pipeline: extract via API, cluster and dedupe with a model, map to the target schema, dry-run in a sandbox, cut over reversibly.
- AI drives about 80 to 90% of it. A person makes the judgment calls: the canonical template, the field mapping, the customer-facing sample and the cutover sign-off.
- De-risk with a sandbox, a reviewable diff before anything is applied, and a cutover you can roll back.
If you have a martech setup like this and a migration you have been putting off, a short call is a good way to talk through whether it would make a good first project.
Footnotes
-
The 80 to 90% is the split I have seen on this shape of job, and it will be different for yours. Where the source tool has a thin API or the templates contain heavy custom logic, more of the work stays human. Treat it as a starting estimate and revise it once the extract stage shows how clean the data is. ↩
Common questions
Can an AI run a CRM or martech migration?↓
For a large part of it, yes, because martech tools with APIs and webhooks let code read and write their objects. A pipeline can extract the templates and campaign logic through the source tool's API, group and dedupe the near-duplicates, map fields to the target tool's schema, generate the equivalent objects, and produce a diff for review. On this kind of job, AI drives about 80 to 90% of the work and a person validates and moves the remaining 10 to 20%, especially the parts that reach a live audience.
Why do the cleanup before the migration?↓
So you move a clean, deduplicated set into the new tool instead of copying the duplicates across. The cleanup also has value on its own before the migration starts: the existing tools work as intended again and the team's daily work gets lighter. That early result is what gets the team to agree to the larger move.
How do you de-risk an AI-driven migration?↓
3 ways. Run it against a copy or a sandbox first, so nothing touches the live audience. Produce a diff of what will change before applying anything, and have a person review it. And make the cutover reversible, so a mistake can be rolled back. The model does the bulk transformation; the dry run, the diff and the rollback make it safe.
What parts of a martech migration still need a person?↓
The judgment calls. Choosing which near-duplicate template is the canonical one when they differ. Approving the field mapping where 2 tools model something differently. Checking a sample of migrated campaigns that will reach real customers. And signing off the cutover. These are about 10 to 20% of the work, and they are where a mistake would reach an audience.