Rebuilding more than ten business applications without ever stopping the business
Inside the IT department of a multi-country distribution group, more than ten applications were rebuilt. One at a time, never all together. What that choice costs, and what it avoids.
By Laurent TulpanPublished 9 min read
The engagement sat inside the corporate IT department of an international distribution group operating in several countries, with subsidiaries that shared neither the same tools nor the same habits.
More than ten business applications to rebuild. None of them optional: they were what the operation ran on every day.
The structural decision was taken at the start, and everything else follows from it. We do not rebuild everything at once. We rebuild one application, put it into service, confirm it holds, and move to the next.
Why that choice, when it costs more
It has to be said plainly: rebuilding in waves costs more than rebuilding at once, and it shows on the quote.
Each wave redoes its own scoping, its own cutover, its own data migration, its own training. Some technical foundations are shared, many are not. The total exceeds what a single program would have shown.
What the single figure does not show is cutover day.
In a big-bang rebuild, everything changes on one morning. If invoicing does not work, you cannot roll back invoicing alone: the rollback covers the whole thing, to a system that has not evolved for months and whose data are no longer current. That day is not a project milestone, it is an event with irreversible consequences.
In a wave-based rebuild, the same failure concerns one application. The previous version is still running, you go back to it while you fix, and the rest of the group does not notice.
The extra cost is the price of that reversibility. It should be compared against what a day without invoicing costs a distribution group, and that comparison is rarely close.
What the first wave is really for
It is there to discover what the plan underestimated, and there is always something.
On a rebuild, the unpleasant surprises almost never concern the technical work. They concern behaviors nobody documented because everybody knew them: a discount rule applied only to certain customers, a report printed on the first of the month that nobody could still name a reader for, a field repurposed years ago to hold something else.
These do not surface by interviewing users, because they are too obvious to be mentioned. They surface by putting the new system into service and listening to what comes back.
That is why the first application should be neither the most critical nor the most trivial. The most critical makes those discoveries too expensive. The most trivial produces none, and you approach the second wave with the same ignorance as the first, plus the false confidence of an easy win.
The rule that holds it together: one source per piece of data
During a wave-based rebuild, two systems coexist. That is the dangerous period, and the danger is not technical.
If the same piece of data exists on both sides and can be modified on both sides, they will diverge. Not might: will, and it will be noticed weeks later, when two reports do not agree and nobody can say which one to believe.
The rule we held is easy to state and demanding to apply. For each piece of data, at any moment, exactly one system is authoritative. The other receives it and does not modify it. When a wave transfers authority over a piece of data, the transfer is dated and the old system goes read-only on that data specifically.
That requires knowing, before each wave, which data change sides. It is the least glamorous preparation work in the exercise, and the one whose absence is paid for most dearly, in the same way that an unverified migration is a migration that has not happened.
Hosting, treated as a subject in its own right
Alongside the applications, hosting was consolidated onto a single cloud.
That is not a fashion decision. A multi-country group where each subsidiary hosts wherever it can accumulates situations nobody has a full view of: servers under a desk, contracts signed locally, backups nobody is sure who verifies.
Consolidating produced an effect that matters more than any saving: the hardware risk changed hands. It is no longer carried by internal teams doing what they can, it is carried by a host who answers for it contractually.
That is a transfer of responsibility, not a disappearance of risk. It is worth exactly what the contract is worth, which brings you back to reading service commitments carefully rather than trusting a percentage on a slide.
What I would do differently
Two things.
Write the order of the waves down, and make it arguable. The order adjusted along the way, which is normal, but each adjustment took a discussion that would have been shorter had the prioritization criterion been written at the start. A written order is not there to be held to. It is there to give a starting point when it has to change.
Close each wave explicitly. The temptation, once an application is live, is to move straight on. What is then missing is the moment where everybody agrees the old version can be switched off. Without it, the old version stays up just in case, and six months later you are maintaining two systems for an application that uses one.
What this way of working says about the rest
Rebuilding in waves is not a project technique. It is a position on risk: we would rather pay more than ever be somewhere we cannot come back from.
That position transfers. It is why a data migration is run blind before it is run for real, why a deployment carries a written rollback procedure before it is launched, and why the honest answer to “will it work” is less useful than an answer to “what do we do if it does not”.
It is also, in a different form, what makes a system possible to hand over at all: a rebuild that can be stopped between waves is a rebuild whose state somebody else could pick up. That is the same discipline as transferring a system with the people who will run it.
Further reading
- Making the case for technical debt: why the full rewrite is nearly always wrong
- Modernize or renegotiate: the decision that comes before the method
- Cloud or on-premise: the hosting half of this engagement
- Acceptance criteria that end the argument: how each wave was declared finished
- Legacy modernization: how we run this kind of program
The questions this raises, answered straight.
Why not rebuild everything at once, since it is cheaper?
On the quote, it is. A single program shares the scoping, the technical setup and the change management, so its price is mechanically lower than the sum of ten separate projects.
What the quote does not price is cutover day: everything changes at once, and if something does not work there is no partial way back.
The extra cost of rebuilding in waves is an insurance premium, and it should be compared against what the outage it prevents would cost.
How long should the two systems run side by side?
The length of one wave, no longer. Coexistence is a real burden: two systems to maintain, data to keep aligned, users who need to know where to go. That is bearable for a few weeks per application and unliveable for a year.
A wave whose coexistence drags is a wave that was not finished, and it is the signal to stop launching new ones.
Which application should go first?
Not the most important, and not the simplest. The one that teaches the most for the least risk: real enough that the method is genuinely tested, isolated enough that a failure does not stop the business.
The first wave is not primarily about delivering an application, it is about discovering everything the plan underestimated, and it is better to discover that there.
How do you handle urgent changes during the rebuild?
This is the question that kills big-bang rebuilds and that waves make bearable.
On an application already migrated, the change goes into the new system. On one not yet reached, it goes into the old, knowing it will be redone.
The rule to hold is never to build the same change twice in parallel: either you bring the wave forward, or you accept a temporary fix in the old system.
Recognize your situation? 20 minutes is enough to tell.
Describe what is happening on your side, and where your data and customers are. You get a plain answer on whether we can help, and a better route if there is one.

