# Old system: rewrite from scratch or replace it in parts?

> A full rewrite puts all the risk into one cutover. Here is what the research says about replacing an old system in parts, and what coexistence costs.

- Author: Marlon Trettin
- Published: 2026-11-12 · Updated: 2026-11-12
- Language: en
- Canonical: https://yowpi.com/en/blog/old-system-rewrite-from-scratch-or-replace-in-parts

---

In most cases, replacing an old system in parts is safer than rewriting it from scratch. A rewrite puts all the risk into a single cutover and returns value only at the end. Replacing in parts spreads the risk across small steps, but it has a price: the two systems coexist, and that coexistence has to be designed.

## TL;DR

- A full rewrite promises a system identical to the old one on newer technology. Rarely can anyone specify "identical", because the business rules tend to live in the code, not in a document.
- In 1993, Brodie and Stonebraker listed eight reasons the rewrite is risky. In our reading, seven of them describe the company, not the technology, and they still hold.
- Replacing in parts has its own cost: the bridge between old and new, which is expensive to build and is meant to be thrown away.
- The decision is architectural. What sets the path is where the old system can be cut, and that is found out before asking for a quote.

## Why does a rewrite look like the obvious choice?

Because the plan fits in one sentence. The system is twelve years old, every change takes too long, and the one person who knows it is overloaded. Building another one on current technology that does the same thing sounds cleaner than touching what exists.

Martin Fowler describes this plan in the article where he presents the Strangler Fig pattern, [revised in August 2024](https://www.martinfowler.com/bliki/StranglerFigApplication.html): build a new system that does exactly what the old one does. According to him, this simple-sounding plan fails most of the time. That is a practitioner's account, not a measurement. Fowler is at Thoughtworks, a consultancy that works in system modernization, and the text carries the weight of someone who has seen many such projects.

He gives two reasons. Replacing a serious system takes a long time, and the operation does not wait that long without asking for changes. And the current behavior is hard to specify, and it includes a lot that nobody wants anymore.

## What does the research say about a full rewrite?

It says the risk is structural. In 1993, Michael Brodie and Michael Stonebraker published [a technical report on migrating legacy systems](https://dsf.berkeley.edu/papers/S2K-93-25.pdf) and named the two strategies. Cold Turkey is rewriting from scratch and cutting over at once. Chicken Little is migrating in small steps while the system stays live.

For Cold Turkey, the authors state that the strategy carries substantial risk of failure and list eight reasons. A better system has to be promised, because a one-for-one rewrite is nearly impossible to get approved. The business does not stand still while the project runs. Specifications rarely exist, and the only documentation is usually the code itself. There are dependencies nobody documented. The system can be too big to cut over at once. Large projects are hard to manage. They run late, and lateness is seldom tolerated. And they tend to bloat.

The report includes two cases without naming the companies. At a bank, one of the core components of the cash management system had 1 million lines of COBOL, of which about 300,000 served no current function. Anyone quoting an "identical" rewrite would be paying to rebuild almost a third of dead code, or paying for the work of finding out which third it was. At a telephone company, the provisioning system, dating from 1972, had already prompted more than 25 replacement studies. According to the report none of them succeeded, and at least one full rewrite attempt failed.

These are 1993 figures from systems far larger than a mid-sized company runs. What carries across the decades is the mechanism. In our reading, only the reason about a system too big to cut over at once (the time it takes to load the data) has lost force with technology. The others describe the company, not the computer. A [research survey from Trinity College Dublin](https://publications.scss.tcd.ie/tech-reports/reports.97/TCD-CS-1997-01.pdf), from around 1997, reached a similar conclusion about the single cutover: the risk of failure is usually too great for a full rewrite to be seriously considered.

## What does a failed cutover cost?

A well-documented case is the British bank TSB. In April 2018, the bank migrated its customer data to a new IT platform. According to the [statement from the FCA, the UK financial regulator](https://www.fca.org.uk/news/press-releases/tsb-fined-48m-operational-resilience-failings), the data migrated successfully, but the platform immediately experienced technical failures.

All branches and a significant proportion of its 5.2 million customers were affected. The bank only returned to business as usual in December 2018, eight months later. It paid £32.7 million in redress to customers and, in December 2022, was fined £48.65 million by the FCA and the PRA.

The statement does not discuss whether the migration should have been phased. The regulators point to failures in planning, in the governance of the program and in managing the outsourced supplier. The reading that follows is ours: the data migrating correctly was not the test that mattered. The test that mattered was the new platform carrying the whole operation, and that is where it failed.

The scale is a bank's. Your company does not have 5.2 million customers or a prudential regulator. The shape of the risk is the same: in a single cutover, the first time the new system meets the real operation tends to be the day when going back has already become expensive.

## Is replacing in parts free?

No, and that bill is often left out of the conversation. For old and new to coexist, something has to sit between them. Brodie and Stonebraker call this piece a gateway and warn that it can be very costly to build and can weigh on performance. Keeping data consistent on both sides is, in their words, one of the most complex technical challenges in the migration.

The Trinity College survey adds a risk: in some architectures, the bridge can never be eliminated. Fowler admits the same cost from another angle. Teams resist writing code that will be thrown away when the transition ends. His position is that the lower risk and the earlier value outweigh it.

What the 1993 report proposes in exchange is discipline per step. In the bank case there were three rules: no step above ten person-years of development, no step longer than one calendar year, and each step had to pay back its cost within a year. The numbers are a bank's and do not fit a mid-sized company. The rule does: each part has its own size, deadline and return. If a step fails, you repeat the step, not the project.

From there comes the question that decides the path, and it is not a technology question. Where can the old system be cut? Fowler calls these points seams and acknowledges that an old system rarely offers them ready-made. Finding them is a matter of reading the operation and the code, done by people who understand both. An AI tool speeds up reading the code. Deciding which part leaves first remains judgment.

## When does a full rewrite make sense?

In few cases, and they share some traits. This part is our reading of the sources, not a measured result. A rewrite with a single cutover is defensible when the four conditions below hold together:

- The system is small enough for the new version to be ready before the operation changes.
- The rules are written down outside the code and someone in the operation confirms them.
- The company can absorb a short stoppage, and the cutover can be rehearsed with real data beforehand.
- There is a tested way back to the old system if the first day goes wrong.

If one of them is missing, the project inherits at least one of the eight reasons from 1993.

## What does this look like in a mid-sized company?

The scenario below is a hypothesis for illustration, and its numbers are not measurements. A distributor has used the same system for orders, inventory and invoicing for twelve years. It receives a proposal for a full rewrite in ten months, with the cutover over a weekend.

For those ten months, the company pays for two systems and uses one. Every new rule, a discount per channel, a change in freight, has to be built twice or wait. In the tenth month, the new system meets a real month-end close for the first time.

The other path starts with a part that has a clear boundary, order entry for example. The new module records the orders and hands them to the old system, which keeps handling inventory and invoicing. Within a few months people are using the new part, and what is learned there changes the design of the next one. The cost is the bridge between the two, which needs an owner and a [date to be switched off](/en/blog/when-to-switch-off-the-old-system-after-go-live).

In our work with [Colo Saúde](/en/cases/colo-saude), the platform inherited from another vendor was first audited and optimized. The migration to another technology came later and is in progress, with the operation live. [UniTrust](/en/cases/unitrust), a US insurance IMO, is also mid-migration, to Next.js on Azure, with more than 8,000 active users on the platform. The reasoning connects with what the data shows about the [cost of changing software late](/en/blog/cost-of-changing-software-late-what-the-data-shows): the cost depends on where the rule lives.

## Frequently asked questions

**Doesn't replacing in parts end up costing more in total?**

It can, if you add up development alone. The bridge between the two systems is a cost a full rewrite does not have. The complete comparison includes what the rewrite hides: months of paying without using, rules implemented twice and the cost of a cutover that fails. When you replace in parts, each step can be judged by the return it brought.

**Won't the integration between the old system and the new one be complicated?**

It tends to be one of the hardest parts of the project, and the sources say so plainly. That is why it is designed first, before any screen. If the old system does not allow data to be read or written from outside, that fact changes the plan and has to surface before the quote.

**My team is used to the old system. Does that weigh on the choice?**

It weighs in favor of replacing in parts. In a single cutover, everyone changes everything on the same day. In steps, one area changes one routine at a time, and the rest of the operation stays with what it knows while the first part proves itself.

## The next step

If there is a rewrite proposal on your desk and nobody can say where the current system can be cut, the Operational Architecture Diagnostic is a 30-minute conversation that starts with that question. [Talk to an architect](/en/contact).
