Ask three vendors what your IBM i modernization will cost and you will get three confident numbers that disagree by a factor of five. None of them are lying, exactly. They are all estimating the same unknown with different assumptions, because the honest answer to “what will it cost” is another question: what do you actually own?
Most modernization budgets fail at exactly this point. The estimate was priced against the codebase everyone remembered, and the project was executed against the codebase that actually exists. The gap between those two is where overruns live.
The Five Numbers That Drive the Price
Strip away the vendor packaging and IBM i modernization cost comes down to a handful of quantities. The problem is that most shops can only guess at them:
- True program count in scope. Not the number in the change management system. The number that includes the utility programs, the cloned variants, and the jobs that run twice a year.
- Dependency density. A thousand loosely coupled programs are cheaper to move than four hundred that share record formats and copy members. Coupling, not code volume, is what makes work travel in expensive clusters.
- Dead code percentage. Every dead program you identify before the project is work you delete from the invoice. Shops that skip this step pay full price to migrate code nothing calls.
- The ready-versus-review split. Some share of your code can be converted with high confidence, and some needs human judgment. The ratio between them moves the labor line more than any other single factor.
- Target and staging choices. Free-format RPG on the platform, Python off it, or a staged mix. Big-bang cutover or file-by-file. These are legitimate strategy decisions with very different price tags, and they cannot be made intelligently until the first four numbers exist.
Notice what all five have in common: none of them are opinions. They are measurable properties of your codebase. An estimate built without measuring them is a guess with a letterhead.
The Price of Guessing
Underscoped modernizations do not fail politely. The pattern is familiar to anyone who has watched one: the first months go well because the visible code converts as planned. Then the project reaches the programs nobody remembered, the dependencies nobody mapped, and the field change that ripples into forty objects. The timeline doubles, the change requests stack up, and leadership starts using the word “salvage.”
The other cost of guessing gets less attention: overpriced caution. Vendors who cannot see your codebase protect themselves with padding. When the scope is unknown, you pay for the unknown either way, through overruns or through margin.
The Dependency Map Is the Estimator
This is why we tell buyers to spend the small money before the big money. An assessment run with AS/Forward ingests your source through a proprietary ingestion layer that reads six RPG dialects, then produces the exact quantities an estimate needs: the real program inventory, the interconnection graph showing how tightly things couple, the dead code flags, and a readiness status on every program based on how confident the ingestion layer is in what it read.
Those outputs convert directly into budget lines. Ready programs are priced as automated conversion with review. Flagged programs are priced as human work. Dead code is priced at zero because it is not going. And because the migration view scopes impact at the field and object level, the staging plan is built from actual blast radii instead of optimism. We walked through what that first stage produces in our IBM i modernization assessment guide.
The assessment runs air-gapped inside your own infrastructure, so getting to a real number never requires your source code to leave your network.
Rewrite, Convert, or Stay: Price All Three
One more place budgets go wrong: pricing only one strategy. With the map in hand, you can put honest numbers against all three real options. A full conversion to Python or another modern language. A fixed-to-free-format conversion that modernizes the code and keeps the platform. Or a scoped hybrid that retires the dead weight, converts the volatile components, and leaves the stable core exactly where it is. For plenty of shops, the third number is the one leadership approves, and it only exists if the analysis was honest enough to show it.
Get a Number You Can Defend
If you are budgeting a modernization for this year or next, start by measuring the five numbers instead of collecting three more guesses. Golden Path Digital can run AS/Forward against your codebase and turn what you actually own into a cost picture you can put in front of a CFO. Call 501-232-7188 to scope the assessment.