The Strangler Fig Pattern vs. Reality: When Your Migration Is Just Two Platforms Forever
It's month 18 of a "low-risk, incremental" migration. The tracker says 80% done. Then finance asks why the data platform bill went up.
Nobody did anything wrong, exactly. The team followed the strangler fig pattern by the book. They moved workloads one at a time, kept the old warehouse running for safety, and never had a scary cutover weekend.
They just never got to the part where the old tree dies.
If you've worked on a data platform migration in the last few years, you've probably seen some version of this. Two orchestrators. Two bills. Two numbers for "revenue", depending on which dashboard you open.
So let's chat about the strangler fig pattern on data platforms: what it was invented to fix, why it stalls in a very particular place, and a simple test for whether your migration is actually finishing or just copying.
What is the strangler fig pattern, and what mess was it invented to fix?
The strangler fig pattern replaces a legacy system gradually instead of all at once. New functionality grows around the old system, workloads move across one at a time, and the old system is switched off once nothing depends on it. It exists because big-bang rewrites are risky, slow to deliver value and painful to roll back.
The weekend cutover that fails on Monday
Before the pattern had a name, the default plan was the rewrite. Freeze the old system, spend a year rebuilding everything, then cut over in one weekend.
You probably know how that goes. The new system is late, the old one keeps changing underneath it, and the cutover weekend becomes a cutover month.
Fowler's Queensland figs
Martin Fowler named the pattern in 2004, after seeing strangler figs in the rainforests on the Queensland coast. (As someone writing from Sydney, I enjoy that one of software's most quoted patterns started a short flight north of here.) The fig seeds high in a host tree, grows roots down to the ground, and gradually replaces the tree it started on.
He renamed the post from "Strangler Application" in 2019, because people kept dropping the botanical part and missing the metaphor. In the 2004 version of the post, he's clear that the main reason to choose it over a cut-over rewrite is reduced risk.

Transform, coexist, eliminate
AWS breaks the pattern into three steps: transform (build the new version), coexist (run both while traffic moves) and eliminate (switch off the old one).
Hold on to that third word. It's the whole post.
What does the strangler fig pattern look like on a data platform?
On a data platform, the strangler fig pattern moves workloads (pipelines, models and the tables dashboards read) from the old platform to the new one, one at a time. Consumers point at a stable name, such as a view or a catalog entry, so the backend can switch without them noticing. Each move ends with a reconciliation, then a switch-off.
The facade is a view, or the catalog
In application migrations, a facade or proxy routes requests to either the old system or the new one. On a data platform, the equivalent is usually much simpler: a view, a synonym or a catalog entry that consumers query by name.
If every dashboard reads sales.orders and that name is a view, you can repoint it from the legacy table to the new one in a single statement. If every dashboard reads the legacy warehouse directly, every switch becomes a negotiation with every report owner.
The consumer query never changes. Only the view definition does, and the _source column flips from legacy to lakehouse.
The unit you strangle is a workload
A "workload" is something with an owner and a consumer: an ingestion pipeline, a dbt model, the extract finance runs every month-end. That's the unit you move, reconcile and switch off.
Microsoft's version of the pattern applied to a database ends the same way the original does. Once the new database is validated, the legacy one gets retired. Validation first, then retirement. Not validation, then a long, comfortable coexistence.
The half-strangled platform
Here's an illustrative example, not a specific client story.
A team migrates ten workloads off their old warehouse. The first seven go well. Ingestion, the customer dimension, a few marketing models. They're well understood, well tested and owned by people who are still around.
Then come the last three. A finance month-end process built on stored procedures nobody has touched since 2019. A regulatory extract with a format someone agreed with an auditor years ago. An Airflow DAG with 40 tasks and one person who understands it.
These are hard for reasons that have nothing to do with the platform. The logic lives in someone's head, the consumers are nervous, and every option means a meeting.
So the team does the sensible-sounding thing. They park the hard three and keep the old warehouse running "for now".
I call this the half-strangled platform. The tracker says 70% migrated, and that's true. But not one workload has had its legacy version switched off. Even the seven that moved are still running on both sides, because the old warehouse is still up and "might as well keep the jobs going for safety."


Now you're paying for two platforms, two orchestrators and two on-call rotations. And you've got two sources of truth, which is the expensive one. The day someone notices the old and new revenue numbers don't match, the migration has created exactly the problem it was meant to remove.
Don't get me wrong. Fowler argues in that same 2004 post that a strangler migration that stops partway can still return more than many rewrites ever do. I think that's true, and it's why the pattern is still the right default.
But a partial migration is only a return on investment if you've stopped paying for the old system. Otherwise, it's just a second system.
Why does interoperability make it easier to never finish?
Sure, interoperability is genuinely good for migrations.
With UniForm, a Delta table gets Iceberg metadata generated alongside it, without rewriting the data files. Unity Catalog exposes those tables through its Iceberg REST catalog, and Databricks has a walkthrough for reading Unity Catalog tables from Snowflake. Under all of it is still the delta log underneath every table, so nothing magical is happening. There's just more metadata.
On a client migration from Snowflake and Airflow to Databricks, we took a strangler approach: workloads moved one at a time while the old stack kept running, with Iceberg so both platforms could read the same data. It's a good setup. Consumers on either side see the same tables, and nobody has to coordinate a big switch.


And here's the uncomfortable part. Interoperability removes the pain that forces a decision.
When the old platform can't read the new data, dual-running hurts, so people push to finish. When both platforms can happily read the same tables, nothing hurts. The legacy warehouse becomes one more consumer, quietly running, quietly billing.
Interoperability is a bridge. It's very easy to start living on the bridge.
How do you know a workload has actually migrated?
A workload has migrated when three things are true: its output reconciles with the legacy version, nothing still reads the legacy version, and the legacy version has been switched off on a date somebody committed to. If any of the three is missing, the workload hasn't migrated. It's been copied.
I call that the decommission test. For every migrated workload, can you name the date its old version was switched off? Not planned. Switched off.
Reconcile before anything switches
Before you switch a workload off, prove both sides agree: row counts, key aggregates, schema, and a row-level comparison on the columns that matter. Lakebridge's post-migration reconciliation is one tool for this. A pair of EXCEPT queries is another, and it works on day one.
The new table is missing 2 rows and disagrees on 3 amounts. After the fix, both EXCEPT queries come back empty.
If the numbers drift after a switch, the new table's history is the first place to look. DESCRIBE HISTORY tells you which write changed them.
Find out who still reads the old table
Reconciliation proves the new output is right. It doesn't prove anyone has moved to it.
Before the switch-off date, check who is still querying the legacy table, using query history, lineage or the old platform's access logs.
You'll almost always find a surprise. An analyst's spreadsheet. A scheduled export to a partner. A dashboard someone built on the raw table "temporarily" in 2023.
Copied is not migrated
Every workload that passes reconciliation but keeps running on the old platform is a copy, not a migration. Copies cost money twice and drift over time.
How should you sequence a strangler fig migration so it actually finishes?
Sequence a strangler fig migration around the eliminate step, not the move. Pull one hard workload into the first wave, move consumers onto stable names early, give every workload a switch-off date and owner up front, and staff decommissioning as real work instead of leaving it as cleanup.
Pull one hard workload into the first wave
Starting with the easy workloads builds momentum, but it also hides the real risk until the budget is spent. Put one genuinely hard workload into the first wave. You'll learn what the migration actually costs while you still have time to plan for it.
Move consumers onto stable names first
The cheapest switch is a one-line view change. So before you migrate much at all, get consumers reading through names you control. Then every later switch is a change the platform team makes, not a project for every report owner.
On the Synapse migration I'm working on now, ingestion runs through Lakeflow's built-in connectors where they exist and custom connectors where they don't (SAP C4C over OData is the awkward one). The bronze, silver and gold layers are declared in the Lakeflow Framework. That structure gives every workload a predictable home on the new side, which makes the "where do consumers point?" question much easier to answer.
Databricks' own Synapse migration guide makes a related point: a migration isn't a single workstream. I'd add that switching things off is one of them, and it needs a name and an owner like the rest.
Give every workload an exit date and an owner
Each workload gets a switch-off date and a person accountable for it, from the start. Not a phase called "decommission" at the end of the plan, which is the first thing that gets cut when the timeline slips.

What should you tell the people paying for both platforms?
If you're the data lead, this is the conversation to have early.
Most migration business cases lead with licence costs. Databricks' Synapse guide makes the case that the bigger savings usually come from running fewer systems: fewer integrations, fewer handoffs, fewer things to break. Every month you dual-run, you get none of that.
So put dual-running on the plan as a line item with an end date. Report "workloads switched off" alongside "workloads migrated", and watch how differently the two numbers move.
And when the steering committee asks how the migration is going, give them a better question to track: on what date does the old platform's bill go to zero?
If nobody can answer that, you're not migrating. You're expanding.
Final thoughts
Three things to take away:
- The eliminate step is the migration. Transform and coexist are the easy parts. Plan, staff and date the switch-offs from day one.
- Interoperability is a bridge, not a destination. Iceberg and shared catalogs make coexisting comfortable. That's exactly why coexisting can last forever.
- Measure switch-offs, not moves. Run the decommission test on every workload. If it has no switch-off date, it hasn't migrated.
If this was useful, I write about real-world Databricks migrations and platform work every week in The Delta Log. Subscribe free and get the next one in your inbox.
And I'm curious: have you got a migration that's been 80% done for a year? Hit reply and tell me about it. I read every one.
FAQ
What is the strangler fig pattern?
The strangler fig pattern is a way to replace a legacy system gradually instead of in one big rewrite. New functionality is built around the old system, workloads move across one at a time, and the old system is switched off once nothing depends on it. Martin Fowler named it in 2004.
Why is it called the strangler fig?
Martin Fowler named it after strangler figs he saw in the rainforests of coastal Queensland, Australia. The fig starts high in a host tree, grows roots down to the ground and gradually replaces the tree. The pattern does the same to a legacy system.
Is the strangler fig pattern better than a big-bang migration?
Usually, yes, because it reduces risk and delivers value earlier: each workload can be moved, checked and rolled back on its own. The trade-off is a period of running two systems at once. That period only pays off if it has an end date.
How long should you run two data platforms side by side?
Only as long as each workload needs to be reconciled and its consumers moved. Set a switch-off date for every workload's legacy version at the start of the migration, and treat dual-running as a cost with an end date rather than a safety net that stays up indefinitely.
Can Snowflake and Databricks share data during a migration?
Yes. Databricks can generate Iceberg metadata for Delta tables using UniForm, and Snowflake can read those tables through Unity Catalog's Iceberg REST catalog. That makes coexisting easier during a migration. It doesn't replace switching the old workloads off.
Downloads
The Python notebook containing the experiments used for this blog post is available for download to our readers below.
The Python Notebook
How to open it?
Go to your workspace and use the import option to upload the notebook. Once uploaded, you can click on it to open it. Check the screenshot below.

Thanks as always for reading.
Member discussion