Pattern · seen in 1 breakdown across 1 company

No Uncommitted Config

Definition

Every system accumulates configuration that lives outside its code: settings applied by hand, state managed through a vendor's CLI that bypasses the normal API, decisions made in a console years ago by people who have since left. Most of it is harmless. Some of it is load-bearing — the system's correctness silently depends on it — and load-bearing state with no record is a specific, severe hazard: no review can see it, no linter can check it, no changelog reader can realize an upcoming change invalidates its assumptions, and no responder can find it during the incident it eventually causes. Its failure mode is delayed and archaeological: it detonates when the environment shifts under an assumption nobody can see, and the people who could have remembered it are gone.

The pattern is a floor, not an aspiration: no load-bearing state may exist outside version control. Where a mechanism resists codification — configuration that must be fetched via a proprietary CLI, hand-edited, and re-uploaded — there are exactly three acceptable outcomes: build the custom tooling that brings it into the record; replace the mechanism with one that can be recorded; or register it as a named, documented exception with an owner and a review date. The unacceptable fourth state is the default one: unrecorded, unowned, and slowly forgotten. The record serves two purposes the pattern insists on distinguishing: consistent application (the same state can be reapplied, compared, and drifted-checked) and historical memory (breadcrumbs for engineers who arrive after the authors have left — the record is documentation that cannot go stale, because it is the state). Boundary against Violation Ratchet: the ratchet mechanically prevents new violations of an established invariant; this pattern establishes the invariant that all load-bearing state be in the record at all — the ratchet is often the right enforcement tool once the record exists.

When it applies

01Infrastructure with hand-configured components whose authors may leave: network policies, routing topologies, cluster bootstrap decisions, console-applied settings
02Vendor systems whose configuration is managed only through proprietary CLIs or UIs, actively resisting infrastructure-as-code
03Long-lived platforms where environmental changes (version upgrades, deprecations, renamed labels and APIs) can silently invalidate assumptions embedded in old state

Tradeoffs

Bringing CLI-only state into the record costs real engineering — custom tooling or mechanism replacement — for components that currently work fine, which is exactly why the gap persists until it detonates
A complete record creates review and change-management surface for state that changes rarely; the discipline must be cheap enough that operators don't route around it
Named exceptions require ongoing ownership — an exception list without review dates degrades back into the unrecorded state with extra steps

The same move, 1 ways

Every row is a production system that bet on this pattern — the note says how, in that system's own terms.

Reddit
r/RedditEng
2023
This comes straight from the main promise in Reddit's fixes: codify everything, 'both to ensure consistent application and to have a clear historical record.' The pattern is that no critical state may exist outside version control. State that can only be managed through a vendor's tool gets custom tooling to bring it into the record, gets replaced by something recordable, or becomes a named, documented exception, never a fourth thing that is simply unrecorded. The record has a second job too: leaving a trail for the responders who arrive after the original authors have gone. Read the breakdown →

Problems this pattern answers

The walls where its breakdowns live — each opens the cross-company comparison.