Why software needs maintenance — and what good maintenance looks like

The short answer: software isn't a one-off purchase — it's something that needs ongoing care, or it quietly rots. The tools it connects to change, your processes evolve, small issues accumulate. Good maintenance isn't a ticket queue you chase; it's active care that keeps the system working, current and improving as your business grows.

Why does software rot without care?

A system goes live and works. Then an integrated tool updates and something breaks. A process changes and the software no longer matches it. Small bugs get ignored and become workarounds. The person who understood it moves on. None of these is dramatic, but together, unattended, they turn a good system back into the mess it replaced — usually within months.

It helps to see software as a living thing rather than a finished object. A building needs maintenance not because it was built badly but because weather and use act on it constantly. Software sits in a similarly moving environment: the tools around it change, the rules it encodes change, the people who use it change. Standing still, in that setting, means falling behind. This is the same slow decay behind why custom software projects fail after launch.

What does good maintenance actually look like?

• •Keeping it running — issues resolved as they arise, before they become workarounds.
• •Keeping it current — updated as connected tools change and your process evolves. When Xero or your CRM shifts something, the integration is looked at before it quietly fails.
• •Keeping it improving — building on it as your business grows, not freezing it at launch. The system that fit you last year should still fit you next year.
• •Being available — active care, not a ticket queue you have to chase.

Think of it like a bookkeeper looking after your books or an IT team looking after your network — ongoing, proactive, and part of how the business runs. You don't wait for the books to be a disaster before you bring in a bookkeeper; the point is to keep them healthy so they never become one. Good software maintenance works the same way.

Why "we'll maintain it ourselves" often fails

Most small and mid-sized businesses don't have a spare person whose job is tending software. It falls to whoever has time, which means it falls to no one. The system doesn't fail loudly — it degrades quietly, until one day it's clearly failing and the cause is months of small neglect. Planned, owned maintenance avoids that.

The trap is that internal maintenance looks free and looks manageable, right up until it isn't. Nobody schedules the neglect; it just accumulates in the gaps while your team gets on with the actual business. By the time someone notices, the fix is bigger and costlier than a steady stream of small attentions would ever have been.

What does neglect actually look like?

It's rarely a crash. Picture a system that quietly connects to Xero to push invoices. One day Xero changes how part of its connection works — a routine update on their side. Nothing screams; invoices just stop syncing. For a fortnight the team keys them in by hand, grumbling but coping, until someone finally asks why the automation "stopped working." That's neglect in its natural form: not a disaster, a slow leak. Under good maintenance, the change to Xero is spotted and the integration adjusted before anyone in the business notices. Under no maintenance, it becomes a workaround, then a habit, then a reason people start to say the system "doesn't really work anymore."

Multiply that across every tool the system touches and every process that shifts over a year, and you can see how a system that launched perfectly can drift into the exact mess it was built to replace — without a single dramatic failure.

What should ongoing maintenance cost?

There's no single figure, but a useful way to think about it: maintenance is a small, predictable percentage of the build, paid regularly, in exchange for the system staying healthy. Usually it takes the shape of a retainer — you're paying for availability and proactive care rather than a fixed deliverable, which is why a retainer suits it better than a fixed price. The number should be knowable up front and sit in your budget from day one. Treat it the way you treat insurance or a service plan on a vehicle: a steady, modest cost that quietly prevents a large, sudden one. The businesses that get burned are almost always the ones who budgeted for the build and forgot the care.

Maintenance is what makes custom worth it

A maintained system pays off for years — it stays useful, stays trustworthy, and grows with the business. An unmaintained one is the abandoned-build horror story. The difference between the two isn't the quality of the launch; it's whether anyone's looking after it afterward.

That's why maintenance belongs in the plan and the budget from day one, not bolted on as an afterthought when something breaks. When you're weighing what a build costs, the ongoing care is part of the real figure — the same way the running cost of a vehicle is part of owning it, not a surprise. Deciding who owns the system's health, and paying for that properly, is what turns a one-off spend into a lasting asset.

Related reading

• •Why custom software projects fail after launch — and how to avoid it
• •What to look for in a custom software partner (a checklist)
• •Who owns your data — and what happens if your provider disappears
• •Up to the pillar: getting software delivered right

The honest first step

Getting maintenance right starts with treating it as part of the plan, not an afterthought — deciding who owns the system's health before it's built. A build planned with ongoing care in mind is one that keeps paying off.

Tell us what you run, and we'll show you what's possible.