Home › Insights › Blogs › App Modernization

How Much Does Legacy Software Modernization Cost? The Drivers Behind the Number

Mohit Agarwal Mohit Agarwal
Last updated: 5 Nov 2026
Get an AI summary of this post on Perplexity ChatGPT Gemini

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.

Get a modernization estimate

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.

Where the cost sits, by modernization approach.
ApproachWhere spend concentratesWhat makes it overrunCost left behind
RehostInfrastructure, packaging, cutoverHidden OS and runtime dependenciesHigh: the architecture moves with you
RefactorFramework layer: config, DI, routing, authCoupling discovered mid-migrationModerate: structure largely preserved
Re-architectDecomposition, service boundaries, data separationBoundaries drawn before the domain is understoodLow, if the boundaries are right
RebuildRequirements recovery and full buildUndocumented logic found lateLowest, 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.

Get a modernization estimate
#legacy software modernization cost #application modernization cost #legacy modernization pricing #legacy system modernization #modernization budget #legacy application modernization
Share

Frequently asked questions

How much does legacy application modernization cost?
There is no honest range, because the number is set by the system you already have rather than by the one you want. Two applications with the same screen count can differ by a factor of several in effort depending on how coupled the code is, how many integrations you do not control, how much data history has to move, and whether any automated tests exist. The way to get a real number is a codebase assessment, which is a days-long exercise, not a months-long one.
Why will no vendor quote a fixed price before seeing the code?
Because in a modernization the unknowns live inside the existing system, not in the requirements. A greenfield build can be scoped from a specification. A modernization can only be scoped from the code, the data, and the integration contracts. Any firm quoting a fixed price before reading those is either padding heavily to cover the risk, or will raise a change request once they find what is actually in there.
Which modernization approach costs least?
Rehosting usually carries the lowest upfront cost and the highest carried cost, because the legacy structure moves with the application. Rebuilding is the inverse. Refactoring and re-architecting sit between them. The cheapest approach over a five-year window is rarely the cheapest approach in the first invoice, which is why approach and budget have to be decided together rather than in sequence.
Does AI-assisted tooling reduce modernization cost?
It reduces the mechanical portion materially, and leaves the rest roughly where it was. On a Xamarin to .NET MAUI migration we ran, AI-assisted conversion moved each application from a conventional estimate of about two months to roughly 15 days, with three applications reaching UAT in under four weeks. What did not compress was engineering review, platform-specific edge cases, and testing. Tooling changes the translation cost, not the verification cost.
What costs are usually missing from a modernization quote?
The ones that sit outside the build: running two systems in parallel during a phased cutover, maintaining the legacy application while the new one is built, reconciling data between them, retraining users, and stabilising the first weeks after go-live. None of these are optional on a live system, and they are routinely left out of comparisons between vendors.
How should we phase a modernization budget?
Fund an assessment first, as its own small commitment, and let it produce the estimate for everything after it. Then release budget per module or per slice rather than for the whole programme, with each release tied to something usable in production. This keeps spend tracking delivered value and gives you a defensible exit point at every stage instead of one at the end.
Mohit Agarwal
Lead Architect, Kansoft

Lead Architect at Kansoft with 15+ years designing scalable, maintainable application and system architectures for enterprise clients. He writes about software architecture, application development, and the engineering decisions that keep systems fast and easy to evolve.

Need help with your next project?

Our engineering experts can help you build something exceptional.

Book a Free Call