[SURVEY RESULTS] The 2024 edition of State of Software Modernization market report is published!
GET IT here

The Strangler Pattern for Legacy System Modernization

readtime
Last updated on
January 22, 2024

A QUICK SUMMARY – FOR THE BUSY ONES

The Strangler Pattern in a nutshell

The strangler pattern in a nutshell

What: The Strangler Pattern is a method for gradually replacing legacy systems with new ones, reducing risk and disruption. 

When: It's most helpful when dealing with complex, critical systems where a complete overhaul is impractical or risky. It allows for a controlled transition and continuous improvement, when the main system remains operational.

TABLE OF CONTENTS

The Strangler Pattern for Legacy System Modernization

The Strangler architecture pattern as a strategic approach

If you need to minimize the risk of disrupting your current system, the Strangler Pattern is for you.

Learn how this architectural approach helps businesses incrementally replace outdated systems, reduce risks, and achieve a successful digital transformation.

Let's dive in.

What is the Strangler Pattern?

The Strangler architecture pattern is a software design and modernization approach used to incrementally replace and upgrade legacy systems. Incremental migration involves gradually introducing new components, services, or functionalities alongside the existing system, allowing for a smooth and controlled transition. 

This pattern is inspired by the way a strangler fig tree grows around an existing tree, eventually replacing it.

What is the main purpose of the strangler pattern?

The main purpose of the Strangler Pattern is to facilitate the gradual, safe, and manageable transition from an old, often legacy, system to a new system. 

This pattern is particularly useful in scenarios where a complete overhaul or replacement of the existing system is either too risky, costly, or impractical

Choosing a modernization strategy - strangler pattern
Report: State of Software Modernization 2024

Use cases of the strangler pattern

Let’s take a look at when the Strangler Pattern will be the most helpful:

Legacy systems modernization

The most common use case of the Strangler Pattern is modernizing outdated systems. This is especially relevant for systems that are difficult to maintain, scale, or integrate with new technologies.

Incremental feature development

When adding new features to an existing system, the Strangler Pattern allows developers to build and deploy new functionalities in a controlled and incremental manner, without disrupting the existing system.

Migration to microservices architecture

It’s an effective way to break down a monolithic application into microservices. This pattern enables the gradual decomposition of functionalities into smaller, more manageable services.

<span class="colorbox1" fs-test-element="box1"><p>Read also: Don't Believe the Hype: Sometimes a Monolith Is Better Than Microservices [Case Study]</p></span>

Platform or technology migration

When moving an application to a new platform or technology stack (e.g., from an on-premises infrastructure to the cloud), the Strangler Pattern allows for a gradual migration process, reducing risks associated with a big-bang approach.

Refactoring and codebase improvement

For improving or refactoring a complex codebase, this pattern allows developers to gradually replace parts of the legacy code with improved implementations, enhancing maintainability and performance.

How the Strangler Pattern addresses legacy system modernization challenges

The Strangler Pattern addresses several key challenges commonly faced specifically during legacy application modernization:

Risk 1: system failure

One of the biggest challenges in modernizing a legacy system is the risk of system failure, especially if a "big bang" approach is taken. The Strangler Pattern mitigates this risk by allowing for incremental replacement of the system. Since changes are made in small, manageable parts, any issues can be detected and resolved early without affecting the entire system.

Risk 2: operational disruption

Legacy applications are often critical to business operations. Completely overhauling the system can lead to significant downtime and disruption. The Strangler Pattern allows the old system to remain operational while new functionalities are gradually introduced, ensuring continuous business operations.

Risk 3: complexity of the legacy application

Legacy systems can be complex and poorly documented, making it difficult to understand all their intricacies. The incremental approach of the Strangler Pattern helps in unraveling this complexity slowly, allowing teams to understand and address issues piece by piece.

Risk 4: huge amount of technical debt

Legacy apps often carry a significant amount of technical debt. The Strangler Pattern enables teams to address this debt gradually. As each part of the system is refactored, the overall quality of the software improves, and technical debt is reduced.

Risk 5: integrity and consistency of migrated data

Migrating data from a legacy system to a new one is a significant challenge, especially ensuring data integrity and consistency. By using the Strangler Pattern, data migration can be done incrementally, synchronizing data between the old and new systems progressively, which reduces the risks associated with data migration.

Pros and cons of using the Strangler Pattern during the migration process

When considering it for legacy system modernization, it's important to weigh these pros and cons carefully:

Strangler pattern - advantages and disadvantages

The advantages of the strangler pattern are:

  • Gradual transition: Allows for a step-by-step migration, reducing the risk of system failure compared to a full overhaul.
  • Minimized disruption: Ensures continuous operation of existing services, minimizing disruption to business operations.
  • Risk management: By replacing small parts at a time, it's easier to manage risk, as any issues that arise are typically localized and easier to fix.
  • Testing and validation: Incremental changes allow for continuous testing and validation, ensuring that new components integrate well with the existing system.
  • Flexibility and scalability: New components can be built using modern, scalable technologies, improving the overall performance and flexibility of the system.
  • Cost-effective: Can be more cost-effective over the long term as it allows for budget allocation over time and reduces the need for large upfront investments.
  • Stakeholder confidence: Gradual improvement can help build confidence among stakeholders, including users and management, as they see continuous progress and improvement.

The disadvantages of the strangler pattern are:

  • Complexity in interim: Maintaining two systems (old and new) simultaneously can be complex, requiring additional effort in coordination and integration.
  • Longer overall duration: The process can take longer to complete than a full replacement, as it's done in stages.
  • Resource intensive: Requires ongoing investment in both the old and new systems during the transition, which can strain resources.
  • Potential for technical debt: There's a risk of accumulating technical debt, especially if temporary solutions become permanent or if the transition phase is excessively prolonged.
  • Data synchronization challenges: Keeping data synchronized between the old and new systems can be challenging and requires careful planning and execution.

Best practices for strangler pattern implementation

  • Comprehensive assessment: Begin with a thorough assessment of the legacy system. Understand its architecture, dependencies, and limitations. Identify which parts need modernization and prioritize them based on business value and risk. Define your business objectives.
  • Incremental approach: Break the modernization process into small, manageable increments. Each increment should deliver a specific set of features or functionalities. Prioritize the most critical or problematic components first.
  • Proxy layer implementation: Develop a robust proxy or façade layer that intercepts requests and routes them to either the legacy system or the new components. Ensure this layer is flexible and extensible to accommodate changes as the modernization progresses.
  • Continuous testing: Implement a rigorous testing strategy. Continuously test the new components and their integration with the legacy system. Automated testing can help detect issues early.
  • Data migration strategy: If data migration is involved, plan and execute it carefully. Ensure data integrity, consistency, and security during the migration process. Consider running parallel databases for a period to ensure data synchronization.
  • Monitoring and logging: Implement comprehensive monitoring and logging for both the old and new components. This helps in detecting and diagnosing issues, performance bottlenecks, and ensuring system health.
  • Rollback plan: Develop a rollback plan in case issues arise during the transition. Being prepared for potential setbacks is essential for risk management.
  • Cross-functional collaboration: Foster collaboration between development, operations, and business teams. Effective communication and collaboration are crucial for successful modernization.
  • Documentation: Maintain thorough documentation throughout the process. Document the old system, the new components, integration points, and any changes made. This documentation is invaluable for troubleshooting and knowledge transfer.

Strangler pattern in practice - key steps

Implementing the Strangler Pattern in practice involves several key steps, each designed to ensure a smooth and gradual transition from the old system to the new one.

Typically it looks like this:

  1. Step 1: Identify the scope: Start by identifying the components of the legacy system that need to be replaced or upgraded. This involves understanding the functionalities, dependencies, and limitations of the existing system.
  2. Step 2: Create a proxy layer: Introduce a facade or proxy layer in front of the legacy system. This layer will intercept all requests to the system and act as a router, directing traffic either to the old system or to the new components as they are developed.
  3. Step 3: Develop new features incrementally: Begin developing new features or components. Instead of adding them directly to the legacy system, these new features are built as separate services or modules.
  4. Step 4: Gradually redirect traffic: As new components are developed and tested, gradually redirect the relevant traffic from the legacy system to these new components through the proxy layer. This can be done feature by feature or service by service.
  5. Step 5: Test continuously: Throughout this process, it’s crucial to continuously test the new components to ensure they interact correctly with both the legacy system and each other.
  6. Step 6: Data migration: If the new system involves a new data store or schema, data migration needs to be planned and executed carefully. This might involve running parallel databases and synchronizing data between the old and new systems for a period.
  7. Step 7: Phase out the old system: As more components are replaced by their new counterparts, the legacy system's role diminishes. Eventually, when all critical functionalities are transferred to the new system, the old system can be decommissioned.
  8. Step 8: Ongoing evolution: Even after the old system is fully replaced, the new system is continually evolved and improved, leveraging the flexibility and modularity introduced by this pattern.

Analyze this on the graphic below:

The strangler pattern in practice

Example: A legacy fintech system modernized using the strangler pattern

Let's consider a legacy banking application that handles customer accounts, transactions, and reporting, built on outdated technology and unable to support new features or integrations efficiently. Here's how the Strangler Pattern could be applied in this context:

  • Scope identification: The first step is to assess the legacy system, identifying key components like account management, transaction processing, and reporting. Suppose the transaction processing module is the most outdated and needs urgent modernization.

  • Creating a proxy layer: Introduce a facade or proxy layer in front of the legacy system. This layer will route requests for transaction processing either to the legacy system or to the new service, depending on which parts have been modernized.

  • Incremental development of new transaction service: Start by developing a new, modern transaction processing service. This service is built with current technology, ensuring it can handle more transactions faster, supports new types of transactions, and integrates better with other banking services.

  • Redirecting transaction processing: Gradually, as parts of the new transaction service are completed and tested, the proxy starts routing transaction processing requests to the new service instead of the legacy system. Initially, this might be done for less critical transactions to minimize risk.

  • Continuous testing: Throughout, both the new service and its interaction with the legacy system are rigorously tested. This includes testing for accuracy, performance, security, and compliance with financial regulations.

  • Data migration strategy: If the new transaction service requires a different data format or storage, a data migration strategy is developed. This might involve synchronizing data between the old and new systems, ensuring data integrity and consistency.

  • Phasing out the old transaction module: As the new transaction processing service proves stable and efficient, more and more of the transaction load is shifted from the legacy system to the new service. Eventually, the old transaction module is retired.

  • Iterative approach for other modules: Once transaction processing is fully migrated, a similar approach can be taken for other parts of the system, like account management or reporting, incrementally replacing each with modern services.

  • Final transition and ongoing evolution: When all critical components have been replaced, the legacy fintech system is fully decommissioned. The new system, modular and modern, continues to evolve with ongoing improvements and feature additions.

Next steps

The Strangler Pattern is a method for modernizing legacy systems gradually. It offers various implementation approaches, including component replacement, microservices, data-driven migration, API integration, and more.

To implement the Strangler Pattern effectively:

  • Assess the legacy system comprehensively.
  • Define clear business objectives for modernization.
  • Prioritize components for replacement.
  • Implement a proxy layer for routing.
  • Continuously test new components.
  • Plan data migration carefully.
  • Ensure robust monitoring and logging.
  • Develop a rollback plan for emergencies.
  • Foster cross-functional collaboration.
  • Maintain thorough documentation.
  • Provide user training and support.
  • Iterate and improve continuously.

The Strangler Pattern is ideal for complex, critical systems where a full overhaul is impractical, enabling a controlled transition and ongoing enhancements.

Frequently Asked Questions

No items found.

Our promise

Every year, Brainhub helps 750,000+ founders, leaders and software engineers make smart tech decisions. We earn that trust by openly sharing our insights based on practical software engineering experience.

Authors

Olga Gierszal
github
Software Engineering Editor

Software development enthusiast with 6 years of professional experience in the tech industry.

Read next

No items found...

Get smarter in engineering and leadership in less than 60 seconds.

Join 300+ founders and engineering leaders, and get a weekly newsletter that takes our CEO 5-6 hours to prepare.

Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.