SOFTWARE DEVELOPMENT

Legacy modernization one module at a time: how to move off old systems while the business keeps running

How the strangler fig pattern lets you modernize legacy applications in small, safe steps: choosing the first module, data migration, parallel running and measuring progress.

By Akash Soni, Founder & CEO, Zuroth · Updated 9 Nov 2026 · 8 min read

The short answer

Don't rewrite everything at once. Put a routing layer in front of the legacy system, rebuild one module at a time as new services, switch traffic over, run old and new in parallel until results match, then retire the old code. This strangler fig approach keeps the business running, delivers value early and lowers risk.

Why big-bang rewrites fail

  • Hidden rules: decades of business logic live in code no one fully understands.
  • Moving target: the business keeps changing while the rewrite takes years.
  • Feature freeze: the old system can't change, and the new one isn't ready.
  • All-or-nothing cut-over: one go-live weekend carries all the risk.

Modernization options

Approach What it means When it fits
Rehost Move as-is to the cloud Stable systems, quick data-center exit
Replatform Small changes for managed services Reduce operations effort
Refactor Improve code without changing behavior Good core, messy code
Rebuild module by module Replace capabilities incrementally Core systems that block the business
Replace with SaaS Buy instead of build Commodity functions like HR or accounting

The 6-step plan

1. Map capabilities and pain

List what the system does, such as orders, billing, pricing and reporting, and score each on business value, change frequency, risk and technical pain.

2. Pick the first module

Choose something valuable and fairly separable. A good first module proves the pattern within 3 to 6 months.

3. Add a routing layer

Use an API gateway or proxy so each request can go to old or new code. Add monitoring on both paths.

4. Build the new module

Rebuild with modern architecture, tests and security. Capture business rules from code, data and the people who use the system.

5. Run in parallel and switch

Shadow traffic or run both and compare results. Move users gradually, by percentage, region or customer group, with a quick rollback.

6. Retire and repeat

Remove the old code path and its data once stable. Pick the next module, using what you learned.

How Zuroth helps

  • IT architecture assessments to map capabilities, risks and the right modernization path.
  • Legacy application modernization module by module, with routing, testing and parallel running.
  • API development and integration so old and new systems work together during the transition.

Our global forwarder case study shows a 20-year-old TMS replaced module by module with zero downtime.

Next step: book a free consultation for an architecture review.

Frequently asked questions

What is the strangler fig pattern?

The strangler fig pattern replaces a legacy system gradually. A routing layer sends requests either to the old system or to new services. You rebuild one capability at a time, switch its traffic to the new code and retire the old part, until the legacy system can be switched off.

Should we rewrite or refactor our legacy system?

Full rewrites are risky: they take years, freeze new features and often miss hidden business rules. Most companies do better with incremental modernization, rebuilding the highest-value or highest-risk modules first, while refactoring or rehosting parts that are stable and rarely change.

Which module should we modernize first?

Choose a module that is valuable, fairly self-contained and causing pain: frequent changes, performance or security problems, or a blocker for new features. Avoid starting with the most tangled core. An early visible win builds confidence and teaches the team the pattern.

How do you migrate data during incremental modernization?

Options include syncing data between old and new stores with change data capture, letting the new service own its data and exposing it back to the legacy system through APIs, or migrating in batches per customer or region. Reconcile both sides until the old store is retired.

How long does legacy modernization take?

The first module usually goes live in 3 to 6 months. Full modernization of a large system can take 1 to 3 years, but because value is delivered module by module, the business sees benefits early and can reprioritize as it goes.

Akash Soni

Akash Soni

Founder & CEO, Zuroth

LinkedIn ↗

FREE CONSULTATION

Talk it through with someone who does this work.

30 minutes with a senior expert. You leave with your top 3 risks and clear next steps, whether or not we work together. NDA before we talk.

Book a free consultation →