The 38-point cluster health checklist
This is the list we work through on a paid audit, published without a gate. Every item answers three questions: why it matters, how to verify it in your own environment, and what the healthy state actually looks like.
No email required to read it. If you want a shareable copy plus the interpretation table we use to turn a "no" answer into a fix, that form is at the bottom.
Network & fabric
6 checks.
- N1
Firewall HA failover has been tested under load, not in a maintenance window
Why it mattersAn HA pair that has never failed over under traffic is a configuration, not a capability. The failure mode people discover in production is session state that does not synchronise for the protocol they actually run.
How to verifySchedule a failover during business hours with real traffic. Time it from the first dropped packet to full recovery. Repeat in the reverse direction — asymmetric paths are the ones that break.
What good looks likeSub-second failover for stateful sessions, both directions, with a written record of the measured interruption. If nobody has ever timed it, the number you have is a hope.
- N2
Redundant peers do not share a single power feed or upstream
Why it mattersTwo switches in an MLAG pair plugged into the same PDU, and both uplinked to the same upstream switch, is one switch with extra cabling. This is the most common false redundancy we find.
How to verifyTrace power for both members back to the breaker. Trace every uplink to its upstream device. Draw it — the drawing usually makes the problem obvious.
What good looks likeSeparate PDUs on separate feeds, ideally separate UPS, and uplinks landing on physically distinct upstream devices.
- N3
Routing convergence time is measured, and BFD is doing the work
Why it mattersBGP hold timers default to 90 seconds. Without BFD, a dead link can black-hole traffic for the better part of two minutes while the control plane decides.
How to verifyCheck whether BFD is configured per neighbour and what the detection multiplier is. Then pull a link and measure the actual reconvergence.
What good looks likeBFD at 300ms × 3 on all internal adjacencies, with a measured reconvergence under one second.
- N4
Configuration can be restored onto a bare device, and you have done it
Why it mattersBackups that have never been restored are a hypothesis. Device firmware differences routinely make a restored config fail to boot the exact way it was saved.
How to verifyTake a spare unit (or a lab instance), restore the newest backup, and bring the device into service. Record how long it took and what had to be adjusted by hand.
What good looks likeAutomated config backup into version control, plus a restore that a second engineer can perform from the runbook without calling the person who wrote it.
- N5
Out-of-band management is physically separate
Why it mattersIf switch management lives on the network that the switches provide, a failed configuration change takes away your ability to fix it. This is how a 20-minute outage becomes a site visit.
How to verifyConfirm management interfaces are on a dedicated VLAN or physically separate switch, reachable when the data plane is down.
What good looks likeA separate management network, on its own power where practical, with access that survives a total data-plane misconfiguration.
- N6
MTU is consistent end to end, including the storage path
Why it mattersJumbo frames configured on the storage VLAN but not on the interswitch links produce a cluster that works until an MTU-sensitive transfer touches a specific path. Symptoms look random.
How to verifyPing with the don't-fragment bit set at 8972 bytes (for a 9000 MTU) between every pair in the storage path. Watch interface counters for giants.
What good looks likeDF-bit pings succeed across the entire storage and replication path, and giant counters are not incrementing.
Foundation & HA
7 checks.
- F1
Fencing actually isolates, and it has been triggered deliberately
Why it mattersA cluster without working fencing will, on a split, do the worst possible thing: both sides keep running and both write. Fencing is not a feature of high availability — it is the precondition.
How to verifyTrigger a real fence on a non-critical node and confirm the victim loses power or network, and that the surviving side takes over. Check both the IPMI and the fabric paths independently.
What good looks likeTwo independent fence paths, both tested, both able to complete within the cluster's configured timeout.
- F2
Quorum survives the failure it is supposed to survive
Why it mattersA three-node cluster in two racks gives you two nodes in one rack. Lose that rack and you have lost quorum regardless of how many nodes remain.
How to verifyMap each node to a failure domain. Simulate losing the largest single domain and confirm the surviving set still holds quorum — or that a witness or arbiter exists.
What good looks likeQuorum is preserved for every single-domain failure you are claiming to tolerate, and a witness device is placed outside the primary domain.
- F3
Clock offset is monitored, not assumed
Why it mattersKerberos, TLS validation, database replication, distributed consensus and log correlation all depend on time. Drift is silent until something refuses to authenticate.
How to verifyRun chronyc tracking on every node and compare offsets. Check that the source set is diverse and that a reachable source is not a single upstream.
What good looks likeOffsets under a few milliseconds across the fleet, at least four time sources, and a dashboard that alerts before drift becomes an incident.
- F4
Firmware and kernel versions are known and deliberately drifted
Why it mattersAccidental version spread means an upgrade behaves differently on three nodes out of twenty. Deliberate drift, staged per rack, is a safety mechanism; unknown drift is a roulette wheel.
How to verifyCollect firmware and kernel versions into one table, grouped by node. Ask for the reason behind every outlier.
What good looks likeA version matrix with a documented reason per group, and an upgrade cadence that keeps the fleet within one minor version.
- F5
A node can be rebuilt from nothing, reproducibly
Why it mattersThe rebuild procedure lives in three people's heads. That is your real disaster recovery plan, and it does not survive a resignation.
How to verifyTake a decommissioned node. Rebuild it end to end using only the documented procedure and the repository. Hand the procedure to someone who has not done it before.
What good looks likeAutomated provisioning (PXE, Ansible, or an image pipeline) that produces a byte-comparable configuration, and a second engineer who has completed a rebuild unaided.
- F6
Service start order is enforced, not hoped for
Why it mattersAfter an unplanned reboot, a service that starts before its dependency is available can come up in a degraded state that looks healthy to a naive health check.
How to verifyReboot a node with all services cold and watch the order. Compare against what the services actually require — mount, network, database, then application.
What good looks likeExplicit unit dependencies or a parallel-start defence, so a cold boot converges to a correct state without human intervention.
- F7
Privileged access is enumerated, individual and logged
Why it mattersA shared root credential is an audit finding and an incident-response blind spot. If you cannot attribute a change to a person, you cannot reconstruct an outage.
How to verifyList every account with root or equivalent privilege. Check whether access is individual, whether sudo is logged centrally, and whether any keys are shared.
What good looks likeNo shared privileged credentials, per-person keys, central sudo logging, and a documented break-glass account with its own alerting.
Data & storage
8 checks.
- D1
Database failover has been performed, and the application survived it
Why it mattersA replica that has never been promoted is a backup, not high availability. The failure that matters is not the promotion — it is whether the application reconnects without a restart.
How to verifyPromote the replica in a controlled window with the application connected. Time the interruption. Then fail back and confirm replication resumes without a full rebuild.
What good looks likeA measured interruption the business can live with, automatic application reconnection, and a documented fail-back that does not require a maintenance window.
- D2
A restore has been timed, from backup, into a usable state
Why it mattersBackup success is not restore success. Compression bugs, missing WAL segments, and permissions drift on the target all pass the backup job and fail the restore.
How to verifyPick a random backup from at least a month ago. Restore it to a clean host and bring the service up against it. Time the whole thing including validation.
What good looks likeA measured restore time you can put in an RTO, performed by someone other than the person who wrote the backup job.
- D3
At least one copy is immutable or offline
Why it mattersEvery modern ransomware incident finds the backups and encrypts them, because the backup target is reachable with the same credentials as everything else.
How to verifyIdentify whether any copy is append-only, object-locked, or physically offline. Ask what credential would be needed to delete it, and from where.
What good looks likeOne copy that the compromised production identity cannot delete, with a retention lock enforced by the storage layer rather than by policy.
- D4
Ceph CRUSH rules match the physical failure domains
Why it mattersA replicated pool that places all three copies across OSDs on the same host is a two-copy pool with extra ceremony. Durability claims come from the map, not the replication number.
How to verifyInspect the CRUSH tree against the physical topology. Confirm failure domains are declared at host, rack and site level where they exist, and that pools use the right ruleset.
What good looks likeFailure domains declared to match reality, pool rules consuming them, and a documented answer to what happens if a whole rack disappears.
- D5
Recovery and backfill are rate-limited so they cannot take out the front end
Why it mattersA disk replacement can trigger a rebalance that saturates the storage network and makes the healthy cluster slow enough that users notice — turning a disk failure into a service incident.
How to verifyCheck the recovery and backfill throttles against measured network headroom. Then test with a large rebalance during business hours, ideally in staging.
What good looks likeThrottles set from measured bandwidth headroom, with front-end latency staying within target during a full-disk rebuild.
- D6
Multipathing is genuinely active/active and monitored
Why it mattersTwo paths configured but one silently down means you have no redundancy and no alarm. The failure is only discovered when the surviving path fails too.
How to verifyInspect path state per LUN and per initiator. Look for failed or ghost paths. Verify path_selector matches the array's ALUA behaviour.
What good looks likeAll expected paths active, no ghost paths, monitoring that alerts on any path transition rather than only on total loss.
- D7
Silent corruption is being detected on a schedule
Why it mattersStorage that returns wrong data without an error is worse than storage that fails, because the corruption propagates into your backups.
How to verifyConfirm scrubbing or checksums are enabled and running: pool scrub for Ceph, media scrub for arrays, pg_checksums or equivalent for databases.
What good looks likeScheduled scrubbing with results reviewed, and a documented response when a scrub finds an inconsistency.
- D8
Disk health is predictive, not reactive
Why it mattersWaiting for a disk to fail means you are always reacting, and in a rebuild-heavy week that means degraded redundancy for days.
How to verifyCheck SMART attributes for reallocated sectors, pending sectors, and growth trends. Confirm alerts fire on trend, not just on the failure flag.
What good looks likeAlerts on trend lines weeks before failure, with a documented replacement process and spares already on site.
Compute & HPC
5 checks.
- C1
GPU utilisation is measured honestly, including idle time
Why it mattersExpensive accelerators running at 30% utilisation is a budget problem that nobody owns, because the utilisation number usually comes from the scheduler rather than the device.
How to verifySample device-level utilisation over a week, not scheduler occupancy. Break it down by user and by job. Look specifically for allocated-but-idle cards.
What good looks likeDevice-level utilisation reported per user and per job, with a named owner for the idle tail and a policy for reclaiming it.
- C2
Gang scheduling is configured where jobs span nodes
Why it mattersWithout gang scheduling, a multi-node training job can hold half the cluster while waiting for the other half, deadlocking against another job doing the same. The cluster looks busy and produces nothing.
How to verifyCheck whether the scheduler enforces all-or-nothing allocation for multi-node jobs, and whether backfill respects reservations.
What good looks likeGang scheduling enforced, with the deadlock scenario tested by submitting two competing multi-node jobs.
- C3
Driver, CUDA and fabric versions form a tested matrix
Why it mattersOne node at a different driver version produces jobs that fail only when scheduled there. The randomness wastes more engineer time than the upgrade would have.
How to verifyCollect driver, runtime and fabric firmware versions across all nodes into one table. Compare against the combination your workload has actually been validated on.
What good looks likeOne validated version set across the fleet, with any deviation intentional, documented and excluded from general scheduling.
- C4
The interconnect has been benchmarked under real collective patterns
Why it mattersA fabric can pass a point-to-point test and still collapse under all-reduce. Point-to-point numbers are how fabric problems hide.
How to verifyRun collective benchmarks (all-reduce, all-to-all) at the job sizes you actually run, across the topology you actually use. Compare against theoretical fabric capacity.
What good looks likeCollective benchmarks matching the vendor's realistic expectations, re-run after any fabric change and retained as a baseline.
- C5
Fair-share and priority policy reflects who pays for the cluster
Why it mattersA default first-in-first-out queue means one researcher's sweep can block a production job for a day, and the conversation that follows is political rather than technical.
How to verifyReview the scheduler's partition, QOS and fair-share configuration against actual usage and who funds the cluster.
What good looks likePolicy documented and agreed with users, with a preemption rule everyone understands and expected wait times published.
Platform & delivery
7 checks.
- P1
etcd backups exist and a restore has been rehearsed
Why it mattersLosing etcd means losing every object in the cluster. It is the single highest-consequence, lowest-cost thing to protect, and it is routinely the least tested.
How to verifyConfirm snapshotting is scheduled, snapshots leave the node, and retention covers more than the interval. Then actually restore into a scratch cluster.
What good looks likeAutomated off-node snapshots, a measured restore that reconstructs a working control plane, and the procedure in the runbook.
- P2
The upgrade path from the current version is supported
Why it mattersClusters drift until the upgrade you need requires three intermediate versions, none of which were tested against your workloads. Skipping minor versions is not supported by anyone.
How to verifyCompare the running version against the current supported releases. Check whether the next upgrade is a supported single step or a chain.
What good looks likeNever more than one minor version behind the supported window, with a rehearsed upgrade path against a staging cluster.
- P3
Requests and limits reflect measured usage
Why it mattersNo limits means one workload can evict its neighbours. Limits set far too low means OOMKill loops that look like application bugs. Both are common and both are cheap to fix.
How to verifyCompare declared requests and limits against a week of measured usage per workload. Look for the two extremes specifically.
What good looks likeRequests within a reasonable band of real usage, limits present where they protect neighbours, and no namespace that can starve the node.
- P4
Ingress configuration has a known blast radius
Why it mattersA single misconfigured ingress resource can take down every route that shares the controller. Nobody notices until someone's typo becomes everyone's outage.
How to verifyIdentify what shares a controller and where a bad resource would fail. Check admission policy: is anything validating resources before they reach the cluster?
What good looks likeAdmission validation on ingress resources, separated controllers where isolation matters, and a tested recovery from a bad route.
- P5
Secrets are managed and rotatable
Why it mattersCredentials committed into manifests, or stored in a namespace everyone can read, are the most common finding in any cluster review. Rotation is the part that reveals whether management is real.
How to verifyFind every place a credential is stored. Then perform one rotation end to end and record what broke.
What good looks likeA secret store with access control, no credentials in version control, and a rotation procedure that has been performed at least once.
- P6
The artifact registry is as reliable as production
Why it mattersIf the registry is down, you cannot scale, roll back, or recover. It is usually deployed as an afterthought, without redundancy or capacity planning for garbage collection.
How to verifyCheck registry storage, replication and garbage-collection schedule. Test pulling an image with the registry's primary storage degraded.
What good looks likeRegistry with redundant storage, a GC schedule that does not starve concurrent pulls, and images retained for at least the rollback window.
- P7
Every certificate, public and internal, has an owner and an expiry view
Why it mattersPublic certificates usually have automation. Internal ones usually do not, and internal expiry is where clusters go dark at 3am with a confusing error.
How to verifyEnumerate every certificate the platform depends on, internal mTLS included. Compare expiry dates against who would notice and who would renew.
What good looks likeOne expiry view covering internal and external certificates, alerts at 30 and 7 days, and automation wherever the issuer allows it.
Operations & recovery
5 checks.
- O1
Alerts reach a human, and the human agrees they are actionable
Why it mattersAn alert that pages nobody is a log line. An alert that pages constantly trains people to ignore the pager. Both failure modes are equally expensive.
How to verifyTrace the routing for critical alerts to a real destination. Interview whoever is on call: which alerts do they ignore, and why?
What good looks likeEvery critical alert routes to a named person, has a documented first action, and the on-call engineer does not describe any of them as noise.
- O2
The monitoring system is monitored from outside itself
Why it mattersMonitoring on the same host or network as the monitored service fails silently with it. The outage you cannot see is the one that lasts longest.
How to verifyConfirm an independent external probe exists on separate infrastructure, and test it by blocking the monitoring path deliberately.
What good looks likeAn external probe on independent infrastructure, alerting into a channel that does not depend on the monitored environment.
- O3
RTO and RPO are measured numbers, not aspirations
Why it mattersAn RTO nobody has validated is a number in a slide. When the real event arrives, the gap between the promise and the reality is discovered at the worst moment.
How to verifyCompare the documented RTO and RPO against the measured restore and failover times from your drills. Note the gap.
What good looks likeDocumented targets within a small margin of measured reality, reviewed after every drill and every real incident.
- O4
Changes have a rehearsed rollback, not an assumed one
Why it mattersA rollback plan that has never been executed is a second change, made under pressure, at 2am, by tired people. Most are only discovered to be impossible during the outage.
How to verifyTake the most recent significant change and ask what the rollback was. Then confirm whether it was tested, including whether the old state still exists.
What good looks likeEvery significant change has a rollback that has been performed at least once in a non-production environment, with the previous state preserved until the change is proven.
- O5
More than one person can operate the cluster
Why it mattersThe bus factor is the oldest risk in infrastructure and the one most often left unmanaged. Documentation that assumes its author is present is not documentation.
How to verifyPick the two most critical procedures. Ask someone who did not write them to perform the task using only what is written down.
What good looks likeAt least two engineers who can execute the critical procedures unaided, with documentation kept current by the person who last performed the task.
Run it in an afternoon, then look at the pattern
Work through the 38 items and mark each one pass, fail, or unknown. The individual failures matter less than the shape of the result.
- A cluster of unknowns is the real finding. "Unknown" almost always means nobody owns it, and an unowned control is an untested control.
- Fencing and restore failures are not equal to the rest. Without working fencing you do not have high availability, whatever the rest of the list says. Without a tested restore you do not have a backup.
- Failures cluster by layer. If most of your failures sit in one layer, that layer has been treated as somebody else's job. That is a staffing observation, not a technology one, and it is worth saying out loud.
If you want us to run it against your estate and argue with you about the answers, that is what the fixed-price audit is.
The 38-point Cluster Health Checklist
The exact list we work through during a paid audit: quorum and fencing, storage failure domains, backup restorability, upgrade paths, certificate expiry, GPU allocation idleness, and the eleven things that most often turn out to be wrong.
- 38 items, each with what "good" looks like and how to verify it
- Written for engineers, not for procurement
- Includes the questions we ask that usually make people go quiet
Found more than you want to fix yourself?
That is a normal outcome. A 38-point review usually finds a handful of real problems and a lot of unowned ones. We can take either.