← All writing AI enablement, 13 min read

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:

  1. 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.
  2. The volume part, reading 200 templates and seeing which ones are the same, is pattern matching, which models do well.
  3. 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 projectPipeline
Reading and grouping 200+ templatesA person, one by oneA model, then a person checks the groups
Field and token mappingA person works it outA model proposes, a person approves
Seeing what will changeAfter it is liveA diff from a sandbox dry run
Undoing a mistakeFix each one manuallyRoll 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.

Clean up inside the tools the team already has, then migrate the small, clean set. Migrating first would copy the 200 variants into the new tool.

There are 2 reasons for this order:

  1. 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.
  2. 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:

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
The machine row does the volume. The person row holds the 3 checkpoints where a wrong call would break a template or reach customers.

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.

An illustrative group, not the client's real templates. 5 copies collapse into 1 template whose differences are parameters, and a person approves the result where the differences matter.

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

0% automated 200 templates

AI does

Human checks

Where the 80 to 90% comes from, and the other 10 to 20%

So much of this can be automated for 2 reasons:

  1. Every stage reads and writes through an API.
  2. 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.
The model takes the volume that made the manual project look impossible. The person keeps the 4 calls they would want to make themselves anyway.

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:

  1. find an expensive, repetitive problem,
  2. put a number on it,
  3. deliver an early result that makes people's work better,
  4. 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

  1. 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.

Keep reading

Share this
← More writing Get in touch