Place a boundary where requests can be routed

Identify an interface through which callers reach the capability you want to replace. This might be an HTTP gateway, an application facade, or a message boundary. Preserve the external contract where practical, and establish which request conditions select the old or new implementation.

Illustrative scenario: invoice downloads use a stable URL. A facade routes selected accounts to a new invoice renderer and leaves other requests on the old service. Before rollout, test authentication context, error codes, file formats, and links so the routing change does not expose a different customer contract.

Control data and compare behavior

Decide which component owns each write during coexistence. A shared database can simplify access while preserving tight coupling; separate stores introduce synchronization and reconciliation work. Do not introduce dual writes casually, because partial failure can leave the implementations with different versions of the same business event.

Compare representative outputs with sanitized fixtures or safe read-only shadow processing where appropriate. Avoid replaying side-effecting operations against both implementations without a design for duplicates. Include retries, failure responses, and authorization checks in the contract evidence, rather than comparing only successful response bodies.

Cut over, observe, and retire

Increase routed traffic only after the team can observe errors, latency, and business correctness for the selected capability. Define a fallback procedure and its limits. Returning traffic to old code may be unsafe after incompatible writes, so validate rollback assumptions before the first production cutover.

Remove the old route and its dependencies once the migrated capability no longer relies on them. Update runbooks and ownership maps, then reassess the next slice. Leaving the facade and duplicate implementations indefinitely can create a more complex system than the one the modernization effort intended to improve.

Working sheet

Strangler Fig implementation checkpoints
CheckpointDecisionFailure to prevent
RoutingWhich requests select each implementation?Unpredictable or circular routing
ContractWhich behavior must remain compatible?Caller breakage during cutover
Data authorityWhich component owns writes?Conflicting updates
FallbackWhen is reversal still safe?Old code reading incompatible data
RetirementWho removes the old path?Permanent duplicate operation
Download this worksheet (CSV)

Questions about use the Strangler Fig pattern for legacy modernization

Does Strangler Fig require microservices?

The essential idea is incremental replacement through a boundary. The replacement's deployment structure should fit the system rather than follow a label.

When might the pattern be unsuitable?

Investigate alternatives when you cannot intercept requests, separate functionality, or operate old and new implementations together safely.

How should I use the working sheet?

Download the CSV and replace the sample rows with evidence from your repository. Record a clear acceptance check and an owner for each item. Keep unresolved assumptions visible rather than treating the example as a completed assessment.

Sources and further reading

Examples are illustrative. They are not customer results, security guarantees, or a substitute for checking the documentation for your installed version.

Make the next change verifiable.

Getzilla is an open source workflow for changes to existing repositories. Inspect the project, define acceptance checks, and keep independent review in the loop.

See the repository workflow See current access and pricing