liveBook · Manning

Strangler fig pattern

The strangler fig pattern is an incremental modernization approach in which a new system gradually takes over functionality from a legacy system until the legacy system can be retired.

How 6 Manning books explain it

Grokking Software Architecture

A gradual modernization technique that replaces a legacy system by moving functionality into a new system until the old system is no longer needed.

How it is used
Uses gradual replacement to modernize legacy code and evolve a monolith without stopping feature delivery for a rewrite.
How deep it goes
Outlines hexagonal migration steps and a service-routing example, while deferring detailed implementation of the refactor.
Examples
Illustrates legacy replacement with a hexagonal outpost and a shop monolith whose billing, inventory, and shipping routes move to services.
What you can do after
Practice/perform a basic migration plan by identifying a seam, creating a legacy adapter, and shifting logic incrementally.

Read how Grokking Software Architecture explains strangler fig pattern →

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 fig 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 fig 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 fig pattern →

Build High Value Software Systems

A gradual replacement pattern in which a new system is built alongside a legacy system and takes over its responsibilities incrementally.

How it is used
Replaces a legacy system incrementally while the existing system continues handling requests.
How deep it goes
Details request routing, staged traffic shifts, behavior checks, endpoint-by-endpoint replacement, and rollback.
Examples
Uses a payment API, replacing `/payments/create` while `/payments/refund` remains legacy, with internal and percentage-based traffic.
What you can do after
Apply the pattern by routing selected requests to a new service, checking behavior, then increasing rollout or routing back.

Read how Build High Value Software Systems explains strangler fig 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 fig pattern →

Also covered in

What to know first

Related concepts

Questions about strangler fig pattern

What is strangler fig pattern?

The strangler fig pattern is an incremental modernization approach in which a new system gradually takes over functionality from a legacy system until the legacy system can be retired.

Which Manning books explain strangler fig pattern?

Grokking Software Architecture, Google Anthos in Action, Architecture Modernization: Socio-technical alignment of software, strategy, and structure, ASP.NET Core in Action, 3e, Build High Value Software Systems and Kafka for Architects.

What should I know before learning strangler fig pattern?

Manning books that teach strangler fig pattern usually introduce legacy system, legacy code, refactoring and unit test first.

What is the difference between strangler fig pattern and big-bang rewrite?

The strangler fig pattern is an incremental modernization approach in which a new system gradually takes over functionality from a legacy system until the legacy system can be retired. A big-bang rewrite is a software replacement strategy that replaces or rewrites an entire system in one large, coordinated effort rather than incrementally.

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.