Re-platforming a 12-year-old system without a maintenance window. The incremental strategy that keeps you live while you modernize.
Key takeaways
- The big-bang rewrite is the most expensive mistake in software.
- Strangle the monolith one capability at a time, with rollback at each step.
- Dual-writes and backfills move data while both systems stay live.
The big-bang rewrite is the most expensive mistake in software. The alternative — strangling the monolith incrementally — is slower to start but dramatically safer.
Strangle, don't replace
We route traffic through a thin layer in front of the monolith, then peel off one capability at a time into a new service. The old and new systems run side by side until the last piece moves.
- Front the monolith with a routing layer
- Migrate one bounded capability at a time
- Keep a clean rollback path at every step
Migrate data without downtime
Dual-writes and backfills let you move data while both systems stay live. You cut over only once the new path is proven under real load.
Zero downtime isn't luck — it's a sequence of small, reversible steps.
Frequently asked questions
Rewrites carry enormous risk: you freeze features for months and bet everything on a single cutover. Incremental migration ships value continuously and keeps a rollback path.
A routing layer, dual-writes, backfills and feature flags let the old and new systems run together — you only cut over once the new path is proven.
It scales with the system, but most modernizations run in phased increments over a few months rather than a single big release.
Written by Marcus Hale
Principal Engineer at Zoomcode
