Strangler Fig Pattern in System Design

What is the Strangler Fig Pattern?

The Strangler Fig Pattern is a design strategy used in software architecture to gradually replace an old (legacy) system with a new one. Instead of rewriting the entire system in one go (which is risky and expensive), the new system is developed and integrated incrementally, while the old system is slowly "strangled" or phased out.

Why is it Called "Strangler Fig"?

The pattern takes inspiration from the strangler fig tree in nature. This tree grows around an existing tree and eventually replaces it. Similarly, in software, the new system wraps around parts of the old system and eventually replaces them completely.

Why Use the Strangler Fig Pattern?

Many large-scale applications run on legacy systems that are difficult to change. They may be built on outdated technologies or have fragile codebases. Completely replacing them risks downtime and can be costly. The Strangler Fig Pattern helps mitigate that risk by allowing gradual and controlled migration.

Key Concepts

• Incremental Migration: Replace legacy functionality piece by piece.
• Routing Layer: Directs traffic between the old and new systems.
• Zero Downtime: Users don't experience interruptions during migration.

Real-World Example: Migrating a Legacy eCommerce Website

Imagine you have an old eCommerce website written in PHP. You want to move to a modern microservices architecture using Node.js and React. Rewriting the entire platform at once could break things. So, you start small.

Step 1: Add a Routing Layer

A routing layer (such as an API gateway or reverse proxy like Nginx) sits in front of the application. It decides whether to send user requests to the old PHP site or the new Node.js services.

Step 2: Identify a Component to Migrate

You choose to migrate the "Product Listing" page first. You build the new version using React and Node.js, and deploy it under the same routing layer.

Step 3: Route Traffic Selectively

The routing layer is configured to send requests for /products to the new Node.js service, while all other routes continue to go to the PHP backend.

Step 4: Monitor and Expand

You observe performance and user feedback. Once the new component proves stable, you migrate the next feature—say, the "Add to Cart" functionality—using the same approach.

Step 5: Full Transition

Eventually, every major module is migrated, and the old system is no longer used. At that point, you decommission the PHP codebase entirely.

Question: Why not rewrite the whole system at once?

Answer: Rewriting an entire system is risky. You may introduce bugs, change business logic unintentionally, and require extended downtime. The Strangler Fig Pattern avoids these problems by allowing changes in small, manageable steps.

Example: Modernizing a Banking System

A bank’s legacy system written in COBOL handles customer transactions. But COBOL developers are hard to find, and maintaining this system is costly.

To migrate safely:

• A routing layer directs some customer requests to new Java-based microservices.
• They start by building a new "Account Overview" module.
• Requests for that module go to the new service, while the rest remain on the COBOL system.
• Over time, they migrate "Funds Transfer", "Transaction History", and "Customer Support".

This allows developers to modernize while continuing to serve millions of users with minimal risk.

Question: What happens if something breaks in the new system?

Answer: Since the migration is incremental, if something fails in the new service, it's easier to roll back or redirect traffic back to the legacy system temporarily.

Advantages of the Strangler Fig Pattern

• Minimizes risk of complete system failure.
• Enables gradual learning and adaptation.
• Preserves existing business continuity.
• Makes testing and debugging easier.

When Should You Use This Pattern?

• Your legacy system is business-critical and cannot be turned off abruptly.
• You need to migrate functionality without rewriting everything at once.
• You're adopting modern architecture (microservices, cloud-native, etc.)

Common Challenges

• Keeping old and new systems in sync (data consistency).
• Routing complexity as system grows.
• Long migration timelines if not managed well.

Summary

The Strangler Fig Pattern is a safe and structured way to modernize legacy systems. Instead of throwing away the old system, you grow the new system around it, and gradually transition until the old system is no longer needed.

Question: Can this pattern work for frontend systems too?

Answer: Yes. For example, you can gradually replace sections of a legacy UI with new components (e.g., React or Angular) while keeping the rest intact until you're ready to fully migrate.