> ## Content Index
> Fetch the complete content index at: https://www.thedeltalog.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# The Strangler Fig Pattern vs. Reality: When Your Migration Is Just Two Platforms Forever
- URL: https://www.thedeltalog.com/strangler-fig-pattern-data-migration/
- Published: 2026-11-21T13:07:27.000Z
- Updated: 2026-11-21T13:13:21.000Z
- Description: Your migration tracker says 80% done, so why did the platform bill go up? The strangler fig pattern works right up until the step nobody staffs: switching the old system off.
- Author: Sanjay
- Tags: data-migration

💡

****TL;DR:** The strangler fig pattern moves workloads one at a time instead of in a big-bang cutover. On data platforms it tends to stall at the last step, eliminate: the easy 70% migrates, the hard 30% stays, and you pay for two platforms indefinitely. Interoperability makes that comfortable. The fix is the decommission test: a workload has only migrated once its old version has a switch-off date, and that date has been met.

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](https://www.martinfowler.com/bliki/StranglerFigApplication.html?ref=thedeltalog.com), because people kept dropping the botanical part and missing the metaphor. In [the 2004 version of the post](https://martinfowler.com/bliki/OriginalStranglerFigApplication.html?ref=thedeltalog.com), he's clear that the main reason to choose it over a cut-over rewrite is reduced risk.

![](https://storage.ghost.io/c/6a/5e/6a5e07fb-970d-4f2b-87c2-afa263154cca/content/images/2026/11/image.png)

The ingenious strangler fig

### Transform, coexist, eliminate

[AWS breaks the pattern into three steps](https://docs.aws.amazon.com/prescriptive-guidance/latest/modernization-decomposing-monoliths/strangler-fig.html?ref=thedeltalog.com): 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.

0:00 

/1:57 

1× 

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](https://learn.microsoft.com/azure/architecture/patterns/strangler-fig?ref=thedeltalog.com) 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."

![](https://storage.ghost.io/c/6a/5e/6a5e07fb-970d-4f2b-87c2-afa263154cca/content/images/2026/11/CleanShot-2026-11-21-at-23.45.49@2x.png)

Seven of ten workloads are live on the new platform. Not one legacy version has been switched off.

![](https://storage.ghost.io/c/6a/5e/6a5e07fb-970d-4f2b-87c2-afa263154cca/content/images/2026/11/CleanShot-2026-11-21-at-23.46.24@2x.png)

Seven of ten workloads are live on the new platform. Not one legacy version has been switched off.

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](https://learn.microsoft.com/azure/databricks/delta/uniform?ref=thedeltalog.com), a Delta table gets Iceberg metadata generated alongside it, without rewriting the data files. Unity Catalog exposes those tables through [its Iceberg REST catalog](https://docs.databricks.com/aws/external-access/iceberg?ref=thedeltalog.com), and Databricks has a walkthrough for [reading Unity Catalog tables from Snowflake](https://www.databricks.com/blog/read-unity-catalog-tables-in-snowflake?ref=thedeltalog.com). Under all of it is still [the delta log underneath every table](https://www.thedeltalog.com/something-broke-your-delta-table-the-delta-log-knows-what/), 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.

![Databricks SHOW TBLPROPERTIES output for a Delta table with UniForm Iceberg enabled](https://storage.ghost.io/c/6a/5e/6a5e07fb-970d-4f2b-87c2-afa263154cca/content/images/2026/11/CleanShot-2026-11-21-at-23.49.15@2x.png)

Still a Delta table, but with Iceberg metadata generated next to it, so an Iceberg reader can query the same files.

![](https://storage.ghost.io/c/6a/5e/6a5e07fb-970d-4f2b-87c2-afa263154cca/content/images/2026/11/CleanShot-2026-11-21-at-23.52.41@2x.png)

Look for the Iceberg-related rows near the bottom of the output

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](https://databrickslabs.github.io/lakebridge/docs/overview?ref=thedeltalog.com) is one tool for this. A pair of `EXCEPT` queries is another, and it works on day one.

0:00 

/1:05 

1× 

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](https://www.thedeltalog.com/delta-log-debugging/).

### 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](https://databricks.com/blog/navigating-synapse-migration-databricks?ref=thedeltalog.com) 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.

![Databricks query result listing migrated workloads with missing or overdue legacy switch-off dates](https://storage.ghost.io/c/6a/5e/6a5e07fb-970d-4f2b-87c2-afa263154cca/content/images/2026/11/CleanShot-2026-11-21-at-23.57.25@2x.png)

All seven "migrated" workloads fail the test: four have no switch-off date, and three are past theirs.

## 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:

1. **The eliminate step is the migration.** Transform and coexist are the easy parts. Plan, staff and date the switch-offs from day one.
2. **Interoperability is a bridge, not a destination.** Iceberg and shared catalogs make coexisting comfortable. That's exactly why coexisting can last forever.
3. **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](https://thedeltalog.com/?ref=thedeltalog.com#/portal/signup) and get the next one in your inbox.

## Sign up for The Delta Log

Real problems, real fixes, reusable patterns. A weekly newsletter for data engineers on Databricks.

Subscribe 

Email sent! Check your inbox to complete your signup. 

No spam. Unsubscribe anytime.

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

[strangler-fig-pattern-notebook (1)strangler-fig-pattern-notebook (1).py19 KBdownload-circle](https://www.thedeltalog.com/content/files/2026/11/strangler-fig-pattern-notebook--1-.py "Download")

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

![](https://storage.ghost.io/c/6a/5e/6a5e07fb-970d-4f2b-87c2-afa263154cca/content/images/2026/11/CleanShot-2026-11-21-at-17.47.48@2x.png)

How to import the experiment notebook and open it?

Thanks as always for reading.