Brand Logo

Got a question? Chat with us.

Chat on WhatsApp › Book a Meeting ›
Chat with us
WhatsApp Icon
strangler fig pattern migration

Strangler Fig in Practice: Migrating Without a Feature Freeze

Contents

  • Why not just freeze and rebuild
  • Where the routing layer lives
  • Dual writes and reconciliation
  • Choosing the first seam
  • How strangler migrations stall
  • Milestone structure a board can follow
  • FAQ
  • Next step

Most writing on this pattern quotes Fowler, draws a diagram of a vine on a tree, and stops. The metaphor is memorable and the operational reality is where migrations are actually won or lost.

This article is the operational reality: where the routing layer lives, how dual writes go wrong, how to pick the first seam, and — the part nobody writes — how a strangler migration stalls half-done and leaves you maintaining two systems for three years. That failure mode is the real risk of this pattern and it deserves as much attention as the happy path.

Why not just freeze and rebuild

Because the freeze is always longer than planned, and the business doesn’t stop needing things during it.

A big-bang rebuild requires you to stop changing the old system while building the new one, or to change both in parallel — which is more expensive than either. The freeze gets extended, the business builds workarounds outside the system, and those workarounds become requirements you now have to support in the new one.

Meanwhile the new system is being built against a specification captured at freeze time, which ages every week.

The strangler pattern’s actual proposition isn’t that it’s faster. End to end it’s usually slower. It’s that you ship continuously, you can stop at any point, and you never have a single catastrophic cutover event. Those three properties are what make it fundable by people who have watched a rebuild fail before.

the scoring rubric for choosing between approaches

Where the routing layer lives

Every strangler migration needs something that decides, per request, whether the old system or the new one handles it. Your options, roughly in order of how much they constrain you later:

At the edge — API gateway, reverse proxy, load balancer. Cleanest separation and no changes to either system. Good when the seam aligns with URL paths or hostnames. Limited when routing depends on request content, user identity or data state.

In the old system. The old application checks a flag and either handles the request or forwards it. Ugly, and you’re writing code in the system you’re retiring — but it gives you routing decisions with full access to the old system’s context and data, which is frequently what you need.

A dedicated facade in front of both. A new service owning routing, and eventually owning the public interface. Most flexible and most work. Right when the migration is long and the routing logic is genuinely complex.

In the client. Mobile or web clients call old or new directly. Avoid. Client versions you don’t control become permanent, and you’ll be running the old system for the tail of users who never update.

The practical answer for most migrations: start at the edge for the first seam, introduce a facade when routing logic outgrows path matching. Don’t build the facade first — you’ll build the wrong one, because you don’t yet know what the routing needs to decide on.

Whatever you choose, two non-negotiables: every routing decision is logged (you will need to answer “which system handled this request,” and under regulated conditions you will be required to — see compliance during phased migration), and routing is changeable without a deploy. If flipping a seam back requires a release, you will not flip it back when you should.

Dual writes and reconciliation

The hardest part, and where most strangler migrations get into trouble.

While both systems are live, some data must exist in both. You have three options.

Old system as source of truth, new system reads from it. Simplest, safest, and the one to start with. The new system does no writes. Limits what you can migrate — but as a first phase it’s almost always correct.

Dual writes. Both systems written on every change. Conceptually simple, operationally treacherous: two writes that must both succeed with no transaction spanning them. One fails and the systems diverge. Retry the failed one and you may apply it out of order. Write ordering under concurrency is a genuinely hard distributed systems problem, and it does not announce itself — it shows up as a slow, quiet drift you discover months later.

Event-driven sync — one system writes, the other consumes a change stream. More upfront work, dramatically better failure behaviour. Events can be replayed, ordering is explicit, and lag is observable. If your migration will run longer than a few months, build this instead of dual writes.

Reconciliation is not optional

Whatever you choose, run continuous automated reconciliation from day one.

Compare on a schedule appropriate to the data — hourly for transactional, daily for reference.

Alert on divergence above a defined threshold, and define that threshold in advance. Deciding after the first alert what counts as acceptable is how a real problem gets rationalized.

Retain the results. Under regulated conditions this is evidence. Everywhere else it’s how you discover that divergence started three weeks ago and correlates with a deploy.

Have a repair path. Detecting divergence without a way to fix it is just anxiety. Know which system wins and how the other gets corrected.

Reconciliation failures are the leading indicator of a migration in trouble. A team that has stopped looking at reconciliation output has usually stopped believing the migration will finish.

Choosing the first seam

The first seam sets the trajectory. Four criteria, and the first two matter most:

Low coupling. Few dependencies in either direction. You’re trying to prove the approach, not solve the hardest problem.

High change rate. Pick something that changes often, so the benefit is felt quickly. A seam nobody touches produces no visible payoff and the migration loses political support in month four.

Clear data ownership. Ideally data this component owns and nothing else writes to. This is what lets you avoid dual writes in phase one.

Real but bounded business value. Enough that shipping it matters; not so much that failure is catastrophic.

Good first seams: a read-heavy reporting or search path; a notification or messaging subsystem; a new feature area that can be built new and routed to from day one; a well-bounded integration with a third party.

Bad first seams: authentication (everything depends on it); the core transactional path (highest risk, no room to learn); anything touching data five other components write to; and — tempting but wrong — whatever is most broken. The most broken component is usually most broken because it’s most coupled.

The best first seam is often a new capability. Build it in the new system, route to it from day one, and you’ve established the routing layer, the deployment path and the operational practice with zero migration risk.

How strangler migrations stall

This is the failure mode that matters, and almost nobody writes about it.

The migration goes well for two or three seams. Then attention moves elsewhere — a reorg, a new priority, the executive sponsor changes roles. The migration isn’t cancelled. It’s just not finished. Three years later you’re running two systems, paying for both, onboarding engineers into both, and every change requires deciding which one it belongs in.

That state is worse than either endpoint. Worse than the old monolith, worse than the completed migration. And it is the most common outcome of this pattern.

Why it happens

The easy seams go first, correctly. What remains is the hard, coupled core — and the work gets harder exactly as enthusiasm declines.

Early wins reduce urgency. The migration was funded because the system was painful. Three seams in, the pain is noticeably less. The case for finishing is weaker than the case for starting was, and it’s competing against new features.

Nobody owns completion. Individual seams have owners. The migration’s end state frequently has none.

The routing layer becomes permanent. What was scaffolding becomes infrastructure. Once it’s stable, nobody is motivated to remove it, and its existence makes the half-state comfortable.

Kill criteria — define these at the start

Write these down before seam one, when you’re clear-headed.

No seam completed in two quarters → stop and decide explicitly. Either re-fund with a named owner or formally end it and remove the routing layer.

Cost of dual operation exceeds projected completion benefit → the arithmetic has changed. Recalculate honestly rather than continuing from momentum.

The remaining seams are all the coupled core → you’re at the hard part with the least energy. Either commit properly now or stop at a defensible boundary.

Reconciliation has been failing and nobody is fixing it → the clearest signal that the team has stopped believing. Act on the human signal, not the technical one.

Two consecutive quarters with no new engineer onboarded to the new system → knowledge is concentrating rather than spreading, and the migration’s bus factor is falling.

Stopping deliberately at a defensible boundary is a legitimate outcome. Some migrations should end at 60% with the remaining core left intact and the routing layer kept as a permanent, documented architectural decision. That’s a decision. Drifting into the same state is not.

Milestone structure a board can follow

Governance is what makes this pattern fundable, because “incremental migration” sounds to a board like “indefinite spending.”

One seam per milestone, named for the business capability rather than the technical component. “Order search” and not “extract OrderQueryService.”

Each milestone ends with traffic fully routed to the new system for that seam, old path retired or explicitly deprecated with a date. A seam that is “90% migrated” for two quarters is the stall beginning.

Report three numbers every milestone: percentage of traffic on the new system, number of seams remaining, and current cost of dual operation. That third number is the one that keeps the board engaged, because it rises until the migration finishes.

Each milestone is a genuine stop point, and say so. A board that knows it can stop is far more willing to continue — the ability to exit is what makes the commitment fundable.

Name the end state and the date at the start, and report against it every milestone even when the news is bad. The migrations that stall are the ones where nobody was tracking completion, because nobody had defined it.

Our Modernization Program band — $250K–$750K over 6–12 months — is structured exactly this way: phased, milestone-billed, named architect, steering cadence.

FAQ

What is the strangler fig pattern?

An incremental migration approach where a new system is built alongside the old one and traffic is routed to it capability by capability, until the old system has no traffic and can be retired. Its advantage isn’t speed — end to end it’s usually slower — but that you ship continuously, can stop at any point, and never have a single catastrophic cutover.

How do you migrate without a feature freeze?

By routing traffic per capability rather than switching systems wholesale. New functionality goes into the new system and is routed to from day one; existing capabilities move one seam at a time. The old system keeps serving everything not yet migrated, so the business is never waiting.

Should I use dual writes during a migration?

Prefer not to, for anything running longer than a few months. Dual writes require two writes to succeed with no transaction spanning them, and failure produces silent divergence. An event-driven change stream is more upfront work with dramatically better failure behaviour — replayable, explicitly ordered, observable lag.

How do I choose the first component to migrate?

Low coupling and high change rate, with clear data ownership and real but bounded business value. Avoid authentication, the core transactional path, and — counterintuitively — whatever is most broken, since the most broken component is usually most broken because it’s most coupled. A brand-new capability is often the best first seam of all.

What happens if a strangler migration doesn’t finish?

You run two systems indefinitely, paying for both, onboarding engineers into both, and deciding for every change which system it belongs in. That half-state is worse than either endpoint, and it’s the most common outcome of this pattern — which is why kill criteria should be written down before the first seam.

How long does a strangler migration take?

Nine to eighteen months for a substantial system, versus six to twelve for a big-bang rebuild. It’s slower end to end and starts delivering value in month two rather than month nine, which is why it fails less often.

Next step

If you’re considering this approach, two things are worth doing before any code: pick the first seam against the four criteria above, and write your kill criteria down while you’re still clear-headed about them.

If you want the architecture map that makes seam selection evidence-based rather than intuitive, that’s what a Systems Audit produces — $18K–$35K, two to three weeks, yours regardless of what you do next.