Capability
Application modernization
Before quoting, the company sees and checks the calculation behind where to intervene and how much to rebuild. The applications its work depends on are rebuilt part by part, while they stay in use.
What the work covers
We map the system and its dependencies, then choose an intervention for each part. It covers the data, the interface, the platform the result runs on and the switch-off of what gets replaced. The engineers who read the system carry out the rebuild, inside the company's own team, and they run in production what they build.
When it pays off
A system does not have to be old to hold the business back.
Every change costs more than it returns
Business requests wait for weeks, each release touches parts that have nothing to do with it, and people fill the gaps by hand.
Few people can touch the code
Two or three developers know the system, or only the supplier who wrote it, and the documentation of the original system is gone.
Data leaves only in periodic extracts
Other systems, new channels and AI models receive copies already out of date, and every new integration is a project of its own.
Costs grow and a deadline approaches
Licences and proprietary databases weigh on the budget, and a component at end of support sets the date by which something has to change.
Share of the new-product budget spent on tech debt
INSIGHTS
10–20%
Of the new-product budget goes into tech debt
Fifty CIOs of large financial and technology companies estimate that between 10 and 20% of the technology budget dedicated to new products is spent on fixing tech debt instead. Source: McKinsey, Tech debt: reclaiming tech equity, 2020.
The business case decides where to intervene
Before quoting, we build the business case with the company's own people. Every lever, every point where technology can change a figure, has a formula, its parameters and a source. The company receives it in full and can challenge a parameter: the order of the work changes with it. We agree what will be measured and record each value before the work starts.
How the work runs
Scope, duration and price are fixed before the work starts: the company then decides whether to continue.
Assessment, two weeks
The company receives a map of the system, the risks in priority order, the intervention proposed for each part, the business case and the plan. We read the code with AI tools, even when another supplier wrote it.
Foundations and the first part live
We build the technical foundations only as far as the first step needs. The part replaced first is one of the critical ones, with an alternative plan written beforehand.
Replacement by increments
Each phase ends with a release in production. We repeat the same measurements and review what comes next with the company's own lead.
Switch-off and handover
We shut down the old system, match the resources to the real load and hand the result over to the company's own developers.
What happens to each part
The intervention comes out of the calculation: the lightest one that delivers the result wins, and leaving a part as it is can be the answer.
Move or change platform
The deadline comes from the infrastructure or from a component at end of support, and the application moves into containers and onto managed services.
Go deeper
Refactor or redesign part by part
A part that sets the company apart and changes often gets clear boundaries, as a microservice, and talks to the others through APIs and events. The same boundaries let models and agents work on it safely.
Go deeper
Replace or retire
A function that does not set the company apart can be replaced by a product on the market; features nobody uses do not move.
One part at a time, with the system running
A layer in front of the system sends each call to the old part or to the new one. This is the strangler fig pattern, and parts are swapped one at a time. A new part runs beside the one in use (blue-green) or reaches some users first behind a feature flag. If something fails, the previous version returns. The old part stays on until the new one holds the real load, and switching it off is part of the work.
Go deeper
AI reads the old system, and what it does becomes the test
What the system does today is the criterion by which every new part is accepted, and AI tools pull it out of the system itself.
From the system to the rules
AI tools read the code, the data and the real traffic. From them come the rules in force, the acceptance criteria and the tests.
Also without the source code
Where the code is gone, behaviour is observed from the outside: calls, database, batch files, screens. Recorded traffic is replayed against the new part.
What the new part has to pass
Those tests are the acceptance criteria. Old and new run for a while on the same inputs, and a difference shows up before anyone depends on it.
Data and coverage
Synchronisation and divergence are designed with the rest, and historical data moves in subsets. Tests cover what the observation exercised, and we say how far.
Go deeper
The interface and the people who use it
An interface in use for years carries habits and shortcuts nobody wrote down, so the rebuild starts from watching how people actually work. We validate the journeys before any graphic work, build the new interface on a design system and check accessibility on the components. The change arrives gradually, and the habits worth keeping stay.
Go deeper
What stays with the company
Code, infrastructure described as code, tests and the documentation of how the system behaves stay in the company's repositories, so another supplier can take over without starting again. In-house developers work alongside ours and take on tests, delivery pipelines and the design system, with training and code review on agreed days. The system then goes on without us.
Go deeper
Evidence and further reading
Case studyHandling 50% more cases without rewriting the calculation engineFor Fiabilis, technology is the production line. Having reached 6,000 cases a year, the infrastructure hit its limit. The answer: a cloud architecture that orchestrates the workflows and keeps the original calculation engine intact.
Case studyContinental brings its B2B supply chain into a single cartA multi-supplier B2B architecture: how BestDrive leads its own evolution
Case studyOne brand, 50 markets: Mapei's architecture for global scaleA modular, multi-tenant platform: how we have supported Mapei's evolution since 2018
Case studyPerdormire: the sale doesn't stop between website and storeFrom online configuration to closing the sale in store, without interruption.
Contact us to validate the technical feasibility,
business impact and build your business case together.
FAQ
No. Only what the business case points to gets rebuilt, with the lightest intervention that delivers the result. Sometimes the calculation shows that an important part is better left as it is, and the plan says so, with what leaving it costs. The work starts where the value is highest and the effort lowest, so the first results arrive early.
The assessment takes two weeks. After that the time depends on the intervention chosen for each part, and the first part reaches production in the second phase rather than at the end. Each phase closes with a release, so the plan can be reviewed before the next one starts.
The previous version comes back, following a plan written before the release. Monitoring says when the new part holds the real load, and only then does the old one go off. There is always a working version in use, and no release depends on everything else being finished.
The work needs access to the code and to an environment with production data. It also needs a contact person who decides and one or two people who know the system well. Personal data handled during the work falls under our ISO/IEC 27001-certified management system.
Yes. AI tools read the code, the data and the real traffic. From them come the dependencies, the behaviour and the tests that pin down what the system does today. Where the source code is gone, the behaviour is observed from the outside and recorded traffic is replayed against the new part. Every change still goes through those tests and the review of an engineer, and we answer for what reaches production.