liveBook · Manning

Strangler pattern

The strangler pattern is an incremental modernization approach that replaces a legacy system by gradually transferring its functionality to a new system until the legacy system can be retired.

How 4 Manning books explain it

Google Anthos in Action

The strangler fig pattern incrementally replaces parts of a legacy system with new implementations until the legacy system is reduced or removed.

How it is used
Guides incremental migration from a legacy application toward microservices while preserving production delivery.
How deep it goes
Explains the rationale, candidate-selection heuristic, and evaluation dimensions, but does not detail routing or integration mechanics.
Examples
Uses centralized authentication and authorization as an example of an easily decoupled feature.
What you can do after
Apply incremental extraction to reduce modernization risk and deliver architectural improvements through successive production releases.

Read how Google Anthos in Action explains strangler pattern →

Architecture Modernization: Socio-technical alignment of software, strategy, and structure

The strangler fig pattern is a migration pattern that gradually replaces an existing system by routing increasing responsibility to a new system until the old system is no longer needed.

How it is used
Guides gradual modernization when replacing a legacy architecture without a complete rewrite.
How deep it goes
Explains routing, delegation, and responsibility transfer, but does not detail the additional risks it identifies.
Examples
Uses a legacy monolith, routing component, modernized subsystems, and SoundCloud’s eight-year migration as examples.
What you can do after
Apply incremental migration by routing requests between legacy functionality and newly modernized subsystems.

Read how Architecture Modernization: Socio-technical alignment of software, strategy, and structure explains strangler pattern →

ASP.NET Core in Action, 3e

The strangler fig pattern is an incremental modernization pattern in which new functionality gradually replaces parts of an existing system until the legacy system can be retired.

How it is used
Guides gradual conversion of existing ASP.NET applications to ASP.NET Core when full replacement would add unnecessary risk.
How deep it goes
Explains the incremental strategy and names supporting tools, but stops short of detailed routing or deployment instructions.
Examples
Uses migration of an existing ASP.NET application one page or API at a time as the concrete example.
What you can do after
Apply the pattern with YARP, System.Web adapters, and Visual Studio tooling to reduce risk during ASP.NET Core migration.

Read how ASP.NET Core in Action, 3e explains strangler pattern →

Kafka for Architects

The strangler fig pattern is an incremental replacement approach in which a new implementation gradually takes over functionality from a legacy system.

How it is used
Guides gradual application and event-contract migration without interrupting users.
How deep it goes
Explains coexistence, compatibility direction, schema validation, and retirement, but stops short of implementation walkthroughs.
Examples
Uses concurrent producers, consumers, and channels, followed by validation and retirement of the legacy deployment.
What you can do after
Apply the pattern by coexisting versions, selecting compatibility direction, validating schemas, and retiring the legacy implementation.

Read how Kafka for Architects explains strangler pattern →

Related concepts

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.