Six Myths About Patching and Pruning What Is Already Deployed

Six Myths About Patching and Pruning What Is Already Deployed

Engineering teams are good at shipping. They are noticeably worse at looking after what they shipped last year. Roadmaps reward new features, dashboards celebrate releases and nobody gets a trophy for deleting an unused service. The result is a familiar kind of decay: systems that still run, but are quietly out of date, over-permissioned, half-documented and unowned. Much of the reluctance to do upkeep traces back to a few convictions that sound reasonable and are not. Here are six of them, with the facts.

Myth one: “If it is running, leave it alone”

This one has the most appeal because it contains a grain of truth. Changing stable systems carries risk, and restraint is often wise. But “running” is not the same as “healthy”. A service can respond to requests while its libraries accumulate known vulnerabilities, its certificates edge towards expiry and its disk fills slowly. Stability that depends on nobody looking is not stability, it is luck with a long fuse. The sensible alternative is small, regular, reversible changes, rather than a standing ban that turns into one enormous emergency later.

Myth two: “Patching is the security team’s job”

Security teams can scan and advise, but the people who understand how a system behaves when a dependency changes are the people who run it. Splitting responsibility leaves gaps where each side assumes the other has it covered. Teams that treat updates as part of owning a service, with time reserved for them in the normal rhythm of work, keep the burden small. If you want a broader look at why gaps matter commercially, our article on how web application security protects revenue and customer trust covers the business side of the argument.

Myth three: “Pruning is risky, so keep everything”

Every unused endpoint, forgotten test environment and stale credential is a liability you carry for free. Attackers love the systems nobody is watching, and engineers lose time working around components they no longer understand. Pruning does carry risk, but the risk is manageable with a staged approach: switch the item off, watch for complaints for a defined period, and delete it only when nothing breaks. Keeping everything forever is a decision too, and it is the expensive one.

Myth four: “Monitoring tells us when something is wrong”

Monitoring tells you about the things you thought to monitor. It rarely tells you that an old link in your documentation points to a retired host, or that a runbook refers to a tool you decommissioned, or that a public page references a download that no longer exists. Verification of the existing estate is a distinct activity: periodically open the thing, use it as a newcomer would and check that it still delivers what it promises.

Links are the simplest example. Internal wikis, README files, status pages and customer-facing docs are full of addresses that nobody has opened since they were pasted in. Platforms built for link management can take over the checking. URLSnow, for instance, performs its own scheduled health checks across everything you publish and records whether each address still answers, so the dead ones show up in a list instead of in a support ticket.

Myth five: “A rebuild will fix the mess”

Rewrites are seductive. The old system is a tangle, the new one will be clean, and everyone gets to use modern tools. What the story omits is that the old system encodes years of hard-won behaviour, edge cases and customer expectations. A rewrite that does not first audit what exists tends to rebuild the same faults in a newer language. Often the cheaper path is to patch the worst parts, remove what is dead and document the rest, and then decide with real evidence whether a rebuild is still justified. Our note on improving website speed through better architecture shows how much can be gained by working with what already runs.

Myth six: “We will do maintenance when things calm down”

Things do not calm down. Teams that wait for a quiet period discover that quiet periods are a myth of the same family. The practical answer is to make maintenance a permanent, boring slice of capacity rather than a project. A modest recurring slot, protected from feature requests, is more reliable than an ambitious clean-up sprint that is cancelled the first time a deadline appears.

What a sensible maintenance rhythm looks like

Replacing the myths with a routine is straightforward:

  • Patch: apply updates to operating systems, runtimes and dependencies in small batches, test them and keep a way back.
  • Prune: list services, environments, accounts, keys and scheduled jobs; remove or disable the ones without an owner or a purpose.
  • Verify: test the things that matter from the outside, including backups, restores, certificates, documentation and public links.
  • Record: keep a short note of what was changed and why, so the next person understands the state of the estate.
  • Decide: only after those steps, consider whether new building is truly the priority.

The order matters

There is also a human payoff. Engineers who inherit a pruned, patched and documented estate onboard faster and make fewer cautious, defensive changes. New joiners can trust what they read. Nobody has to ask which of three similar-looking services is the real one, because the other two were retired with a note.

It is tempting to do the verification step last, as a final sign-off. In practice it belongs first, because it determines what the patching and pruning should focus on. A system that is mostly fine needs light attention; one that fails verification in several places needs a plan. Without that sorting step, teams spend their effort on the parts that are easiest to touch rather than the ones that most need it.

Maintenance has an image problem, and the myths above are its symptoms. Done well, it is the work that makes every later project cheaper, because new things get built on ground that has been checked. Before the next release is scheduled, ask what already runs, whether it still deserves to, and whether it still points to the right place. The honest answers usually set the agenda better than any roadmap workshop.