Your business application still works. But who could maintain it tomorrow?

For years, the software behind a company's orders is barely discussed. Then somebody needs to change a price, fix a fault or recover from an outage. It turns out the person who understood the system has moved on. How much does the business really know about the application it depends on?
Two colleagues discuss software on a laptop, with icons representing the business application, documentation and maintenance.

The essentials in 30 seconds

  • An application can work every day and still be hard to repair or hand over, particularly when its history lives in one person's head.
  • Patches, monitoring and backups are standard services. The important test is whether the business could recover and carry on working.
  • Keeping a system, updating part of it or replacing it altogether should depend on how it is used and what condition it is in.

A small pricing change, a much bigger problem

Next month's price list is being prepared. At a small distribution business, the sales team asks for a revised discount for a few customers. Nothing unusual about that.

The order-management application is still doing its job: working out prices, preparing delivery notes and passing figures to the accounts team. It has gradually been adjusted to the way this particular business operates.

Then someone opens the code. The developer who wrote the discount rules is gone. The rules themselves are there, but nobody recorded why some customers received exceptions. Making a change may be easy; knowing what it will do to existing orders is another matter.

Orders continue to come in. The new prices, however, are put on hold until someone can work out what the software is actually doing.

This is an illustrative scenario, not an actual E-merging Digital customer or incident.

We tend to think about maintenance when a system breaks. In practice, questions about supportability can surface just as quickly when a business wants to make a perfectly ordinary change.

What happens when knowledge leaves the business?

Having the code is one thing. Knowing why it was written that way is another. A decision made years ago may never have been documented at all.

Who knows why a particular invoice is calculated differently? Does the organisation control its administrator accounts? Can the hosting provider repair the application, or only keep the server available? Is there enough documentation for another team to take over?

Using specialist suppliers makes sense for many smaller companies; they cannot keep every skill in-house. What matters is knowing what would be handed over if the relationship ended: code, access, documentation and a workable route to continued support.

A useful handover pack need not be enormous. It might contain a list of components, securely managed access details, notes on unusual business rules and the names of people responsible. But a new team has to be able to use it; an outdated file gathering dust will not help.

Imagine a capable developer joining the project on Monday morning. Would they know where to begin by the end of the day?

Backed up is not the same as recoverable

“We've got backups.” It's a reassuring answer — until somebody asks what could actually be recovered.

A nightly database copy is a good start. It doesn't tell you whether the team can recover the right application version, its settings or the files people have uploaded. Nor does it explain how much recent work might be lost, or when the business could take orders again.

Only a recovery test can start to answer them.

Drupal's official update documentation calls for backing up the database before changes and checking the site after database updates. The broader principle applies to business software of all kinds: recovery must be tried, not assumed.

Of course, not every system warrants the same effort. An occasional internal catalogue and the application handling a company's daily orders pose different risks. The business must decide how much disruption it can tolerate and what level of protection is proportionate.

Where automation helps — and where it stops

There's much less manual work involved in routine maintenance than there used to be. Hosting platforms already monitor availability and flag some problems. Pantheon's Autopilot, for example, offers updates for Drupal and WordPress with visual checks ahead of an optional deployment.

Belgian supplier Noyau also advertises packages combining updates, monitoring, backups, tests and reports, depending on the plan. None of that is an exclusive invention of a single agency.

These are the suppliers' published service descriptions, not independent assessments of how a particular website is looked after.

But an automated check can miss the mistake that matters. The order form looks exactly as it did yesterday. Every status indicator is green. And one customer's agreed discount is wrong. The first person to notice may be the accountant preparing the invoice.

A small set of real-world checks can reveal more: an order with a special discount, a corrected invoice, a customer record moving through its usual steps. Technical indicators matter, but they only show part of the picture.

Software keeps ageing even when nobody changes it

A company can decide not to add any new features this year. It has much less control over when the software underneath reaches the end of its support life.

Drupal is a useful example. Its official release calendar gives **9 December 2026 as the end-of-life date for Drupal 10**. Sites running that version are not expected to stop working the next morning. But new releases for that major version will cease under the normal support programme.

An organisation running Drupal 10 should check what version is installed, which extensions it relies on and what an upgrade would involve. It can then choose a time to test the change, rather than waiting for a rushed decision.

There's no prize for adopting every new release first. But knowing the deadlines early gives a company more room to plan.

Keep it, upgrade it, or start again?

“We should rebuild the whole thing.” It's a familiar suggestion when software has aged. Sometimes it's right. It should still be challenged before becoming an expensive project.

If the application meets current needs and can still be supported, routine maintenance may be the least disruptive choice. That means fixing defects, testing changes and keeping the documentation usable.

If the core system remains sound but a few components are ageing badly, upgrading them in stages may be better. An accounting interface, an unsupported extension or a troublesome screen can sometimes be replaced without discarding years of useful work.

A full replacement deserves consideration when problems run deeper: essential workflows are no longer fit for purpose, important dependencies cannot be maintained on reasonable terms, or a proven off-the-shelf product now meets the need better.

But replacement brings migration work, data checks, user training and the risk of losing small but important rules that the old application quietly enforced.

A newer product brings its own constraints. An older system that still meets the need and can be maintained properly may have plenty of useful life left.

Questions worth asking before signing anything

The market for external maintenance is real. In July 2026, the United Nations procurement register recorded a contract award covering maintenance, hosting and design for Cities Alliance's Drupal website. That is evidence of one actual purchase, not a measure of what SMEs generally spend.

That does not tell an individual business what to buy. Its decision will turn on the details of a proposed contract.

Ask what is included and what costs extra. Would anyone respond outside working hours? Can the business retrieve its code, access details and documentation if it changes supplier? What will the provider actually test after an update — and can they show the results of a restore test?

The same questions apply to an internal IT team. Whether work happens inside or outside the company matters less than knowing who is responsible and what has been checked.

The application is working? Good. Now ask what a new developer would need to fix it tomorrow. If the answer is “we'd have to find out” or “we'd call the person who built it”, that's a useful place to start.