Skip to content

Strangler Fig Pattern

Overview

The Strangler Fig pattern is a really clever approach to gradually modernizing a legacy system. Here's the breakdown:  

The Analogy

Imagine a strangler fig tree. It starts as a vine that grows around an existing tree. Over time, the vine completely envelops the tree, eventually killing it and taking its place.

The Software Pattern

The Strangler Fig pattern applies this idea to software systems. It's a way to incrementally replace an old, monolithic application with a new one, piece by piece.  

Here's how it works:

  1. Create an Abstraction Layer: You introduce a facade or proxy that sits in front of your existing system. This facade acts as a router, directing traffic to either the old system or the new one.  
  2. Start Small: Begin by building a small piece of your new system that handles a specific set of functionality.
  3. Redirect Traffic: Configure the facade to direct traffic for that specific functionality to the new system.
  4. Repeat: Continue building out pieces of your new system and redirecting traffic until all the functionality has been moved over.
  5. Retire the Old System: Once the new system is fully in place, you can decommission the old one.  

Benefits

  • Reduced Risk: Instead of a risky "big bang" rewrite, you modernize gradually.  
  • Faster Time to Value: You can start delivering new features sooner.  
  • Less Disruption: Users experience a smooth transition.

When to Use It

The Strangler Fig pattern is ideal for modernizing large, complex applications where a complete rewrite is too risky or time-consuming.

Considerations

While the Strangler Fig pattern offers a less risky approach to modernization than a full rewrite, it's not without its challenges and risks. Here are some key considerations:  

Technical Risks

  • Complexity: Introducing a facade and managing the routing of traffic can add significant complexity, especially in intricate systems. Debugging and troubleshooting can become more difficult as requests flow through multiple layers.

  • Data Synchronization: If the old and new systems share data, keeping them synchronized can be a major hurdle. You'll need a robust data migration and synchronization strategy, which can be complex and prone to errors. Consider eventual consistency and its implications.  

  • Testing: Thorough testing becomes crucial, but also more challenging. You need to test both the old system, the new system, and the interaction between them. Integration testing is essential.  

  • Performance: The facade and the routing logic can introduce performance overhead. Careful design and optimization are essential to avoid impacting the user experience.  

  • Rollback Complexity: If something goes wrong, rolling back changes can be difficult, particularly if data has been migrated or modified in the new system. Plan for rollback scenarios.

  • API Design: The design of the APIs between the old and new systems is critical. Poorly designed APIs can create tight coupling and hinder future development. Organizational Risks:

  • Team Coordination: The Strangler Fig pattern requires close collaboration between different teams working on the old and new systems. Communication and coordination challenges can arise.

  • Skill Gaps: The team may need to acquire new skills to work with the technologies used in the new system. Training and knowledge transfer are important.

  • Project Management: Managing a project that involves two parallel systems can be complex. Careful planning, tracking, and risk management are essential.

  • Legacy System Expertise: You still need to maintain expertise in the legacy system while building the new one. Losing key personnel with knowledge of the old system can be a major risk.

  • Resistance to Change: Introducing a new system can be met with resistance from users or stakeholders who are comfortable with the old one. Managing expectations and communication are crucial.  

Other Considerations

  • Increased Infrastructure Costs: Running two systems in parallel can increase infrastructure costs, at least temporarily.  

  • Security: Ensuring security across both the old and new systems is critical, especially during the transition period.

Mitigation Strategies

  • Thorough Planning: Spend ample time planning the migration, including data migration, testing, and rollback strategies.  

  • Automated Testing: Implement robust automated testing to catch issues early.  

  • Continuous Integration/Continuous Deployment (CI/CD): Use CI/CD pipelines to automate the build, test, and deployment process.  

  • Monitoring and Alerting: Set up comprehensive monitoring and alerting to detect issues quickly.  

  • Phased Rollout: Consider a phased rollout of the new functionality to minimize disruption and allow for early feedback.