Legacy System Migration Cost: The 2026 Budget Breakdown

What a legacy system migration actually costs in 2026

Across 2,000+ projects at Digital Heroes, migrations are the category where the quoted number and the final number diverge most. Not because anyone is lying. Because the old system contains decisions nobody documented, and you cannot price what you have not read yet.

Here are the honest bands.

Tier 1: Lift and reshape. $65,000 to $110,000. 10 to 16 weeks.

One primary system. One database. Under 5 integration points. Data volume under roughly 5 million rows in the tables that matter. You get: a schema mapping document, an ETL pipeline, the application rebuilt on a current stack, a one-shot cutover over a weekend, and 30 days of hypercare. Team is one tech lead, two engineers, a part-time QA, a part-time PM.

What falls out at this tier, and you must hear this clearly: no parallel run. You cut over once and you live with it. No data cleansing beyond deduplication and format normalization, so the garbage in the old system arrives in the new one, just tidier. No historical archive strategy, meaning you migrate live records and leave the rest on a read-only copy of the old database. No integration rewrites, only reconnections. No compliance evidence package. If your old system has three integrations that nobody can explain, this tier will not survive contact.

Tier 2: Proper migration. $120,000 to $220,000. 4 to 8 months.

This is where most real projects sit. 5 to 15 integration points. Data cleansing with business rules you actually agreed on. A staging environment that mirrors production data volume. Reconciliation reports proving row counts and financial totals match. A phased cutover, module by module or region by region, with rollback at each phase. Team is a tech lead, three to four engineers, a data engineer, dedicated QA, a business analyst who reverse-engineers the old rules, and a PM. Add a designer if the UI is being rebuilt rather than reskinned.

Tier 3: Enterprise, regulated, or heavily undocumented. $220,000 to $400,000+. 8 to 14 months.

Multiple source systems consolidating into one. 15+ integrations. A regulated data set, healthcare, finance or anything with a retention mandate. Parallel run of 4 to 12 weeks where both systems process live traffic and you compare outputs daily. Formal validation, audit trail, sign-off gates. Team expands to include a solutions architect, a compliance lead and often a second QA. A single-system migration can also land here on undocumented integrations alone, which the worked example below shows. Projects above $400,000 usually mean you are also replacing business processes, which is a different project with a migration attached to it.

What actually drives the number

Integration count. $6,000 to $14,000 each. This is the single biggest lever and the one most underestimated. Each system connected to your legacy platform needs discovery, a rewritten connector, a test harness and a cutover plan. A documented REST integration with a live vendor contact lands near $6,000. An undocumented nightly SFTP file drop that a retired employee built in 2011 runs $11,000 to $14,000, because half the work is archaeology. Count your integrations before you take any quote seriously. In our experience most clients undercount by 30 to 40 percent, because scheduled jobs and reporting exports do not feel like integrations until they break.

Data quality and volume. $15,000 to $70,000. Volume is cheap. Quality is expensive. Moving 40 million clean rows is a weekend of compute. Moving 400,000 rows where customer names are stored inconsistently across three tables, dates live in four formats and 12 percent of records have orphaned foreign keys costs $50,000+ in profiling, rule definition, cleansing scripts and reconciliation. Ask for a data profiling exercise before signing anything. It runs $8,000 to $15,000 as a standalone and it is the best money you will spend, because it converts the largest unknown in the project into a number.

Undocumented business logic. Adds 20 to 35 percent to the rebuild effort. The old system encodes rules nobody wrote down. Discount tiers, approval thresholds, edge cases added after a bad quarter in 2016. Extracting these means reading code, interviewing staff and running the old system to observe behaviour. On a $150,000 rebuild that is $30,000 to $52,000 of pure reverse-engineering. If your source code is available and commented, take the low end. If you have binaries and a vendor who went out of business, take the high end and add a contingency.

Cutover strategy. $0 to $45,000. A big-bang weekend cutover costs nothing extra beyond a tense Saturday. A phased cutover adds $18,000 to $28,000 for the sync layer that keeps both systems consistent while they coexist. A full parallel run adds $30,000 to $45,000, because you are running dual writes, daily reconciliation and a comparison harness for weeks. Pick based on what an hour of downtime costs you. If it is under $5,000 an hour, big-bang is rational.

Compliance regime. $20,000 to $60,000. HIPAA, SOC 2 scope, PCI, GDPR with data residency. Concretely: encryption at rest and in transit, audit logging on every data touch, access control matrices, a documented data lineage from old system to new, and a validation package someone signs. Budget $20,000 for GDPR handling on a system already broadly compliant. Budget $60,000 for a first-time HIPAA or PCI scope where the evidence trail is being built from scratch.

Historical data strategy. $8,000 to $35,000. Deciding what comes with you. Migrating everything is often the most expensive answer, because 12 years of records means 12 years of schema drift. The cheap answer is migrating 24 months of live data and keeping the rest queryable on a read-only archive, roughly $8,000. The expensive answer is full historical migration with schema reconciliation across every legacy version, $35,000 and a lot of arguing about what a 2014 status code meant.

A worked example: a distributor moving off a 14 year old ERP (Enterprise Resource Planning)

Regional industrial distributor. 200 staff. Custom ERP built on an old stack, running order management, inventory and invoicing. Nine integrations. 6 million order line items across 11 years. No parallel run needed, downtime tolerable over a holiday weekend, but phased by module. Here is the arithmetic.

• Discovery and data profiling, 3 weeks: $16,000
• Business logic extraction, reading the old codebase and interviewing 11 staff: $34,000
• Schema design and mapping document: $12,000
• ETL pipeline build with cleansing rules, 6M rows, 340 mapping rules: $38,000
• Application rebuild, order management module: $42,000
• Application rebuild, inventory module: $31,000
• Application rebuild, invoicing plus tax logic: $27,000
• Nine integrations, four documented at $6,500, five undocumented at $11,000: $81,000
• Phased cutover, sync layer, three phases: $22,000
• Reconciliation reports and QA across the whole set: $24,000
• Historical archive, years 1 to 9 on read-only, years 10 to 11 migrated: $11,000
• Training, documentation, 45 days hypercare: $19,000

Total: $357,000 over 11 months.

Two things worth sitting with. First, this landed in Tier 3 on nine integrations, not fifteen, and with no compliance regime at all. Five of the nine were undocumented, and the business logic extraction ran $34,000 against a $100,000 rebuild, which is the 34 percent top end of that driver. Undocumented is what moves a migration up a tier, not integration count on its own.

Second, look at the integration line. $81,000, or 23 percent of the project, for nine connectors. The rebuild of the entire order management module cost $42,000, roughly half what the integrations cost, which is the reverse of a greenfield build where features dominate.

The lever that would have moved this most: three of those undocumented integrations turned out to be feeding a reporting tool that two people used. Killing them before the project started would have saved $33,000. Audit what your integrations actually serve before you pay anyone to rebuild them.

The costs nobody puts in the quote

Running both systems during the transition. The old system does not switch off when the new one turns on. Budget for 3 to 6 months of dual licensing and dual hosting. On a legacy ERP with per-seat licensing this can be $4,000 to $15,000 a month. It is the most reliably forgotten line in a migration budget.

Hosting. A migrated mid-market system typically runs $600 to $2,500 a month on a managed cloud setup. Past roughly 20 TB of hot data, expect the top of that range or above. Migrations often increase hosting cost, because the old system ran on a paid-off box in a closet and the new one has staging, backups and monitoring.

Third-party services. The pieces the old system did badly and the new one buys properly. Search, email delivery, error monitoring, document generation, identity. Realistically $300 to $1,500 a month combined for a mid-market system.

Maintenance at 15 to 20 percent of build cost per year. On the $357,000 example, that is $54,000 to $71,000 annually. This buys dependency updates, security patches, integration breakage repair when a vendor changes an API, and someone who answers when it breaks at 2am. Migrations skew toward 20 percent in year one, because the integrations you rebuilt are the ones most likely to move.

Year one change requests. Plan for 25 to 40 percent of build cost. Higher than a greenfield build, and here is why. When staff finally use the new system, they discover the old one did things they never mentioned in discovery, because those things were invisible until they were gone. On a $357,000 build, that is $90,000 to $140,000 of year one changes. If this number shocks you, halve your build scope, not your change budget.

How to not get burned on price

A cheap migration quote is cheap because it priced the rebuild and never opened the old system. It assumed your integrations are documented. It assumed your data is clean. Those assumptions become change orders in month three, at a moment when you cannot walk away because your data is half moved. We have inherited migrations where the client paid $70,000 for a stalled effort and then $180,000 to finish properly. The second vendor was not more expensive. The first one was just wrong earlier.

The tell is a quote that skips discovery. Any migration quote produced without someone reading your schema and counting your integrations is a guess, formatted. Insist on a paid discovery phase, $10,000 to $20,000, delivered as a fixed price with a written output: schema map, integration inventory, data profile, risk register. Then get the build quoted against that document. If the vendor will not do this, they are planning to discover on your dime later.

Change requests should be priced at a published rate, agreed before you sign. A reasonable structure is a blended day rate, with anything under half a day absorbed into the sprint at no charge and anything larger scoped and approved in writing. If a vendor cannot tell you their change rate up front, that is not a pricing gap, it is a negotiating position they are saving for when you have no leverage.

Contract terms that protect the number. Fixed scope with a written change process, not fixed price with vague scope, which is the same thing as a variable price. IP transfers to you on payment, per milestone, not at the end, so a dispute in month seven does not leave you with nothing. Source code lives in your repository from day one, with your team holding admin. Data stays in your cloud account. A migration where the vendor holds the code and the infrastructure is a hostage situation with an invoice schedule.

One more: get the reconciliation criteria in the contract. "Migration complete" should mean specific row counts match, specific financial totals reconcile to the cent, and a named person on your side signs. Without that, "done" is whatever the vendor says it is.

How to brief a vendor so the quotes come back comparable

Three vendors reading three different projects into the same email will produce three different numbers, and comparing them teaches you nothing.

Send every vendor the same document containing: your integration inventory, listed by name, with documented or undocumented marked against each. Row counts on your top ten tables. Your source code access situation, source available, source lost, or vendor binary. Your downtime tolerance in hours, and what an hour costs you. Your compliance regime, named. Your decision on historical data, all of it or a stated cutoff. Your cutover preference, big-bang or phased or parallel, and if you do not know, say so and ask them to price two options.

Then ask for the quote broken into the same line items every time: discovery, logic extraction, data pipeline, rebuild per module, integrations priced individually, cutover, QA and reconciliation, training and hypercare. When all three quotes have those lines, differences become readable. You will see one vendor priced integrations at $4,000 and another at $11,000, and that single row tells you which one has done this before.

Ask one question at the end of every vendor call: "What did the last migration you delivered cost at the start, and what did it cost at the end?" Anyone who says the numbers matched exactly has either done one migration or is not answering honestly. The useful answer is a real overrun with a real reason.

When you are ready to turn this into a specification, Digital Heroes builds and runs its own products, so the people choosing your architecture live with those decisions on their own revenue. The document is yours whichever way you go.