Software maintenance after delivery is everything that keeps your system running, secure and useful once it is live: fixing defects, applying security and component updates, adapting to changes in servers, browsers and the systems it connects to, and making the small improvements your team asks for. A good support contract states exactly what falls under each item, how fast each level of issue gets a response, and what is billed separately. The cost is not one fixed number: it depends on the size of the system, how many integrations it has and the response level you ask for.
In this guide we explain the four types of maintenance, why every system needs maintenance even if you change nothing in it, what a support contract usually covers and what it leaves out, and how maintenance is priced and what drives the cost up or down. We finish with seven questions to ask before you sign.
What does software maintenance after delivery actually mean?
The international standard ISO/IEC/IEEE 14764 on software maintenance defines the different types of maintenance and sets out guidance for managing them. Four types are the best known, and each raises a different question in your contract:
| Type | What it means | A practical example |
|---|---|---|
| Corrective | Fixing a defect found after launch | A report that calculates the wrong total when an invoice has a discount |
| Adaptive | Changing the system so it works in an environment that changed around it | Upgrading the server runtime, or updating the integration after a payment gateway changed its API |
| Perfective | Improving performance or usability, or adding a small change | Speeding up a slow page, or adding a filter the sales team asked for |
| Preventive | Dealing with a likely problem before it appears | Updating a library with a known vulnerability, or cleaning up code that will be hard to extend later |
Note a point many people miss: the standard itself separates maintenance from day-to-day operation, such as backups and server administration. So do not assume that the word "maintenance" in your contract covers hosting, backups and server monitoring. Ask for each of them to be named explicitly, together with who is responsible for it.
Why does every system need maintenance even if you change nothing?
Because the world around the system changes even when the code stays the same. Modern systems rely on runtimes, libraries and external services, and each has a limited life cycle. For example, the official Node.js releases page explains that a long-term support release typically receives critical bug fixes for a total of 30 months, and recommends that production applications run only on releases that are still supported. In other words, a system built three years ago and never updated may be running today on a foundation that no longer receives any fixes.
Then there is what changes outside your control: payment gateways, shipping companies and government invoicing systems update their APIs, browsers and phone operating systems change their behaviour, and new vulnerabilities keep being discovered in components your system uses. Our article on the October 2026 breaches and what to do now shows recent examples of what happens when components are left unattended.
What does a software maintenance contract usually cover?
Contracts differ in detail, but a clear contract covers these items and states the limits of each:
- Fixing defects. Any error in how the system behaves against what was agreed, with a severity level and a response time for each level.
- Security and component updates. Updating the runtime, libraries and frameworks before they fall out of support, and testing the system after every update.
- Monitoring and alerts. Tracking downtime, recurring errors and slow performance, with an immediate alert to the team in charge.
- Backups and restore tests. Having a backup is not enough on its own: it has to be restored regularly to prove it actually works.
- A monthly allowance for small improvements. A set number of hours for small changes such as a new field or an adjusted report, with a clear agreement on whether unused hours roll over.
- A regular report. What was fixed, what was updated, and which risks need a decision from you.
- Documentation updates. Every significant change to the system is reflected in the technical documentation, so the knowledge does not live only in one developer's head.
On the other side, some items are usually outside a maintenance contract, and it is better to write them down so they do not turn into disputes: large new features or extra modules, redesigns, the cost of servers, licences and third-party services, and defects caused by changes another party made to the code without coordination.
How are service levels and response times set?
The heart of any support contract is the service level agreement (SLA): a table that classifies issues by their impact and sets a response time and a target resolution time for each level. There is no number that is right for everyone. A store that sells around the clock needs a different response from an internal system used only during working hours. Here is an example of how the levels can be classified:
| Level | Example | What you agree on |
|---|---|---|
| Critical | The system is down, or sales or payments cannot go through | An immediate response even outside working hours, and a workaround that restores service before the full fix |
| High | A core function is broken but has a temporary manual workaround | A same-day response and a clear plan to fix it |
| Medium | An error that annoys users without stopping work | Included in the next agreed fix cycle |
| Low | A cosmetic issue or a small improvement request | Scheduled within the monthly improvement allowance |
More important than the numbers is agreeing on three things: who may open a ticket and through which channel, when the response clock starts, and what happens if the other side misses the agreed time. We gathered the clauses that protect you on these points and others in our article on software development contract clauses to check before you sign.
How much does software maintenance cost, and what sets the price?
We do not quote fixed figures here, because the cost of maintenance is set by the system itself, not by a market average. But it helps to know the common pricing models, because the model you choose affects the cost as much as the price does:
| Pricing model | How it works | Suits | Watch out for |
|---|---|---|---|
| Fixed monthly plan | A monthly fee that covers a defined scope of fixes, updates and monitoring | Critical systems that need a guaranteed response | The limits of the scope and what is billed outside it |
| Block of hours | A monthly or quarterly number of hours used up as requests come in | Stable systems with occasional improvements | Whether unused hours roll over or are lost |
| On demand | You pay per request or per hour when needed | Small systems with light use | No guaranteed priority and no binding response time |
| Annual percentage of the build cost | A yearly fee calculated as a percentage of the original project value | Contracts that start right at delivery | A percentage with no written scope that defines what it covers |
Beyond the model, these are the factors that really push the cost up or down:
- The size of the system and its number of modules. A system with only a sales module is different from one that combines sales, inventory, accounting and a client portal.
- The number of external integrations. Every payment gateway, shipping company or government system connected to yours is a point that can change and needs watching.
- Response level and hours of cover. Round-the-clock support costs more than support during working hours only.
- The quality of what you received. Reviewed code, automated tests and good documentation cut the time of every fix, and their absence multiplies it.
- Who handles hosting. If the servers and their monitoring are in the contract, its value goes up. If they stay with you, the responsibility moves to your team.
To include maintenance in the total cost of your system over three years with a worked example, see our guide to custom ERP and CRM development cost.
Which questions should you ask before signing a support contract?
- Which systems and environments does the contract cover exactly? The website, the dashboard, the app and the servers, or only some of them?
- How are issues classified, and what is the response time for each level? When does the clock start, and through which channel is a ticket opened?
- What is billed outside the contract? At what hourly rate, or by what estimating method?
- Who holds access to the servers, databases and domain? And do you keep a copy of every credential even if the contract ends?
- How are updates tested before release? Is there a staging environment separate from the live system?
- When was the last restore from backup tested? And how long did it take to get the system running again?
- What happens when the contract ends or is not renewed? Do you receive the updated code, the documentation and a list of known risks?
If you do not get a clear written answer to any one of these questions, that is exactly the clause you will disagree on later.
How does HBS handle a system after delivery?
At HBS we treat delivery as the start of a phase, not the end of a project. So we prepare a system for maintenance before it launches: all code goes through review before it is merged, automated tests cover the core functions, and the technical documentation includes architecture decisions, API documentation and operational runbooks, so any developer can understand the system and fix it quickly, whether they are on our team or yours.
One example is our work with Labib Demian Youssef & Co. (LDY CO). The CMS behind its website, which runs a bilingual catalogue of thousands of laboratory instruments and spare parts, shares its users, roles and permissions with the CRM we built for its sales team. It also has a "sync catalog from code" action that keeps the permission list aligned with new features as they ship, so each new addition does not become a risk to the permissions already in place.
The LDY team also runs the whole catalogue itself, from products and specifications to brands and industries, without going back to developers. That is part of maintenance planning too: the more of the day-to-day changes your team can make on its own, the more the support contract can focus on work that truly needs a developer.
If you have a system running today and you are not sure who is keeping its updates and security on track, or you are preparing to take delivery of a new project and want a clear support contract from day one, tell us about your system and its integrations. Our team will review the current state with you and tell you honestly what really needs maintenance, and you can learn more about HBS custom systems development and post-launch support.








