Data engineers spend their days making sure tables, jobs and warehouses behave. Underneath those pipelines sits a layer of servers, networks, buckets and clusters, and more and more of it is described in code. Looking after that layer as a living lifecycle, rather than a one-off setup script, is what people loosely call InfraOps. Here is a clear explanation of the idea, built around the questions a data team tends to ask first.
Origin of the word and its looseness
InfraOps has no governing body and no exam. The Ops Atlas, in its published InfraOps entry, describes it as informal shorthand for infrastructure operations and applies it specifically to the lifecycle of infrastructure as code. The entry adds that the label gets attached to unrelated things, such as job titles and a commercial product, so context decides what any given speaker means.
For a data team, the practical reading is simple: every warehouse cluster, network rule, queue and storage bucket that your pipelines rely on should be created, changed and removed through reviewed code rather than through clicks in a console.
Three records of the same estate
The most useful idea in the Atlas entry is that any code-managed estate has three versions of the truth. There is the code, which states intent. There is the state, which is the tool’s own bookkeeping of what it believes it created. And there is reality, which is whatever the cloud provider is actually running.
Anyone who works with data lineage will find this familiar. It is like having a source table, a cached extract and a dashboard that were all supposed to match. Problems appear in the gaps, and the Atlas names four of them:
- A change was merged but never applied.
- Somebody edited a resource by hand, so reality drifted from the code.
- A resource exists in the cloud that nothing in code describes.
- A resource was deleted outside the tool, so the bookkeeping points at nothing.
Why a clean report can still mislead you
A tidy comparison between code and state only speaks about objects the tool already knows. A storage bucket created manually during an incident will not appear in it at all. One vendor tutorial cited by the Atlas makes the point: a firewall group created by hand showed up merely as an ID inside a diff. In data terms, the check passes because it never looked at the row that was wrong.
Keeping state small enough to reason about
One of the few concrete numbers in the entry comes from Google Cloud’s guidance, which advises against holding more than about a hundred resources in a single state, and preferably only a few dozen. The reason is blast radius and speed: a huge shared state makes every plan slow and every mistake large. Split by environment and by domain, much as you would partition a large table so that one bad load does not poison everything.
For orientation, the Atlas mentions a large chat-software company whose estate reached about 1,400 state files in 2022, one for every region within each account. That is a lot of files, but each one stays small enough for a person to review.
Reviewing a plan the way you review a migration
A plan is a preview of what the tooling is about to do. Data engineers already know the habit from schema migrations: read the diff before running it. The Atlas lists skipping plan review under the habits to avoid, especially the rationalisation that the code itself serves as documentation. Two cautions are worth adding.
- Plans go stale. Applying one saved plan can invalidate other plans prepared against the same state, so treat them as perishable.
- Plans and state can hold secrets, so keep them inside the job that produced them rather than passing them around as downloadable artifacts.
Detecting drift on a schedule
A common pattern is a scheduled plan that returns a special exit code when it finds differences, so a scheduler can alert a person. Think of it as a data-quality test that runs nightly against your infrastructure. If you want to see how the same mindset applies to pipelines themselves, the walkthrough on keeping real-time analytics from breaking covers the data side of that story.
Be careful about automatic correction. Quietly reverting every difference amounts to an unreviewed deploy running with the most powerful credentials you own. The Atlas leans toward alerting and assigning an owner, with auto-revert reserved for modules that carry no durable data.
Measuring it without fooling yourself
The entry proposes a handful of measures: what share of the estate in scope is codified, how often drift appears, how long it lingers, how many hand edits occur, and how fresh your machine images are. In its worked example the managed count is 1,512 against 1,840 resources in scope, a score that sounds strong, yet the Atlas insists on stating the leftover instead: 328 resources that no one reviews. Vanity figures, like tallying lines of code or modules, get a firm warning.
If your platform spans several providers, the same measures apply across all of them; a guide to multi-cloud data operations helps with thinking about where each environment’s responsibilities begin and end.
A sensible first month for a data team
- Week one: choose a remote backend with locking for state, so two people cannot write at once.
- Week two: run plans from CI on every proposal, with read-only credentials.
- Week three: route one real production change through the pipeline end to end.
- Week four: schedule a nightly drift run and decide who receives the result.
That mirrors the early stretch of the Atlas’s day-based rollout outline, which starts with a backend, CI plans and a first pipeline-applied production change.
Summary
InfraOps, as the Atlas uses it, is a lifecycle discipline: keep code, state and reality in agreement, make changes reviewable, and measure the gap honestly. For a data team the payoff is fewer surprises beneath the pipelines you already work hard to keep reliable.