Continuous posture and drift — proving the control is still holding
The Mesh Series · Article 28
Drift & posturePolicy as codeCompliance evidenceGitOpsLGTM stackAuthorizationPolicySAMAmTLS

You spent the last few articles turning written policy into enforced invariants. Admission control (Article 21) blocks the bad manifest at the door. Default-deny (Article 16) is the baseline. Signed evidence (Article 27) freezes the record so nobody can quietly edit it.
All of that is a photograph. It proves the control existed at the instant you took the picture.
An auditor is not asking for a photograph. An auditor is asking a question about time: was this control operating for the whole period, and if it stopped, when did it stop, for how long, and did you find out before I did? Enforcement doesn't answer that. Enforcement fires once, on the write, and then goes quiet. The gap between "the policy exists" and "the policy still holds, right now, this second" is where the audit finding lives.
That gap has a name. It's drift. And catching it is a different job from preventing it.

Enforcement is a gate. Posture is a pulse. This article is about the pulse.
Why continuous is the actual requirement, not a nice-to-have
Read the regulations for what they measure, not what they list.
Saudi Arabia's SAMA Cyber Security Framework does not grade you pass/fail on whether a control is present. It grades you on a maturity model — and the higher levels are explicitly about controls that are measured and operating continuously, not controls that were switched on the week before the assessment. A control you can only demonstrate as a current-state screenshot tops out low on that scale by design. The maturity model is a bet that anyone can turn a control on for an audit; what's hard is proving it never turned off.
India's regime says the same thing in a different accent. CERT-In wants incidents reported within six hours of noticing — which presumes you have something continuously watching that lets you notice. RBI's IT framework puts continuous control monitoring on the board's plate. The DPDP breach clock stacks on top. None of these are satisfied by "we have a PeerAuthentication resource." They're satisfied by "we can show mTLS was STRICT across this namespace for every hour of the quarter, and here is the one forty-minute window where it wasn't, the event that flagged it, and the ticket that closed it."
That last clause is the uncomfortable one. Continuous monitoring that only ever reports green is not evidence of a healthy system. It's evidence of a blind one. The forty-minute window is what makes the record credible.
And here's where Article 27 comes back to bite. A signed evidence pack proves the record is intact — nobody altered the bytes. It says nothing about whether the record is complete. Sign a stream of measurements from a probe that stopped reporting three weeks ago and you've produced a beautifully tamper-evident lie. Signing closes the integrity gap. Drift detection closes the completeness gap. You need both, and they are not the same control.
What enforcement structurally cannot see
Admission control feels like it should cover this. It doesn't, and the reasons are worth being precise about, because "just add more Gatekeeper constraints" is the wrong reflex.
A validating webhook fires on CREATE and UPDATE of the resources it's scoped to. That's its entire universe. Four things live outside it:
Resources that predate the policy. You install a constraint today. Everything already running was admitted yesterday, under the old rules, and the webhook will never see it again unless someone edits it. Your cluster is full of pods the gate never checked.
Out-of-band mutation. A controller reconciles a field back. Someone with break-glass access runs a kubectl edit. A bad merge to the GitOps repo ships a weaker policy and the pipeline applies it cleanly — admission says yes, because the manifest is valid, just wrong.
Deletion. This is the sharp one. Admission blocks bad writes to the resources you guard. But your zero-trust posture is a set of resources — the PeerAuthentication, the default-deny AuthorizationPolicy, the NetworkPolicy. Delete one of those and the cluster falls open. Nobody submits a manifest that says "please allow all traffic" for the webhook to reject. They just delete the object that was holding the line, and mTLS quietly drops to PERMISSIVE, and no webhook fires on the absence of a policy. The gate guards the room. It does not notice when someone removes the wall.
Semantic drift. The policy bytes are unchanged and the policy does nothing anyway. A namespace loses the label your AuthorizationPolicy selector matched on, so it now selects zero workloads. cert-manager stops renewing and the SVID the whole mesh trusts is days from expiry. The Entra JWKS endpoint the mesh validates tokens against moves, and your RequestAuthentication still exists while silently failing open. The manifest passes every review. The control is a ghost.
None of these produce a rejected admission request. Every one of them is drift. Which means the detector has to be a separate thing that periodically compares what you asked for against what is actually running — and treats a mismatch as an event, not an error to swallow.
The two engines you already have
You don't build a drift detector. You compose one out of parts that ship in the ecosystem, exactly as you composed enforcement in Article 21. The pattern is: one engine prevents at the write, a second engine audits what's already live.
Kubernetes itself is the archetype. The whole control plane is a reconciliation loop — declare desired state, and controllers drive actual state toward it, forever. Drift detection for compliance is that same loop pointed at your security primitives instead of your replica counts. That framing matters, because it tells you the compliance operator's job isn't novel plumbing. It's the reconcile loop you already trust, watching a different set of objects.
On the policy side, both admission engines have an audit half most teams never turn on:
Gatekeeper runs a periodic audit as a singleton, default auditInterval of 60 seconds, and writes what it finds straight into each constraint's status.violations — capped at constraintViolationsLimit, default 20. That audit pass is detective: it evaluates resources already in the cluster, including the ones that predate the constraint and the ones something mutated after admission. Admission is the doorman. Audit is the night watchman doing rounds.

Kyverno (1.18, CEL-native, graduated to a CNCF top-level project in March 2026) does the same through background scans that emit PolicyReport and ClusterPolicyReport objects — a continuously refreshed, queryable posture of every existing resource against every policy, not just the ones passing through admission right now.
The point of showing both: this is a composition decision, not a build decision. Your compliance plane consumes these reports. It doesn't reimplement policy evaluation.
Where the operator earns its keep is turning a detected delta into a signal you can prove later. A reconcile that finds drift should do two things, in this order: record the drift event, then correct it. Not the reverse.

The drift event goes to Loki as a discrete, identity-bearing record — this control, this namespace, this timestamp, this delta. The holding/drifted state goes to Mimir as a low-cardinality time series, because that's the shape SAMA's maturity model actually wants: a line you can render across an entire audit window that shows the control operating, with the outages visible as dips rather than smoothed away.

Keep the cardinality discipline from Article 25: identity belongs in Loki and Tempo, never in Mimir. The posture series answers "was the control holding," a question with no user in it. The moment you try to label it with who drifted it, you've detonated your metrics store and put an identifier somewhere it doesn't belong.
The contrarian bit: self-healing is a trap dressed as a feature
Here is where GitOps teams walk into a wall they built themselves.
Argo CD 3.3 will happily watch your cluster, mark anything that diverges from Git as OutOfSync, and — with selfHeal: true — revert it automatically. Flux does the equivalent. It's genuinely good engineering, and for a stateless workload it's exactly right: someone fat-fingered a replica count, the loop puts it back, nobody needs to care.
Apply that reflex to a compliance control and you've quietly built an evidence shredder.

Think about what silent auto-revert does to the audit narrative. Someone deletes the default-deny policy. For ninety seconds the cluster is open. Self-heal reverts it. Git shows no change. The dashboard is green. And you have destroyed the only evidence that the control was ever violated — the exact forty-minute-window-that-makes-the-record-credible, except now it never happened as far as any artifact is concerned.
The auditor's question is not "is the policy correct right now." You can show them that in the live cluster. Their question is "was it ever incorrect, when, and did you know." Self-healing without a drift ledger answers yes / never / no — which is the worst possible answer, because it's a lie the system tells confidently.
So the rule for regulated posture is not "don't self-heal." It's detect and record before you correct. The drift event is the evidence. The correction is the remediation. Log the first, then do the second, and now the same ninety-second window reads as "control violated at 04:11, detected at 04:11, auto-remediated at 04:13, evidence signed" — which is a maturity story, the thing SAMA is actually scoring.
I've watched the failure mode this guards against, in a plainer form. A development environment that was supposed to be isolated from production wasn't — dev workloads could reach the prod store, and they wrote corrupt data into it. No breach. No alarm. Because the one boundary everyone assumed was holding had silently stopped holding, and nothing behind it was watching for traffic that should never have existed. That's drift with no detector. The control didn't fail loudly. It failed the way controls actually fail: quietly, while every dashboard stayed green.
Have you had a specific security control — an mTLS mode, a default-deny policy, a network policy, a firewall rule — that got deleted, reverted, or silently stopped applying, and how long was it gone before anyone noticed? What finally surfaced it (an audit, an incident, a scan), rather than an alert firing at the moment it drifted?
Has automated remediation — Argo/Flux self-heal, an operator reconcile, an "it fixes itself" script — ever masked a real problem, so a recurring drift kept getting quietly reverted instead of investigated? Or is that a risk you've deliberately designed around?
Security · Audit · Integration
Security property gained. Detection of the four failure modes enforcement is blind to — pre-existing resources, out-of-band mutation, deletion of the guarding policy, and semantic drift where the resource exists but no longer does its job. Enforcement narrows the ways things get bad. Drift detection is how you learn they got bad anyway.
Audit evidence produced. A time series (Mimir) showing each control's posture across the whole assessment window, with outages visible as dips — the artifact SAMA's maturity model is grading. Plus discrete drift events (Loki) with control, timestamp, and delta, feeding the signed evidence pack from Article 27 so the completeness of the record is provable, not just its integrity.
Integration. The compliance operator watches the same Kubernetes and Istio APIs everything else in this series wrote to. It consumes Gatekeeper status.violations and Kyverno PolicyReport rather than re-evaluating policy. It emits to the same LGTM stack (Article 25). The drift event is one more input to the evidence pipeline — the pulse that turns a photograph into a film.
Alternatives, and when you'd reach for each
Argo CD / Flux self-heal. Best-in-class for GitOps drift where Git is the source of truth. Pick it as your reconcile engine — but pair it with drift recording, never let it revert silently on a compliance object.
Gatekeeper audit vs. Kyverno background scans. Same job, two ecosystems. If your enforcement is already Rego on Gatekeeper, use its audit and read status.violations. If you're on Kyverno's CEL-native policies, consume PolicyReport. Don't run both engines to get both audit halves; that's the rebuild-the-world tax Article 21 warned about.
Cloud Custodian. Strong for cloud-resource drift — an S3 bucket that went public, a security group that opened. Reach for it at the cloud-account layer, not inside the cluster; it doesn't see your mesh policies.
Fairwinds Polaris / Insights. Good best-practice and posture scanning with a compliance-dashboard bent. Pick it if you want opinionated checks out of the box and are willing to map its findings to your frameworks yourself.
Falco / Tetragon. Runtime, not config. They catch a process doing something it shouldn't right now (Article 24's eBPF layer), which is a different question from "does the declared control still match reality." Complementary, not a substitute.
The line that decides all of these: are you detecting drift in declared configuration (audit, reconcile, GitOps diff) or drift in runtime behavior (Falco, Tetragon)? Posture is the former. You want both eventually; don't confuse one for the other.
From the toy to the standard
The toy is one Gatekeeper constraint with auditInterval on, and you reading status.violations once a day. That's a real drift detector. It's also a manual, single-control, no-history version of the thing.
The standard is the loop closed all the way: a compliance operator reconciling the full ComplianceProfile — mTLS mode, default-deny, NetworkPolicies, egress rules, cert freshness — against live state on a fixed interval; every delta recorded as an event before it's corrected; posture written as a low-cardinality series retained for the framework's full window in-country (CERT-In's 180 days, SAMA and the KSA/UAE residency rules from Article 24); the whole stream feeding the signed packs from Article 27 so what you hand the auditor is provably both intact and complete. Enforcement stops the bad write. Reconciliation notices when the wall came down anyway. Signing proves you didn't edit the story afterward.
Next up (Article 29): we start mapping all of this onto a named framework, PCI-DSS 4.0, using the Quick Reference Guide — and you'll see that "detect and record configuration drift" isn't a nice-to-have there either. It's a requirement with a clause number.
A control that's enforced is not the same as a control that's still holding. Enforcement proves nothing bad got in. Drift proves what you promised is still true — and a policy that heals itself silently is a policy that lies to your auditor.
Key skills & topics in this article
Drift & posturePolicy as codeCompliance evidenceGitOpsLGTM stackAuthorizationPolicySAMAmTLS
Also on LinkedIn.