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.
Related reading
- Software Development services
- How to scope an MVP
- Why digital transformations stall
- Legacy application modernization
- IT architecture assessment
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.