Short answer: Don't stop the business for a big-bang rewrite. Stabilize the current system first, then replace it one slice at a time behind the same interfaces, moving traffic over gradually and keeping the old path as a fallback. Each slice ships value on its own, so revenue keeps flowing while the platform changes underneath.
Most legacy platforms still make money. That's the problem. They're too important to switch off and too fragile to change quickly. Every new feature takes longer, a few people understand the risky parts, and the team spends more time firefighting than building.
The tempting answer is a full rewrite. It is also the riskiest one. A rewrite freezes new features for months, has to match years of hidden behaviour and often launches late into a business that has moved on.
There is a safer way, and it starts before any new code.
Step 1: Stabilize what you have
You can't modernize a system you can't see. Before changing anything:
• Add monitoring and alerts on the flows that earn money: checkout, payments, sign-up
• Map the system: what talks to what, where the data lives and which parts break most
• Write tests around the riskiest paths, so later changes can be checked against current behaviour
• Fix the top recurring incidents, so the team gets time back to plan
This phase is unglamorous, but it turns a broken platform into a stable one, and it usually pays for itself in fewer outages.
Step 2: Replace in slices
Instead of rebuilding everything, pick one capability at a time (search, pricing, notifications, reporting) and rebuild it as a modern service. A routing layer in front decides whether each request goes to the old code or the new one. Engineers often call this the strangler pattern, because the new system slowly wraps and replaces the old.
For each slice:
1. Build it behind the same interface the rest of the system already uses.
2. Send a small share of traffic to it and compare results with the old path.
3. Increase traffic once the numbers match. Keep the old path as a fallback.
4. Remove the old code only when the new slice has run cleanly for a while.
Step 3: Pay down debt as you go
Technical debt quietly drains the innovation budget, because every shortcut adds time to every future change. During modernization, treat debt like any other backlog item: name it, size it and set aside part of every sprint for it. Prioritise debt in the code you touch most often, not the code that looks worst.
Where AI fits
Modernization is a good moment to add AI where it pays, such as automated document handling, support triage or forecasting. Add it to the new slices, not the old core, so you can measure the effect cleanly.
An example
We built middleware for iCertify that modernized the money order business across 1,241 retail locations. Work at that scale only succeeds when stores keep trading while the systems behind them change. That's the same principle described here.




