The hidden cost of keeping legacy software alive

Every quote to replace a legacy application arrives with a number attached, and the number is large. The alternative, doing nothing for another year, arrives with no number at all. That asymmetry is why so many businesses keep systems long past the point where keeping them makes sense: one option has a price, and the other only has consequences.

So let's put a number on doing nothing.

1. The workaround tax

Start with the most visible cost, because it's also the easiest to measure. Every workaround your team performs because the software can't do something is a recurring labor expense: the export into a spreadsheet, the manual re-key into the other system, the report someone assembles by hand every Monday.

Pick the three biggest ones, ask the people who do them how long they take, and multiply by their loaded hourly cost and by 52. Most businesses are surprised by this figure, and it's usually the smallest cost on this list.

2. The security exposure

Unsupported software doesn't get security patches. That is the entire definition of unsupported. In practice it means every vulnerability disclosed after the end-of-life date stays open in your environment permanently, and every mitigation available to you is a workaround: network segmentation, restricted access, compensating controls somebody has to maintain.

This cost is real but probabilistic, so it's easy to wave away. Two things make it concrete. Cyber insurance renewals increasingly ask directly whether you run unsupported software, and the answer affects both premium and coverage. And if you have any compliance obligation at all, unsupported systems tend to be the finding that reappears in every audit until you deal with it.

3. The integration tax

Old systems are expensive to connect to. They predate the APIs everything else expects, so every integration becomes a custom job: a file drop, a database read nobody is comfortable with, a scheduled script that runs at 2am and fails silently.

The cost isn't just building those bridges. It's that each one raises the price of every future change, because now there are five brittle connections that all have to keep working. This is the cost that compounds, and it's why modernization gets harder the longer you wait.

4. Key-person risk

There is usually one person who understands the old system. Sometimes they wrote it. Sometimes they just outlasted everyone who did. Either way, your ability to operate depends on someone whose knowledge isn't written down anywhere.

You can't put a clean dollar figure on this, but you can ask a useful question: if that person gave notice tomorrow, what would the next ninety days look like, and what would you spend getting through them? That's the cost you're carrying.

5. The things you aren't doing

The last cost is hardest to see because it never shows up as an expense. It's the customer portal you can't offer, the automation you can't build, the reporting leadership keeps asking for, all blocked because the system at the center of your operation can't support any of it.

Competitors without that constraint are shipping those things. That isn't a software cost. It's a market position cost, and it appears on no invoice.

Adding it up

Take the workaround hours, the insurance and audit friction, the maintenance and integration work, and a fair estimate of the key-person exposure. Compare that annual figure against the cost of replacing the system, spread across the years the replacement will actually last.

For a genuinely small tool, the math often favors keeping it, and we'll tell you so. For a system the business depends on, the do-nothing cost is usually bigger than anyone expected, and it repeats every year, while the replacement is paid for once.

When keeping it is the right answer

To be fair to the old system: sometimes leaving it alone is correct. If it's stable, isolated from the internet, not blocking anything you want to do, and understood by more than one person, it isn't really costing you much. Stability is worth something, and replacing working software for its own sake is a good way to waste money.

The test isn't how old the software is. It's whether it's stopping you from doing things, and how much you pay every year to work around it.