Modernisation should begin with the change the organisation needs to make next, not with a preferred technology or a programme to replace everything.
Name what limits change before choosing the intervention
A platform can be stable and still limit the business. A new proposition may take months because customer data is duplicated across systems. A pricing change may require a coordinated release across several teams. A reliable core may be surrounded by integrations that nobody can alter with confidence. Each is described as a legacy problem, but each requires a different response.
Modernisation goes wrong when age, architecture style or cloud adoption becomes a proxy for the actual constraint. A newer platform can be expensive and difficult to change. An older one can contain dependable domain logic that would be costly to rediscover. The useful question is not ‘What should we replace?’ It is ‘What prevents the required change, and where does that limitation originate?’
Start with the business move: launch into a market, change a service, reduce failure demand, integrate an acquisition, introduce an agentic workflow or meet a new control. Then follow the obstruction through process, data, software, infrastructure and ownership. The first technical symptom is not always the root cause. A release bottleneck may sit in test environments or approval design rather than in application code.
Build an evidence base around the live estate
Architecture diagrams and dependency lists rarely show the complete operational reality. Combine them with code and data analysis, release history, incidents, cloud and licence cost, service performance, customer journeys and the knowledge held by the people who operate the platform. The aim is not a perfect inventory. It is enough evidence to make a bounded decision without relying on folklore.
Look for four things. First, value: which capabilities differentiate the business or protect a critical operation? Second, friction: where do changes wait, fail or require disproportionate coordination? Third, risk: which dependencies, unsupported components or data practices create material exposure? Fourth, optionality: which boundaries would make the next set of changes easier, not simply make the diagram more modern?
This separates age from consequence. A mature settlement engine with stable behaviour and clear interfaces may be worth retaining. A recently built customer service that duplicates rules and cannot be deployed independently may be the better modernisation target. Evidence also reveals knowledge that must be preserved before change begins: exception rules, reconciliation practices and operational workarounds often embody requirements absent from formal documentation.
Choose the approach required to achieve the outcome
Retain, encapsulate, replatform, refactor and replace are not competing strategies. They are interventions that can be combined around a specific boundary. Retain what remains dependable. Encapsulate a difficult dependency behind a stable interface. Replatform where the operating environment is the constraint. Refactor where the capability is valuable but its internal design blocks change. Replace only where the outcome justifies reconstructing behaviour and migrating responsibility.
Established architecture guidance supports incremental change for good reason. The Strangler Fig pattern introduces an interface that routes work between existing and new implementations while responsibility moves in stages. Microsoft and AWS both emphasise its ability to reduce migration risk, while also warning about transitional complexity, shared data, rollback and the possibility that the façade itself becomes a bottleneck. A recognised pattern is not an automatic answer; its trade-offs still have to fit the system.
Select a boundary that is valuable enough to matter and contained enough to learn from. A frequently changing capability with clear inputs and outputs may be better than the oldest component. Define what will move, what will remain, how consumers will be protected and which evidence will permit the next step. The result should deliver an operational improvement, not merely create a new service beside the old one.
- Retain when a capability is dependable, understood and does not obstruct the required change.
- Encapsulate when a dependency must remain but consumers need a safer, more adaptable interface.
- Replatform or refactor when the capability remains valuable but its environment or internal design is the constraint.
- Replace when the existing behaviour no longer serves the outcome and the migration boundary can be controlled.
Design continuity as part of the modernisation
The target architecture matters, but the organisation experiences the transition. During change, old and new behaviour may coexist, data may cross more boundaries and teams may operate temporary controls. Treat this as a designed architecture with an owner, costs and an exit condition, not as an untidy interval between two clean diagrams.
For each increment, define how traffic or work is routed, which system owns each item of data, how results are reconciled, what is observed and how the change is reversed. Parallel running can increase confidence, but only if discrepancies are visible and someone is accountable for resolving them. A rollback plan is credible only when the old path and the data needed to use it remain valid.
Progress should be demonstrated in production outcomes: a shorter lead time for the target change, fewer failure points, improved recovery, lower operating cost or a clearer path for the next capability. Decommissioning is part of delivery. If old code, interfaces and controls remain indefinitely, the organisation inherits additional complexity rather than modernisation.
Use a decision frame, not a rewrite reflex
The strongest argument for a wholesale rewrite is conceptual clarity: one target, one architecture and no transitional compromise. For a small, well-understood system, or where the existing system cannot be intercepted or safely changed, replacement may be the simpler option. Incremental modernisation also has a cost. It can preserve poor boundaries, prolong duplicate operation and create temporary infrastructure that becomes permanent.
The decision should therefore compare whole routes, not idealised end states. Assess time to the first business outcome, migration and continuity risk, knowledge reconstruction, data integrity, operating cost during transition, reversibility and the adaptability created afterward. Make the assumptions visible. A route that looks slower in a target diagram may produce value earlier and reveal uncertainty while it is still cheap to act on.
AI adds another reason to modernise selectively. Agents need usable interfaces to context, tools, permissions, state and operational evidence. That does not mean rebuilding the estate for AI. It means prioritising the boundaries that let people and agents act safely: authoritative data access, observable workflows, scoped actions and clear ownership. WQA's contribution is to connect that platform decision to the product and operating change it must enable, then deliver the transition in evidence-led increments.
- Outcome: what must become possible, and by when?
- Constraint: what specifically blocks it across process, data, software, infrastructure or ownership?
- Intervention: what changes will remove the constraint while preserving dependable value?
- Transition: how will old and new responsibilities coexist, reconcile, recover and exit?
- Evidence: which production measures will justify continuing, changing course or stopping?
Sources and further reading
- Microsoft Azure Architecture CenterMicroservices assessment and readiness
- Microsoft Azure Architecture CenterStrangler Fig pattern
- AWS Prescriptive GuidanceDecomposing monoliths into microservices
- Google Cloud Architecture CenterChoose components for your agentic AI architecture