Default-deny — the AuthorizationPolicy that fails closed
The Mesh Series · Article 16
AuthorizationPolicyNetwork policyIstioMicrosoft Entra IDSPIFFE

The Mesh Series · Article 16 · Where Entra meets Istio
Every workload you've built in this series now carries a verifiable identity — a SPIFFE certificate inward (Article 14), a federated Entra identity outward (Article 15). Identity was the hard part. Now comes the move it unlocks, the one zero-trust is actually named for: stop allowing traffic by default. Deny everything, then allow only the specific identities that have a reason to talk.
The reason this matters is a failure mode we've already met. Recall the open-access incident from Article 11: a workload reachable by anything, because nothing was configured to stop it, until infosec noticed. That's not a bug in a policy — it's the absence of one, and it's the signature of a default-allow world. In default-allow, the thing that happens when you forget to write a rule is that everything is permitted. The gap fails open.
Default-deny inverts that. When you forget to write a rule, nothing is permitted. The gap fails closed.

The baseline denies everything. Each thing that's allowed to reach the ledger is there because you named its identity, explicitly. Everything else — a service you didn't think about, a compromised pod, a new deployment nobody wrote a policy for yet — is denied by default, not by luck.
Why regulated enterprises should care
The whole argument is which direction your mistakes fail.
In a default-allow mesh, security is a list of things you remembered to forbid. The failures are silent and they accumulate: a workload nobody restricted, a namespace someone opened "temporarily," a service that quietly became reachable from the internet. You don't find these by looking at your policies — your policies look fine. You find them when infosec does, or when an attacker does. This is precisely the shape of the open-access finding: nothing was wrong in the config; something was missing, and missing failed open.
In a default-deny mesh, security is a list of things you explicitly permitted. A forgotten rule doesn't expose a workload — it breaks one, loudly, in your face, in testing, where you fix it. That's the trade every regulated framework wants you to make: RBI's zero-trust expectations, SAMA's maturity model, PCI-DSS's segmentation requirement between cardholder-data workloads and everything else. "Least privilege" and "segmentation" are not achievable in a world where the default is reach anything. They require that the default be reach nothing, and that every connection be an explicit, named, auditable exception. Default-deny is what makes "we can show you exactly which identities may talk to the cardholder-data services" a true sentence instead of an aspiration.
How the pieces come together
Istio makes the inversion mechanical, and there's one rule that surprises people.
An ALLOW policy is implicitly a deny-for-everything-else. The moment any ALLOW authorization policy selects a workload, that workload switches to deny-by-default: anything the policy doesn't explicitly permit is now refused. So a namespace-wide policy that allows nothing is your deny-all baseline — it denies every request in the namespace, and from there you add narrow allows on top.
Those allows are written against the identities you built: the SPIFFE principals from mTLS (Article 14), and — when a user is involved — the requestPrincipals from the Entra JWT (Article 10), composable in the same rule. Evaluation order matters and is worth memorising: CUSTOM (external authz) runs first, then DENY, then ALLOW. An explicit DENY always beats an ALLOW, so you can carve hard exclusions that no allow rule can accidentally re-open.
Show the config
The baseline is one policy, no rules, whole namespace — it allows nothing, so it denies everything. Then you poke exactly the holes you mean:

Now the property that makes this worth the effort: deploy a brand-new service into payments with no policy of its own, and it can reach nothing and be reached by nothing until you write its allow. The new workload fails closed. Compare that to the open-access incident, where a new workload was reachable until someone restricted it. Same missing rule, opposite outcome — because the default flipped.
Security · Audit · Integration
Security property gained. Least privilege by construction. The set of permitted connections is exactly the set you explicitly declared — no implicit reachability, no accidental exposure, no workload that's open because nobody closed it. Lateral movement from a compromised pod stops at the first identity boundary it isn't allowed to cross.
Audit evidence produced. Your allow policies are the segmentation documentation. "Show me which identities may reach the cardholder-data workloads" is answered by reading the policies, not by trusting that nothing was left open. That's the difference between asserting segmentation and evidencing it — exactly what PCI and SAMA ask for.
How it integrates. Default-deny is the frame every other Part-C control hangs in: it's written against the SPIFFE identities (Article 14) and composes with user principals (Article 10); it pairs with L3/L4 NetworkPolicy for belt-and-suspenders (Article 20); and it's the mesh-layer complement to admission control that guarantees the policy exists (Article 21). Identity made this possible; this is what identity was for.
Alternatives, and when you'd actually pick them
Default-allow with targeted denies. The status quo you're leaving. Occasionally defensible for a genuinely flat, low-stakes internal namespace — but it's the posture that produced the open-access finding, and it fails open every time you forget a rule. Don't bring it into anything regulated.
NetworkPolicy default-deny (L3/L4). Complementary, not alternative. A default-deny NetworkPolicy stops packets at the network layer — who can reach the pod at all — while the mesh policy governs what an authenticated identity may do at L7. You want both, and Article 20 is where they meet. NetworkPolicy alone can't express "identity X may POST /ledger"; mesh policy alone doesn't stop a raw connection from a pod outside the mesh.
Cilium / eBPF enforcement. Cilium can do identity-aware L3/L4 and some L7 at the kernel with eBPF, which is attractive when you're not running a full mesh or want enforcement below the proxy. The trade is a different identity model and less of the L7/JWT richness Istio's AuthorizationPolicy gives you. Reach for it when network-layer performance and a unified CNI matter more than mesh-native L7 identity.
The first namespace I flipped to default-deny, I flipped because infosec had already flagged it: everything could talk to everything, and nobody could produce a reason why. Default-deny closed the finding. What it also did — the part you don't plan for — is surface who had been quietly relying on that openness. Access that had never been scoped suddenly had to be named, and the reach that turned out to be wider than anyone intended, interns among the accounts, was pulled back to the restricted access it should have had all along. Deny-all doesn't just secure the namespace; it forces every permission that was ambient to become explicit, and that's where you find out what your cluster was actually allowing.
From the toy to the standard
The toy is a deny-all baseline and one allow on one namespace. The industry-standard version is default-deny everywhere, every permitted connection an explicit rule naming the workload identity (and, where a user is involved, the user principal), hard exclusions expressed as DENY that no allow can re-open, and the whole policy set doubling as living segmentation evidence. The system's reachability is exactly what you declared it to be — and a forgotten rule fails a deployment in testing instead of exposing a workload in production.
There's a thread we've left dangling since Article 10. The user's identity terminates at the edge and rides inward as context — but how, exactly, across three or four service hops? When the payment service calls the ledger on behalf of a signed-in user, does the ledger know who that user is, and how does it find out without the payment service just re-sending a raw bearer token?
That's Article 17: identity propagation across hops.
Next in the series — Article 17: Identity propagation across hops.
Key skills & topics in this article
AuthorizationPolicyNetwork policyIstioMicrosoft Entra IDSPIFFE
Also on LinkedIn.