The True Cost of Custom Software: TCO for Small Businesses, Explained

When someone hands you a quote for custom software, the number on it feels like the price. It isn't. It's the price of the build — the first lap of a race that runs for years. The real figure, the one that actually leaves your bank account over the life of the thing, is usually somewhere between two and four times that opening number. Nobody tells you this up front, because saying it out loud makes for an awkward sales call. So let's have the awkward conversation instead.

I've watched a lot of small businesses commission their first piece of custom software. The ones who end up happy almost never had the cheapest quote or the flashiest demo. They had a clear-eyed picture of the total cost of ownership — TCO, if you like acronyms — before they signed anything. They knew that a system isn't a thing you buy, it's a thing you keep. Like a delivery van: the purchase price is the easy part, and then there's fuel, servicing, insurance, the tyre that goes at the worst possible moment.

This guide is the honest version of that picture. No scaremongering, no upselling — just where the money actually goes over five years, which line items get quietly left off the quote, and how to budget so the bill never ambushes you. If you're weighing up a custom build, read this before you read any proposal.

The build price is the tip of the iceberg

Here's the mental model that fixes everything: the development quote covers getting your software built and live. That's it. Everything that happens after launch — and software lives most of its life after launch — is a separate, ongoing cost that the build number doesn't touch.

A rough rule of thumb that's held up across dozens of projects: over a five-year life, the initial build is often only 30 to 40 percent of what you'll actually spend. The rest is hosting, maintenance, support, security, and the changes you'll inevitably want once real people start using the thing. None of that is waste. It's just the part nobody puts on the headline slide.

This isn't a reason to avoid custom software. For the right problem it pays back many times over. It's a reason to walk in with both eyes open, so the five-year number doesn't blindside you in year two — which is, almost always, when the surprises land.

Where the money actually goes

Let's break the iceberg into its real pieces. Roughly, the total cost of owning a custom system splits into six buckets. Some are one-off, some recur forever, and the recurring ones are the ones people underestimate.

1. The build itself

Design, development, testing, and getting it into production. This is the number on the quote. It's the most visible cost and, paradoxically, the one you can predict best — because it's the part a good partner has scoped in detail before quoting. The danger here isn't the price, it's scope creep: every "can we also just add…" during the build pushes this number up. More on taming that later.

2. Hosting and infrastructure

Your software has to run somewhere. Servers, databases, file storage, backups, the domain, security certificates. For a typical small-business tool this is genuinely modest — often a few tens of euros a month, scaling with how many people use it. It's not where the big money is, but it's a recurring line that never stops, and it grows as you do.

3. Maintenance and updates

This is the big one people forget. Software sits on top of other software — operating systems, frameworks, libraries — and all of that keeps moving underneath it. Security patches get released. A dependency gets deprecated. A payment provider changes its API. If nobody keeps up, your perfectly good system slowly rots until one day it breaks for reasons that have nothing to do with you. Budget for maintenance as a yearly figure, often 15 to 20 percent of the build cost per year, and you'll sleep better.

4. Support and bug fixes

No software ships perfect. Real users do things no test anticipated. Early on you'll find bugs; forever after you'll have the occasional "it's behaving strangely" moment that needs a human who understands the code. Support can be a retainer, a pay-as-you-go arrangement, or bundled with maintenance — but it should never be an afterthought, because the day you need it is rarely a calm one.

5. Changes and new features

This is the cost that surprises people in a good way, then surprises their budget in a bad one. The moment your software works, you'll see ten ways to make it better. Your business will change. A new regulation lands. You win a client who needs one extra field. Custom software's whole advantage is that it can evolve with you — but evolution is billable. Treat ongoing improvement as a planned line, not an emergency.

6. Your own time

The invisible cost. Someone on your side has to give feedback, test, train the team, and answer the developer's questions. It's not a line on any invoice, but it's real, and projects where the owner pretends it's zero are the projects that stall. Budget a few hours a week during the build, less after.

A five-year example, in plain numbers

Numbers make this concrete, so here's an illustrative one. These figures are deliberately round and meant to show proportions, not to quote your project — every build is different. Imagine a custom internal tool that replaces a tangle of spreadsheets for a 20-person company.

Look at the bottom line. The €40,000 build — the only number most people focus on — is around 36 percent of the five-year spend. The other 64 percent is the cost of keeping a living system alive and useful. If you'd budgeted only for the build, you'd be roughly €70,000 short over five years, and you'd feel every euro of it as an unpleasant surprise.

The hidden costs nobody quotes you

Beyond the six buckets, there's a set of costs that don't appear on any proposal because they're not really the developer's to quote. They're yours. Ignoring them is the single most common way a sensible budget turns into a sore subject.

• Data migration — getting your existing data out of old tools and into the new one cleanly is fiddly, manual and almost always underestimated.
• Training and adoption — software only saves money once people actually use it; budget for the awkward first weeks.
• Integrations that drift — every system you connect to can change its rules, and when it does, your connection needs fixing.
• Downtime — the cost of the tool being unavailable during a busy hour, which is why backups and monitoring aren't optional luxuries.
• Key-person risk — if one developer holds all the knowledge, replacing them mid-life is expensive; insist on documentation and code you own.
• The 'we outgrew it' moment — if the build cut corners to hit a price, you may pay again sooner than you'd like.

None of these are reasons to panic. They're reasons to ask better questions. A partner who brings them up unprompted is one you can probably trust with the rest — because it means they're thinking about your five-year cost, not just their invoice this quarter.

How this compares to off-the-shelf

It's tempting to read all this and conclude that off-the-shelf software is obviously cheaper. Sometimes it is — and when it genuinely fits, you should buy it. But off-the-shelf has its own TCO, and it's not always the bargain it looks like on the pricing page.

A subscription tool has a low entry cost and no build, which is wonderful. But you pay per user, per month, forever, and that line only goes up — with your headcount, with their price rises, with the "pro" tier you eventually need. You also inherit costs that don't show as money: the workarounds for the 10 percent it doesn't quite do, the manual steps between tools that won't integrate, the data you can't easily get back out if you leave. Custom software front-loads the cost and gives you control; off-the-shelf spreads the cost and rents you a fit that's never exact.

How to keep the total cost under control

Understanding TCO isn't about bracing for a bigger bill — it's about steering it. The owners who keep lifetime cost sane all do roughly the same handful of things, and none of them require a technical background.

1. 1
   Ask for the five-year picture, not just the build

   Make every partner you talk to lay out hosting, maintenance, support and likely changes. The conversation alone tells you who's being straight with you.
2. 2
   Start smaller than you think you should

   Build the core that delivers value, get it live, learn from real use. A lean first version costs less to build and far less to change than a bloated one you guessed at.
3. 3
   Own your code and your data

   Insist that the code, the accounts and the data are yours and documented. This is your single biggest protection against being locked in and overcharged later.
4. 4
   Budget maintenance from day one

   Set aside a yearly maintenance figure before you launch, not after something breaks. Planned maintenance is cheap; emergency rescue is not.
5. 5
   Decide changes deliberately

   Keep a simple list of wanted improvements and tackle them in planned batches, not as a constant trickle of 'just one more thing'. Batching is cheaper and keeps the system coherent.

Do these five things and the scary-looking TCO becomes a predictable operating cost — the kind you can put in a spreadsheet at the start of the year and not think about again. That predictability is worth more than shaving a few percent off the build price, and it's what separates a project you're glad you did from one you quietly resent.

So is custom software worth it?

After all the cautionary arithmetic, here's the other side. For the right problem, custom software is one of the best investments a small business can make. When a process is genuinely central to how you operate — the thing that, done well, makes you money or saves your sanity — owning software that fits it exactly beats renting an approximation that almost fits.

The trick is matching the tool to the stakes. Don't commission a custom build for something a €30-a-month app handles fine. Do consider it when the off-the-shelf options force you to change how you work, when you're paying a fortune in subscriptions and manual workarounds anyway, or when the process is your actual competitive edge. In those cases the five-year TCO isn't a cost to fear — it's the price of a real asset you control.

Common questions