Why so many large rewrites fail
Application modernisation is often decided too late and carried out too broadly. Too late, because an old application works: as long as it provides the service, replacing it gives way to more visible projects. Too broadly, because on the day the decision is taken, the accumulation of problems pushes towards redoing everything at once.
The pattern that follows is well known. A rewrite programme is launched with the aim of replacing the old system in a single cutover. Meanwhile, the old system keeps evolving, because the business does not stop: the target moves. The business rules turn out to be more numerous than expected, buried in code that no one masters any more. The cutover date slips, the cost of double maintenance sets in, and the budget ends up being called into question before a single user has seen the new system.
The other failure, more discreet, is purely technical modernisation. The application changes platform, nothing changes for the business, and the next workstream can no longer find funding. A modernisation must deliver a visible benefit at each stage: an awaited change that has become possible, an operational risk removed, a cost eliminated.
Mapping the estate before deciding
No strategy can be chosen without knowing what you have. The mapping does not aim to cover the entire information system: it concerns the scope to be addressed and the information that weighs in the decision.
- Business value. Processes served, number and type of users, consequences of an outage.
- Technical condition. Out-of-support components, code quality, presence of tests, ease of deployment. This is the concrete measure of the technical debt accumulated.
- Couplings. Inbound and outbound flows, shared databases, chained batch processes. They determine what can be moved on its own.
- Available knowledge. Documentation up to date or not, people still able to explain the rules, dependency on a service provider.
- Imposed deadlines. End of support for a component, end of a hosting or maintenance contract, regulatory obligation.
This information comes from the application inventory, code analysis and interviews with those who use and maintain the applications. Cross-referencing business value with technical condition gives a first breakdown of the portfolio, to be discussed with the business departments.
Six application modernisation strategies
Vocabulary varies from one source to another, but six strategies cover most situations. They are ranked by depth of intervention, and therefore by increasing effort and risk.
| Strategy | Principle | When it suits | Limitation |
|---|---|---|---|
| Encapsulate | Expose functions and data through APIs, without modifying the core | Reliable, stable core, but closed to new uses | The internal debt remains intact |
| Rehost | Move the application as it is to another infrastructure | Hosting deadline, hardware at end of life | No gain in the code or in the ability to evolve |
| Replatform | Replace the runtime platform (operating system, database, application server) with few code adaptations | Platform component at end of support | Full tests to rerun for zero functional benefit |
| Refactor | Restructure the code without changing its behaviour | Valuable application, set to evolve a great deal | Requires a prior safety net of tests |
| Rewrite | Rebuild the application on new foundations | Technology with no future, unrecoverable code | Highest risk, business rules to be rediscovered |
| Replace | Abandon the application for a market solution | Function that has become standard | Adapting processes, data migration |
To these six strategies are added two decisions that are too often forgotten: retaining the application as it is, when it is stable and little used, and retiring it, when its use no longer justifies its cost. The strategies can be combined: the same application can first be encapsulated, then rewritten piece by piece. When the chosen strategy consists of rehosting or replatforming the application, the work joins that of cloud migration, which we cover on a dedicated page.
Our approach: migrating in reversible stages
When the application has to be transformed in depth, we recommend setting aside the single cutover in favour of progressive replacement. A proven pattern, known as the strangler fig, consists of placing a facade in front of the old system. This facade routes each request to the old or the new code according to the functional scope concerned. Scopes are cut over one by one, and the old system shrinks until it can be switched off.
Three points call for particular attention.
The boundary between the two worlds. The new code must not inherit the data model and workarounds of the old one. A translation layer, often called an anti-corruption layer, isolates the two models and disappears with the old system.
Coexistence of data. As long as two systems live side by side, you must state, for each data item and at each stage, which one is authoritative and how the other is kept up to date. This is one of the most underestimated subjects in progressive migrations.
Rollback. Each cutover is prepared with its rollback procedure, tested before it is needed. A stage from which there is no way back is a single cutover in disguise.
Such work extends across several scopes and involves several teams. It is managed as a programme, with its dependencies and trade-offs, according to the principles we describe for programme management.
Proving non-regression
Non-regression is not declared; it is demonstrated. On an old system, the reference specification no longer exists: the only reliable description of the expected behaviour is the current behaviour.
We therefore start with characterisation tests, which record what the system actually does on a representative set of cases, known anomalies included. Next comes parallel running: the old and new systems receive the same inputs, and their outputs are compared automatically. Each discrepancy calls for a decision. Either the new system is at fault, and it is corrected. Or the old one was, and the business decides whether this behaviour should be reproduced or corrected.
The comparisons also cover what functional tests do not see: response times, batch processing durations, volumes. Datasets drawn from production are anonymised or pseudonymised before use when they contain personal data. The overall organisation of these checks falls under software quality and testing.
Five pitfalls of modernisation work
- Applying a single strategy to the whole estate. ‘Everything to the cloud’ or ‘rewrite everything’ are slogans, not strategies.
- Aiming for an identical reproduction. Part of the functions of an old system are no longer used. Identifying them before migrating reduces scope and risk.
- Freezing business changes. A prolonged freeze is rarely held. It is better to plan how urgent changes will be carried during the transition.
- Forgetting to switch off the old system. As long as the old system runs, its costs keep running and the expected benefit is not achieved. Decommissioning is planned and funded like the other stages.
- Letting knowledge walk away. The people who know the existing system are involved in the work from its launch, not consulted on the eve of the cutover.
The signs of a modernisation that is progressing
Progress is read in what has actually been cut over, not in the effort consumed. The indicators we track with you concern verifiable facts: the functional scopes served by the new system, the applications and components actually switched off, the number of out-of-support components still in production, the residual discrepancies found during parallel runs.
To these are added indicators of effect. The time to release a change to production on a modernised scope, compared with what it was before. Incidents attributable to cutovers. The number of people able to work on the application, which measures the move away from dependency on a few experts. None of these measures is the subject of a promise made in advance: they serve to decide, stage after stage, whether the trajectory is still the right one.