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.
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.
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
- Shipping Go: Develop, deliver, discuss, design, and go again
- Software Architecture Decision-MakingIn early access (MEAP)
- Microservices Patterns, Second EditionIn early access (MEAP)
What to know first
- legacy systemA legacy system is an established software or computing system that remains in use and whose age, design, technology, or existing constraints can complicate maintenance, integration, or change.
- legacy codeLegacy code is existing software code carried forward from earlier development for maintenance or change, regardless of its test coverage or current usefulness.
- refactoringRefactoring is the disciplined restructuring of existing software to improve its internal qualities while preserving its externally observable behavior.
- unit testA unit test is an automated test that checks whether a relatively small unit of software behaves as expected, typically in isolation from external dependencies.
Related concepts
- legacy systemaddresses · A legacy system is an established software or computing system that remains in use and whose age, design, technology, or existing constraints can complicate maintenance, integration, or change.
- feature flaguses · A feature flag is a configuration control that conditionally enables, disables, or selects software functionality at build time or runtime.
- microservice architectureaddresses · Microservice architecture is a software architectural style that structures an application as independently deployable services, typically organized around focused capabilities and communicating through defined interfaces.
- seamuses · A software seam is a boundary where behavior or dependencies can be varied, replaced, or isolated with limited disruption to the surrounding system.
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.





