Budgeting a Modernization Project
Engineering

Budgeting a Modernization Project

What to count before estimating, which costs teams forget, how to price risk, and how a staged budget is re-forecast after the pilot, with a worked example in budget units.

Short answer

Budget a modernization project in stages. Count the real scope first (interfaces, data stores, scheduled jobs, reports and users, not just screens), estimate each cost bucket as a range, including data migration, parallel running and decommissioning, and fund discovery and a pilot slice before committing to the rest. Hold contingency against named risks and re-estimate with actual spend at every gate.

How do you budget a modernization project?

Count the real scope before estimating, budget every cost bucket separately as a range, fund the work in stages that are released only when the previous stage has produced evidence, hold contingency against named risks, and re-estimate with actual spend after each stage. The riskiest part of most modernization budgets is not a wrong unit rate; it is a single number agreed before anyone has mapped the interfaces, looked at the data or found the month-end job that nobody mentioned.

Early estimates for software work have a long record of being too low. HM Treasury's Green Book guidance on optimism bias starts from "a demonstrated, systematic, tendency for project appraisers to be overly optimistic" and asks appraisers to adjust cost and duration estimates explicitly. For its equipment and development category, which covers ICT development projects, the recommended upper-bound adjustments are 200% for capital cost and 54% for duration, with lower bounds of 10% for each. These figures come from a 2002 review of large UK public projects and describe the average bias found at the outline business case stage, so treat them as a warning rather than a forecast for your project. The guidance also expects the adjustment to come down as risks are identified and managed before commitment, and producing that evidence is exactly what a staged budget is for.

What should you count before estimating?

Count the things that generate work, not the screens that are visible. A small-looking application can hide a large integration and data migration burden. For each system in scope, list:

  • Modules and user journeys, with the roles that use them and how often.
  • Interfaces: every connection to another system, with its direction, protocol, owner and volume.
  • Data stores: databases, tables that matter, data volume, retention rules and a sample of data quality.
  • Scheduled jobs, reports and exports, including the ones that run only at month-end or year-end.
  • Environments, licences and hosting that will have to run in parallel for a while.
  • Undocumented manual steps and knowledge held by a single person.

Then choose a treatment per component, because the strategy drives the cost. AWS's migration strategy guidance lists seven: retire, retain, rehost, relocate, repurchase, replatform, and refactor or re-architect. It describes refactoring as the most complex and costly of them, and for large migrations recommends moving applications first and modernizing afterwards wherever possible. It also names cheap scope reductions: one of its signals for retirement is an application with no inbound connection in the last 90 days. Every report or module you can retire is scope you never have to estimate.

Which cost buckets are usually missing?

Build effort is rarely forgotten. These buckets often are:

BucketWhat it includesWhy it gets missed
DiscoveryInterviews, code and data analysis, dependency mappingTreated as part of the sales conversation
IntegrationMapping, authentication, error handling and tests for each interfaceEstimated as a percentage of build instead of counted
Data migrationCleansing, mapping, trial loads, reconciliationAssumed to be "a script"
TestingRegression of existing behaviour, performance, security reviewAssumed to be covered by development
Transitional architectureRouting façade, adapters and sync jobs that will later be removedInvisible in the target architecture diagram
Parallel runningDouble hosting and licences, output reconciliation, extra supportUsually lasts longer than planned
PeopleBusiness staff time, training, a temporary productivity dipNot on the project's invoice
DecommissioningArchiving, licence termination, shutting servers, deleting codePostponed until "later"

Transitional architecture deserves a line of its own. Microsoft's Strangler Fig pattern advises balancing the risk reduction of a temporary routing layer against its temporary infrastructure cost, and Martin Fowler's note on the same pattern argues that the lower risk and earlier value of gradual replacement outweigh the cost of that throwaway code. Both positions assume the cost is planned, not discovered.

Why fund in stages instead of approving one budget?

Because the estimate improves with every stage, and the funding decision should improve with it. The US Government Accountability Office's Cost Estimating and Assessment Guide describes a reliable estimate as comprehensive, well-documented, accurate and credible, and its process includes sensitivity and risk analysis and updating the estimate as the programme progresses. Staged funding turns "update the estimate" into a decision point with evidence. Incremental delivery also brings value earlier: Microsoft notes that the Strangler Fig approach lets you make high-return replacements before low-return ones.

GateEvidence requiredDecision
After discoveryInventory, dependency map, data quality sample, range per sliceFund the pilot, reshape the scope or stop
After the pilot sliceActual cost against estimate, defects, performance, user acceptanceRecalibrate the ranges, fund the next slices
Before each cutoverMigration rehearsal, reconciliation, tested rollbackGo or no-go
After parallel runningOutput comparison, support load, owner acceptanceRelease the decommissioning budget
After decommissioningOld costs actually switched offClose and review benefits against the business case

How should risk and contingency be priced?

Tie contingency to named risks instead of adding a flat percentage. List each risk with a likelihood, a cost impact if it happens, an owner and a trigger, and hold contingency close to the sum of likelihood times impact. Release it only when a named risk materialises, and record which one. An illustrative register, in budget units:

RiskLikelihoodImpactExpected cost
Undocumented interface found after discovery50%63.0
Data quality worse than the sample40%104.0
Key legacy expert unavailable for weeks20%81.6
Cutover needs an extra rehearsal weekend30%30.9
Contingency to holdabout 10

Unknown interfaces belong in this register or in a discovery task with an owner, not in a vague percentage that nobody can explain at the next gate.

What should the business case compare against?

Compare the modernization cost with what the current system costs to keep running, measured over the same period and in the same unit. A budget without that baseline cannot tell you when to stop. Collect at least:

  • hosting, licences and support contracts, including any premium paid for versions that are out of standard support;
  • internal time spent on maintenance, manual workarounds and month-end fixes;
  • incidents and outages, with their business effect;
  • changes the business wanted but could not make, and how long typical changes take today.

Expect costs to rise before they fall. During parallel running you pay for both systems, and most savings appear only after decommissioning. Setting a ceiling for the total programme cost from this baseline gives every gate a clear test: if the re-forecast crosses the ceiling, the scope changes or the work stops.

Hypothetical example: an incremental budget model

Suppose a distributor wants to modernize an order system with six external interfaces. The unit is a team-week; it could equally be a fixed amount, as long as it stays the same across stages. The numbers are illustrative, not a benchmark.

StageLowLikelyHigh
Discovery101520
Pilot slice: read-only customer lookup, with tests and rollback202535
Integration: six interfaces at two to four units each121824
Data migration and reconciliation81220
Parallel running and training61014
Decommissioning358
Total5985121

The sponsor sees a range of 59 to 121 units, a likely figure of 85 and a risk contingency of about 10, but approves only discovery at first. If you applied the Green Book's upper bound to the likely figure at this point, the planning number would be 255 units; that is the size of the uncertainty a single up-front approval would be ignoring.

Discovery confirms the six interfaces and finds a seventh. The pilot then costs 32 units instead of the likely 25, mainly because authentication with the old system took longer than expected. The team does not scale every remaining line by the same overrun. It raises the integration line, where the cause lies, from 18 to 24 to cover the seventh interface and the authentication lesson, and leaves the others unchanged. The new likely total is 98 units. The business case set a ceiling of 110, so the next slices are funded; had the forecast crossed the ceiling, the gate would have reshaped the scope, for example by retiring the reporting module instead of migrating it.

What should be reported at each gate?

  • Actual against estimate for each bucket, not only the total.
  • Contingency used, with the risk that triggered it.
  • Changes in the inventory: new interfaces, retired modules, data issues found.
  • Legacy costs actually switched off so far.
  • Defects and incidents after each cutover, and user acceptance by role.

Common mistakes

  • Estimating from the number of screens.
  • Hiding unknown interfaces in one contingency percentage.
  • Ending the budget at go-live, with no parallel running or decommissioning.
  • Leaving out the business staff's time.
  • Not re-estimating after the pilot, and continuing because money has already been spent.
  • Refactoring everything when retiring or rehosting part of it would do.

Where should you start?

Fund discovery on its own, count the inventory, and only then put ranges on the slices. For choosing between retaining, refactoring and rebuilding each component, see our application modernization decision guide. Staged modernization of existing systems is part of our custom software development service, and the first discovery call is free.

Key takeaways

  • Count interfaces, data stores, scheduled jobs, reports and users before estimating, not screens.
  • Choose a strategy per component; retiring or rehosting parts is often cheaper than refactoring everything.
  • Budget discovery, integration, data migration, transitional architecture, parallel running, people and decommissioning as separate lines.
  • Estimate in ranges and fund in stages, releasing money at gates that require evidence.
  • Hold contingency against named risks and record which risk used it.
  • After the pilot, re-forecast the lines the overrun came from and check the business case ceiling.

Frequently asked questions

How much contingency should a modernization project have?

There is no universal percentage. List the specific risks, estimate each one's likelihood and cost impact, and hold contingency close to the sum of the expected costs. Release it only when a named risk materialises, and revisit the register at every stage gate.

Why are early software estimates so often too low?

Early estimates are made before interfaces, data quality and hidden jobs are known, and appraisers tend to be optimistic. HM Treasury's Green Book guidance treats this as a systematic bias and recommends explicit upward adjustments, which should shrink as risks are identified and managed.

Is it cheaper to rewrite or to modernize in stages?

A full rewrite can look cheaper on paper, but it delays value and concentrates risk in one cutover. Staged modernization adds the cost of temporary routing and adapters, yet delivers usable parts earlier and lets you stop or reshape the work when the evidence changes. Small systems that can be replaced quickly are the exception.

Which costs are most often left out of modernization budgets?

Discovery, integration counted interface by interface, data migration and reconciliation, testing of existing behaviour, transitional architecture, parallel running, business staff time and training, and decommissioning. Each should be a separate line with its own range.

Should a modernization project have a fixed budget?

Fix the budget for the next stage, not for the whole programme. Approve discovery first, then a pilot slice, and release later stages at gates that compare actual spend with the estimate. This keeps the overall envelope visible while basing each commitment on evidence.

All articles