Every legacy modernization conversation opens with the same question, and it deserves a straight answer: we cannot give you a credible range, and neither can anyone else who has not read your code.
That is not evasion. It is the single most important thing to understand about legacy software modernization cost. In a greenfield build, the unknowns live in the requirements, and requirements can be written down and priced. In a modernization, the unknowns live inside a system that has been accumulating decisions for ten or twenty years. The specification is the code, and nobody has read it yet.
What we can do is tell you exactly what moves the number, which of those factors you can assess yourself before you talk to anyone, and how to structure a budget so you are not committing to a figure that was guessed. That is what this guide covers.
If you are still deciding whether to modernize and which route to take, that is a different question and we have answered it separately in the legacy application modernization strategy guide. This article assumes the decision is made and the budget conversation has started.
Why a published range would mislead you
Suppose we published a figure for “a mid-sized application”. Two systems land on your desk with the same screen count, the same user base, and the same business function. One is a layered application with a separated data tier and a working test suite. The other has business rules in stored procedures, UI logic in code-behind files, and three integrations whose vendor contracts nobody can find.
Those two systems do not cost the same to modernize. They do not cost similar amounts. The second one can consume several times the effort of the first, and the difference is invisible from any description you could write in a brief.
This is why the shape of a modernization estimate differs from a build estimate:
- A build estimate is scoped from requirements. You know what you want; the question is how much work it takes to make it.
- A modernization estimate is scoped from evidence. The requirement is largely “behave the way it behaves now”, and the work is set by how legible the current behaviour is.
A range published without that evidence is either so wide it tells you nothing, or narrow and wrong. Both are worse than the honest answer.
The six drivers that decide the number
These are the factors that move a modernization budget more than any others. You can assess most of them yourself, roughly, before any vendor is involved.
1. Codebase size and coupling
Line count is the figure everyone reaches for and the weakest predictor in the set. What matters is coupling: whether business logic, data access, and presentation can be separated.
A tightly coupled codebase cannot be moved module by module, because there are no modules. Every change pulls in neighbouring code, regression risk spreads across the whole application, and the incremental approaches that de-risk a migration stop being available. That constraint alone can change both the cost and the approach.
How to assess it yourself: ask your engineers whether a single screen can be changed and tested without touching anything else. The answer is usually immediate and usually honest.
2. Integration surface
Count every system the application talks to, then weight each one by a single question: do you control the contract on the other side?
An internal service you own can be adapted. A vendor API, a bank interface, a government filing endpoint, or a partner’s file drop cannot. Those have to be matched exactly, tested against systems you may not have a sandbox for, and coordinated with parties who have their own release calendars. The integration you cannot control is consistently more expensive than the one you can.
3. Data migration and history
Three things set this cost, and they are independent of each other:
- Volume, which is the least important of the three and the one people fixate on.
- Schema drift, meaning the columns added over the years, the fields repurposed for a second meaning, the nullable keys that should never have been nullable.
- History depth, meaning how many years must move with full integrity versus how many can be archived to cold storage and read separately if ever needed.
That last one is a genuine lever. Organisations frequently migrate a decade of history at full fidelity because nobody asked whether they needed to.
4. Inherited test coverage
Most legacy systems arrive with little or no automated test coverage. That is not a criticism of the teams who built them; it reflects when they were built.
It matters for cost because you cannot verify a migration against a baseline that does not exist. Before you can prove the modernized system behaves correctly, somebody has to establish what “correctly” means, usually by building a regression suite against the legacy application first. That work is real, it comes before the migration rather than during it, and it is frequently left out of estimates that look cheap.
5. Undocumented business logic
This is the driver that surprises budgets most often.
Every long-lived system contains rules that exist nowhere but the code: a discount calculation with four exceptions, a validation that was added after an incident in 2014, a nightly job whose output three departments depend on without knowing it. Some of it lives in stored procedures, triggers, and scheduled tasks rather than in the application at all.
Recovering those rules is archaeology. It cannot be estimated from the outside, and its size correlates with the system’s age and the turnover of the people who built it. When we re-engineered a cement manufacturer’s procurement platform off ASP.NET Web Forms in 2023, a substantial share of the work was tracing logic embedded in SQL functions, triggers, and jobs before any of it could be rebuilt. That mapping phase was not overhead; it was what made the rest of the programme predictable.
6. Regulatory and audit scope
If the system is subject to external audit, or handles regulated data, three things change:
- Evidence requirements. You need to demonstrate what the system does, who changed it, and that controls held throughout the migration.
- Target architecture constraints. Data residency and access control requirements can rule out otherwise cheaper hosting and design options.
- Validation effort. Testing to a standard an auditor accepts takes longer than testing to a standard your team accepts.
None of this makes modernization unaffordable. It does mean a system aligned with regulatory obligations costs meaningfully more to move than an internal tool with the same screen count.
Get a modernization estimate
Send us the stack, the integration list, and read access to the code. We will come back with a scoped estimate built on evidence rather than averages.
How the approach changes the shape of the cost
Choosing between the approaches is a strategy question, and we work through the decision criteria in the strategy and assessment guide. What matters for budgeting is that each approach puts the money in a different place and leaves a different amount of cost behind.
| Approach | Where spend concentrates | What makes it overrun | Cost left behind |
|---|---|---|---|
| Rehost | Infrastructure, packaging, cutover | Hidden OS and runtime dependencies | High: the architecture moves with you |
| Refactor | Framework layer: config, DI, routing, auth | Coupling discovered mid-migration | Moderate: structure largely preserved |
| Re-architect | Decomposition, service boundaries, data separation | Boundaries drawn before the domain is understood | Low, if the boundaries are right |
| Rebuild | Requirements recovery and full build | Undocumented logic found late | Lowest, at the highest upfront cost |
The pattern worth noticing: the cheapest first invoice and the cheapest five years are rarely the same approach. Rehosting clears the immediate problem and carries the legacy structure forward, which means paying again later. Rebuilding front-loads everything. That trade is a budgeting decision as much as a technical one, which is why approach and funding model should be settled together rather than one after the other.
What AI-assisted tooling actually changes
AI-assisted conversion is the biggest recent change to modernization economics, and it is routinely oversold. Here is the honest split.
What it compresses: the mechanical translation. Namespace and API mapping, syntax conversion between related frameworks, resource restructuring, boilerplate regeneration. This is a large share of the raw work on a like-for-like migration, and the compression is real.
We can put a measured figure on that rather than an estimate. On a Xamarin to .NET MAUI migration for a cement manufacturer, three business-critical applications were migrated at roughly 15 days per application against a conventional estimate of about two months each, with all three reaching UAT in under four weeks. That is our own delivery data, not a vendor claim.
What it does not compress:
- Engineering review of every converted output.
- Platform-specific edge cases, which is where the remaining effort concentrates.
- Testing and parity verification, screen by screen, against the legacy baseline.
- Integration work against systems whose contracts you do not control.
- The data migration, which tooling barely touches.
The useful way to hold this: tooling reduces the translation cost and leaves the verification cost roughly where it was. On a migration between closely related frameworks, translation is a big share of the total and the saving is substantial. On a re-architecture, where most of the work is design and decomposition, the saving is much smaller. Any proposal claiming a uniform multiplier across both is describing a sales position rather than engineering.
The costs that do not appear in the quote
These are genuine, unavoidable on a live system, and routinely absent from the comparison when you put two proposals side by side.
- Parallel running. During a phased cutover both systems are live. You are paying for two sets of infrastructure, two sets of licences, and the engineering to keep them consistent.
- Dual maintenance. The legacy application does not freeze while you build. Production defects and regulatory changes still have to be handled in it, by people who could otherwise be working on the new one.
- Data reconciliation. Keeping legacy and target data aligned through a gradual switchover is its own workstream, and it runs for the length of the transition rather than as a one-off task.
- User transition. Training, documentation, and the productivity dip while people relearn a system they knew well.
- Post-go-live stabilisation. The weeks after cutover, when real traffic surfaces what staging did not. Budgeting zero for this is the most common way a programme that was on track ends over.
- Your own people’s time. Business analysts, testers, and domain experts are required throughout. That capacity is usually not costed because it is internal, but it is not free and those people are not doing their other work.
How to phase the budget so spend tracks value
The structural answer to an unknown total is not a bigger contingency. It is a funding model where you commit progressively and can stop.
Fund the assessment separately, and first. A codebase and data assessment is a days-long exercise, not a months-long one, and its deliverable is the estimate for everything after it. Treating it as its own small commitment means the large commitment is made with evidence. If a vendor will not scope an assessment independently of the delivery contract, that tells you something.
Release budget per slice, not per programme. The Strangler Fig approach exists for risk reasons, and it has a budgeting benefit that gets less attention: each increment goes to production and starts returning value before the next is funded. Spend tracks delivery instead of running ahead of it.
Sequence by risk, not by ease. The temptation is to start with the simplest module to show early progress. The better order is to take an early slice that proves the hard parts: the worst integration, the gnarliest data, the module nobody understands. If the approach is wrong, you want to find out in month two on one module, not in month nine across six.
Put a decision gate at every increment. Each slice ends with an explicit continue, adjust, or stop. This is what converts an unknown total into a series of known, bounded commitments, and it is the only honest answer to a budget question that cannot be answered precisely upfront.
Budget the stabilisation period explicitly. Name it, fund it, and put it in the plan. It is going to happen either way.
If you are weighing this across several applications rather than one, sequencing matters more than per-application cost, and the legacy stack migration playbook covers how to order a mixed estate. Our modernization accelerators show where tooling applies by stack.
The short version
- No credible range exists without a codebase assessment. Anyone offering one before reading your code is padding or guessing.
- Six drivers decide the number: coupling, integration surface, data history, inherited test coverage, undocumented business logic, and regulatory scope. You can assess most of them yourself.
- Approach sets where the money goes and how much cost you carry forward. The cheapest first invoice is rarely the cheapest five years.
- AI-assisted tooling compresses translation, not verification. Real on like-for-like migrations, much smaller on re-architecture.
- Parallel running, dual maintenance, reconciliation, training and stabilisation are real costs that quotes routinely omit.
- Phase the funding. Assessment first and separately, then budget per slice with a decision gate at each one.
The question “what will this cost” cannot be answered well in an article. It can be answered properly in about a week, by people reading your code. That is the next step, and it should be a small commitment rather than a large one.
Get a modernization estimate
Tell us what the application does, what it runs on, and what it integrates with. We will scope an assessment and come back with an estimate built on your code, not on averages.