Software Maintenance Cost: What to Budget Yearly
Plan on 15-25% of the build cost a year to maintain custom software. What that covers, what pushes it up, and how to buy support without overpaying.
Plan on spending 15 to 25 percent of the original build cost every year to keep custom software running, secure and useful, before hosting. That is the planning figure we use at RNDSOL, and it covers dependency and security updates, bug fixes, monitoring, and a modest stream of small improvements. A system that cost $80,000 to build therefore needs roughly $12,000 to $20,000 a year of engineering, which at $1,400 to $2,200 per engineer-week comes to about 6 to 14 engineer-weeks spread across twelve months. The low end fits a stable internal tool with few integrations. The high end fits a customer-facing product with mobile apps, payments and several third-party APIs. The sections below explain where that money goes, what pushes a system toward either end of the band, why cutting it is the most expensive saving a business can make, and how to turn the figure into a support arrangement you can manage and measure.
What Maintenance Covers
- Security patches: frameworks, libraries and base images publish fixes every month, and some cannot wait for the next planned release
- Dependency upgrades: staying on supported versions of the runtime, framework and database, so a patch is a small change instead of a migration
- Mobile OS and store changes: the annual iOS and Android releases, new store policies and SDK deadlines that block updates until they are met
- Third-party changes: payment gateways, SMS providers, maps and identity services retire API versions on their own schedule
- Bug fixes: defects users find in production, triaged by severity with agreed response times
- Monitoring and incident response: uptime checks, error tracking, log review, and a person who answers when an alert fires
- Small improvements: a report column, a new user role, a changed workflow step, the requests that never justify a project of their own
- Hosting and licenses: billed separately from engineering, and worth reviewing on their own schedule
How Much Should You Budget for Maintenance Each Year?
Start with the build cost and pick a point in the 15 to 25 percent band based on how exposed the system is to change. Move toward the low end if the software is used internally by a known group, runs on one platform, has one or two integrations, and the business process behind it rarely changes. Move toward the high end if it faces customers, ships iOS and Android apps, takes payments, depends on several external APIs, or sits in a regulated sector such as fintech or healthcare, where an audit can turn into a list of required changes. Then adjust for age and condition. A system with automated tests, a working CI pipeline and current dependencies is cheap to maintain, because each change is small and easy to verify. A system that has gone two or three years without upgrades costs more in its first year of maintenance than in any later one, because the backlog of deferred upgrades has to be paid down before routine patching becomes routine. If you inherited a system like that, budget a one-time catch-up of several engineer-weeks before the annual figure applies. If you do not know the original build cost, our cost calculator gives a range to start from.
Why Skipping Maintenance Costs More Later
Maintenance is the easiest line to cut in a tight year, because nothing breaks in the month you stop paying for it. The cost arrives later and larger. Framework versions fall out of support, so a security fix that would have been a one-line upgrade now requires moving across two major versions first. A mobile app that missed a store's SDK deadline cannot ship any update, including the urgent one. A payment provider retires an API version and checkout stops working on a weekend. Each of these turns a scheduled task into an emergency, done at emergency speed and with less testing than it deserves, often by an engineer who has to relearn the system first. Past a certain point, deferred maintenance stops being maintenance and becomes a modernization project, which our post on legacy system modernization cost prices in detail. The cheapest maintenance is the steady kind: small upgrades every month, each tested and released on its own, by people who still remember how the system fits together.
Retainer, Hourly or In-House
There are three common ways to buy maintenance. A monthly retainer buys a set amount of engineering time with agreed response times for incidents, and suits most systems the business depends on. Hourly support with no commitment looks cheaper but has no guaranteed availability, so the engineer who knows your system may be deep in another project when production breaks. An in-house engineer makes sense once the maintenance load plus planned improvements fills most of a full-time role, which for many products happens a year or two after launch. Our retainers cover agreed response times, dependency and security patches, and a monthly report on uptime, errors and what we fixed, and they run month to month, so a client never pays for support it has outgrown. Some clients take a full handover and run the system themselves instead; a retainer is a choice, not a condition of the build. Whoever you buy from, ask three things: how many hours the retainer includes, what counts as a fix versus a change, and what happens to hours you do not use.
How to Keep the Number Down
- Fund automated tests during the build; they make every later upgrade cheaper to verify
- Upgrade dependencies on a schedule, monthly or quarterly, instead of when a vulnerability forces it
- Keep each integration behind a thin adapter, so a provider's API change touches one module
- Write a runbook covering deployment, backups, restores and common incidents, and test the restore
- Track maintenance hours by category, so next year's budget comes from what the system needed rather than a guess
- Retire features nobody uses; every screen carries a share of every upgrade
- Review hosting each quarter; our cloud cost optimization checklist lists where the usual waste sits
Put Maintenance in the First Business Case
The right time to agree a maintenance budget is before the build starts, when it can be weighed against the value the software is meant to return. A three-year cost of ownership that shows the build plus three years of maintenance and hosting gives a truer picture than the build quote alone, and it often changes design decisions for the better: fewer integrations in the first release, one cross-platform mobile codebase instead of two native apps, a managed database instead of one your team has to patch. When you collect quotes, ask each vendor for its expected maintenance band next to the build estimate, and for the assumptions behind it. A vendor that cannot say what the system will cost to run after launch has not thought about running it.
Have a project that needs this kind of thinking applied to it?