Skip to content
Pricient by IOanyT

Legacy modernization · guide

The strangler-fig pattern, explained for buyers: replacing an old system without a cut-over day

What the strangler-fig pattern is, why it lowers the risk of replacing a legacy system, when it is the wrong choice, and what to ask a vendor who proposes it.

Published 13 October 2026 · Pricient by IOanyT

The short answer

The strangler-fig pattern replaces an old system one piece at a time while the old system keeps running the rest, until nothing is left of it. Users keep the same front door throughout. It lowers risk because each piece is proven before it switches over. Microsoft's guidance says it may not suit small systems, or ones you need to retire quickly.

The pattern in four stages

StageWhat happensWhat users notice
1. Put a front door in placeA routing layer sits in front of the old system; everything still goes to the old systemNothing
2. Move one pieceOne function is rebuilt, proven against the old behaviour, and requests for it are routed to the new versionThat piece behaves the same — or better
3. RepeatPiece by piece, more requests go to the new systemImprovements arrive one at a time
4. Switch off the old systemNothing depends on it any more; the routing layer can be removedNothing — there is no cut-over day

This follows the stages in Microsoft’s Azure Architecture Center (updated 18 September 2026), which describes a façade that “routes these requests either to the legacy application or to the new services”, so that “customers continue to use the same interface and are unaware that a migration is in progress.”

Where the name comes from, and why it lowers risk

Martin Fowler named the approach after strangler figs — vines that germinate in a tree, draw nutrients from it, and eventually root and stand on their own. His case against replacing a system in one go is simple: “Replacing a serious IT system takes a long time, and the users can’t wait for new features”, and “replacements seem easy to specify, but often it’s hard to figure out the details of existing behavior.” Moving piece by piece instead “make[s] both investment and returns occur gradually and visibly” (martinfowler.com, updated 22 August 2024).

Both checked 5 October 2026.

When it is the wrong choice

Microsoft’s guidance is direct about the limits. The pattern might not be suitable when:

It also warns that the routing layer must not become a single point of failure or a bottleneck, and that data both systems use needs a plan for while they coexist.

What it means for how you pay

Because value arrives piece by piece, payment can follow it: each module accepted, then paid for. You can stop after any piece with something that works, rather than a half-finished rewrite. The temporary cost — running old and new side by side — is the price of never betting the business on one day.

What to ask a vendor who proposes it

  1. What is the first piece to move, and why that one?
  2. How will each piece be proven to behave like the old one before it switches?
  3. What happens to the data both systems use while they run side by side?
  4. What does each piece cost, and can we stop after any of them?
  5. How do we know nothing was lost? Ask for a traceability matrix that maps every old behaviour to where it now lives.

How Pricient quotes a modernization

Nothing here is big-bang. Modules move one at a time, parity is proven for each before it switches over, and the old system keeps running the parts that have not moved. Modernization starts with a Legacy System Specification Assessment. It produces a written specification, a risk register, a keep-vs-replace cost comparison and a staged replacement plan, and its fee is credited in full against the first build stage if it starts within 90 days of the report. You can start with a conversation about the system; we ask for read-only code access only when the assessment begins. Tell us what you are running and you get a fixed quote for the assessment.

More on legacy modernization →

Questions

Asked about this

What is the strangler-fig pattern?

An approach to replacing a legacy system gradually: new parts are built alongside the old system, and work is moved across to them piece by piece until the old system can be switched off. Martin Fowler named it after strangler fig vines, which grow around a host tree until they stand on their own.

Why is the strangler-fig pattern less risky than a rewrite?

Because nothing goes dark on a single cut-over day. Each piece is moved and proven while the rest keeps running. As Martin Fowler puts it, replacing a serious system takes a long time, users cannot wait for new features, and it is hard to work out the details of existing behaviour up front.

When is the strangler-fig pattern the wrong choice?

Microsoft's architecture guidance lists cases where it may not suit: when requests to the old system cannot be intercepted, when you cannot access or change the old system's source code, when the system is small and simple to replace whole, or when you need to retire the original quickly.

Does it cost more than a rewrite?

It carries some temporary cost — running old and new side by side, and the routing between them. In exchange you pay for value as it arrives instead of all at the end, and can stop or change direction after any piece.

Defined by both lists

Describe your project. See what comes back.

Start your spec

No signature, no call. A business email unlocks the full quote.