The scheduling coordinator at a small flight school once told a new hire that the whiteboard in the briefing room was not a record of what happened; it was a record of what everyone hoped would happen. The real truth lived in the tech logs, and the gap between the two was where problems hid. That remark comes to mind whenever someone asks how to audit a Kubernetes cluster, because KubernetesOps has exactly the same gap: what the configuration promises versus what the cluster actually does.
Below is a four-part walk-through that fits into one unhurried afternoon. It borrows its stages from the maturity ladder in a reference entry on KubernetesOps published by xOps School, which describes five rungs from ad hoc to disposable. The entry is open about the fact that the ladder is the Atlas’s own invention rather than an industry standard, so use it as a conversation starter, not a certificate.
Before you start: gather the logbooks
An audit needs paper trails. Collect the list of clusters, the version each one runs, who is on call for it and where its configuration lives. If you cannot assemble that list in ten minutes, you have already found your first finding, and it belongs at rung one: ad hoc. There is no shame in that; most teams begin there, just as most students begin by flying with the instructor’s hand hovering near the controls.
Checklist part one: is the work repeatable?
Repeatable means somebody else could do it tomorrow. Tick each of these only when you have seen the evidence yourself.
- The cluster’s configuration sits in version control, not in one engineer’s terminal history.
- A written runbook exists for the upgrade, and two hops in a row have been completed by following it rather than by memory.
- Nobody hand-edits live objects without recording the change somewhere reviewable.
- The team can say which add-ons run in each cluster and who owns each of them.
Hand-tuned clusters earn a nickname in the trade: pets. They get names, they get nursed, and when they fall ill nobody remembers exactly how they were built. A flight school would never accept an aircraft with undocumented modifications; do not accept the digital equivalent.
Checklist part two: is it managed?
This rung is where the numbers start to matter. According to the Atlas, a managed cluster keeps its version lag at one minor or less, has requests declared on at least 98 percent of its pods, and has had a backup restore drilled rather than merely scheduled.
- Count how many minors separate each production cluster from the newest supported release. More than one means the lag item is red.
- Pull the share of pods that carry resource requests. Under the threshold, a policy that rejects pods without requests is the usual remedy.
- Find the last time anyone restored a backup into a clean environment. If the answer is “never”, then your backups are a hope, not a capability.
- List every disruption budget that allows zero voluntary disruptions. Those will block routine node drains and turn maintenance into an argument.
Student pilots know this feeling well. A student can log fifty hours and still not have practised a forced landing; hours on paper are not the same as a rehearsed skill.
Checklist part three: is it measured?
Measured clusters have a monthly review of a handful of numbers. The ones suggested in the entry are days remaining until a version loses support, the elapsed time between deciding to upgrade and finishing, and the ratio of real usage to requested capacity. The Atlas expects two quarters of tracking before calling this rung earned, which is a sensible guard against a dashboard built the week before an audit.
- Is there a calendar covering the next twelve months of end-of-support dates?
- Can you show the upgrade lead time for the previous two upgrades?
- Does anyone look at the usage-to-request ratio, and does it feed decisions about node counts?
Checklist part four: could you rebuild it?
The top rung, which the Atlas calls disposable, asks whether a cluster could be torn down and recreated within the recovery objective you promised the business. Few teams get there. It is still worth asking the question out loud, because the honest answer shows what your documentation is missing. A hangar that cannot reassemble an engine from its manuals is carrying hidden risk, and so is a cluster that exists only as a running object.
One practical tip: run the audit with a second person who did not build the cluster. Fresh eyes ask the questions that insiders have stopped noticing, such as why a particular budget forbids any disruption at all, or why a certificate renewal lives on one person’s calendar. Write the answers as plain statements with dates, because a vague note like “mostly fine” cannot be re-checked next quarter.
Turning findings into a thirty-day plan
Do not try to repair every finding in a single push. A sensible first month covers inventory and the zero-disruption budgets, nothing more. Month two moves configuration into code, completes one runbook hop and restores a backup. Month three adds an admission rule for requests, a first dashboard and a rough rightsizing pass. That cadence is borrowed from the thirty, sixty and ninety day plan in the same entry, and it fits a team that also has a day job.
If you are building your own skills along the way, the structured route described in a guide to mastering infrastructure engineering through a course path is a reasonable companion, and the write-up on speeding up software delivery in Japan with hands-on cloud engineering offers a view of how teams apply these ideas on real projects.
Finish by writing down one sentence per rung: where you are, what evidence you saw, what you will change first. Pin it next to the whiteboard, and then trust the logs over the hopes.

