Most first encounters with GitOps go the same way: the demo is flawless, the pilot is smooth, and then week three produces a surprise that a ten-minute briefing would have prevented. The surprises are remarkably consistent across teams, which makes them teachable in advance. They cluster around a handful of misconceptions — that the model is about speed, that the webhook is essential, that branches are a neutral choice, that the tool replaces judgement. What follows are the eight facts worth internalising before your first production sync — each one precise, each one drawn from current practice as documented in this GitOps reference guide, and each one cheaper to learn here than in an incident. Where a fact has a number attached, the number is quoted so you can put it in a design document verbatim.
The Eight GitOps Facts, Ordered by Surprise Value
- Reconciliation never stops, and it is not meant to be instant. A reconciler compares the repository with the cluster on a loop — a poll every three minutes fully qualifies as GitOps. You are buying a system that converges forever, not a fast pipeline. Teams that expect sub-second deploys misread the product; teams that expect eventual correctness get exactly that.
- A webhook is a convenience, not the mechanism. Argo CD polls at approximately 120-second intervals, jittered by as much as 60 seconds on purpose; Flux follows whatever cadence its configuration sets. A webhook merely invites an earlier pull. Because the endpoint has no rate limiting, give it a shared secret — and sleep well knowing the poll continues even if the webhook breaks.
- Environments are directories, not branches. Branch-per-environment hides the differences between staging and production inside merge commits nobody can read. A layout of clusters, infrastructure, tenants and applications as folders makes every difference a visible line in a diff, and promotion becomes a reviewed copy between directories. Teams that migrate from branches report the same discovery within a week: they had been shipping configurations they could not see.
- Promote by digest, and change one value per overlay. The artefact that passed staging — that exact, checksummed build — is what production should receive, not a floating tag that might resolve differently overnight. And when an overlay carries a single value change, reviewers approve one intention at a time. Both habits sound pedantic until the first “how did that get to production?” meeting. Render in CI, attach the rendered output to the review, and let approvers read results rather than templates.
- Mutable references undo the whole model. A moving image tag, an unpinned chart, a remote base tracked to a branch head: each means the repository no longer states what runs. Immutability is not aesthetic purism; it is what makes the declaration trustworthy enough to automate against.
- Continuous integration is not replaced. Building, testing and scanning stay exactly where they are. The pull-based model takes over the deploy step alone — which is why a CI job that runs kubectl apply satisfies, at best, two of the four OpenGitOps principles. “We already have CI” and “we should adopt GitOps” are not competing sentences; the second begins where the first ends.
- Self-healing can fight your incident responders. At 3 a.m., an agent that reverts the emergency console fix is technically correct and practically harmful. Suspension is a first-class operation in both major tools; rehearse the break-glass path before the night it is needed, and write into the runbook who may pull the lever and what gets reconciled back afterwards.
- Git history is not a complete audit log. The repository records intent — what was merged, when, and by whom. It stays silent on the reconciler’s behaviour: what it applied, what it corrected, what failed. Argo CD’s documentation makes the point itself; complete evidence needs reconciler events alongside commit history. Teams that learn this during an audit have learned it late.
A Study Path That Exercises Every Fact
Reading the list is preparation; touching the tools is learning. A compact path for learners: stand up a throwaway cluster, install one reconciler, and deliberately trigger each fact. Break the webhook secret and watch polling carry on. Hand-edit a resource with self-healing enabled and watch it revert. Move an environment from a branch to a directory and read the resulting diff. Pin an image by digest and then try to fool the system with latest. Suspend an application mid-incident and resume it. Delete a file and watch what pruning wants to do before you ever allow it near production. An afternoon spent this way converts eight facts into muscle memory — and gives you demo material for interviews that no slide deck matches. Beginners who want the surrounding vocabulary in one place will find the ultimate DevOps glossary of fifty essential terms a useful companion to this list.
What Good Looks Like on a GitOps Dashboard
Facts become feedback once they are measured, and the reference labs publish a useful baseline for what healthy looks like. One tracked week put the median merge-to-healthy interval near 3.75 minutes; the 90th percentile stretched to twenty-six, with heavyweight renders doing most of the stretching. The same week recorded an apply failure rate of twenty percent, which settles into perspective once you see failures surface immediately instead of at runtime. Most instructive is the drift arithmetic: across the week, applications spent 1.12 percent of their running time disagreeing with the repository, and two drift events accounted for ninety-four percent of that total. Four of six drifts were reverted by teams; four of five out-of-band changes turned out to be unticketed. Read those last two numbers together and you have the strongest argument for the whole practice: the deviation you cannot see is the one that hurts you. A dashboard that shows alignment percentage, drift events and revert counts turns the eight facts above from doctrine into a weekly scorecard your team actually argues about — which is the polite word for learns from.
The Objections, and the Short Answers
Every adoption meeting produces the same three worries, and each has a considered answer. “This removes human control” — no, it moves control upstream to the merge, where attention is cheap and decisions are reversible before they are real. “The agent will break production” — it acts only within the authority you grant it, which is why least-privilege configuration belongs to setup rather than being an optional refinement. “Our auditors will not accept a robot” — auditors accept evidence, and a reconciler emits more consistent evidence than any manually maintained change log ever has. Culture, not tooling, decides whether these answers land; the practical guidance in DevOps and culture change management applies almost word for word to GitOps adoptions.
One last framing for sceptical stakeholders, because it connects this to work they already value. Reliable delivery is a customer promise: fewer failed releases and faster recovery show up directly in user experience, the same chain documented in DevOps and customer experience. GitOps is simply the strictest form of that promise — the repository states the intent, the machine keeps the promise, and the evidence accumulates on its own. Teams that internalise the eight facts above reach that state without the week-three surprises, and their first sync is as boring as it should be.









