Mapping controls to frameworks — PCI-DSS 4.0 on the mesh
The Mesh Series · Article 29
PCI DSSAuthorizationPolicyCompliance evidenceDrift & posturemTLSPolicy as codeAudit loggingSupply-chain signing

A PCI requirement is not a mechanism. It is an objective. "Log and monitor all access to system components and cardholder data" tells you what has to be true, and says nothing about how. That gap — between the sentence in the standard and the primitive running on your cluster — is where compliance mapping lives. It is also where most of it goes to die.
You have spent the last nine articles building the how: mTLS, default-deny authorization, audit logging with identity on every line, signed evidence packs, drift detection. This article does one thing. It draws the arrows from those mechanisms to the clauses a Qualified Security Assessor will actually open in front of you — and, just as importantly, it marks the clauses the mesh does not touch, so you stop pretending otherwise.

The map above is the whole article in one picture. Read it as a claim you have to defend: for every requirement on the left, there is a primitive on the right you can point to, query, and hand an assessor as evidence — or there isn't, in which case the honest answer is "that control lives somewhere else."
Why this matters now, in both markets
Stop treating PCI DSS 4.0 as a thing on the horizon. It isn't. Version 4.0 was retired on 31 December 2024; 4.0.1 is the only version any assessor will validate against in 2026. Every one of the 51 future-dated requirements — the ones that were "best practice until 31 March 2025" — is now a formal, tested requirement with no grace period left. If your last assessment leaned on that grace period, this cycle it doesn't exist.
Three of those newly-mandatory clauses land squarely on the mesh: 8.4.2 now demands MFA for all access into the cardholder data environment (CDE) — not just administrative or remote access, which is where most institutions had drawn the line. 10.4.1.1 requires the daily log review to be performed by automated mechanisms, not a human squinting at a dashboard. And 10.7, now in scope for all entities, requires that failures of critical security controls are detected and responded to promptly — the control has to notice its own death.
For an enterprise institution processing cards in India or the Gulf, PCI is not one framework among several — it is the price of touching a PAN at all, and it stacks on everything else you already carry. RBI's payment-data localization keeps that cardholder data inside India; SAMA's maturity model wants proof the controls run continuously, not a screenshot from assessment week; NCA and CBUAE add in-country residency for financial data. PCI tells you what to prove about the CDE. The regional regulators tell you where the proof has to live and how often you have to show it. Same demo-to-audit gap, three jurisdictions deep.
And the req-1 test is not a document review. A competent assessor validating your segmentation opens a raw socket from a host in the general zone and tries to reach the CDE. If it connects, you fail — no matter what your network diagram says.
Where the mesh actually sits on the map
The mesh is a policy-enforcement point and an evidence source. That's the entire pitch. It covers a specific, contiguous band of the standard — the in-cluster technical controls over traffic and identity — and it covers that band well because every control in it is declarative and every action it takes is loggable. Here is the band, requirement by requirement.
Requirement 1 — network security controls and segmentation. This is the requirement people get wrong by reaching for the mesh alone. AuthorizationPolicy is an L7 control: it governs traffic the mesh can see. The assessor's segmentation test operates at L3/L4, and a pod outside the mesh sails straight through an L7 policy it never entered. So req 1 is a NetworkPolicy job first — default-deny at the namespace, CDE isolated as its own segment — with Istio egress (ServiceEntry, REGISTRY_ONLY) locking the outbound door that req 1 also cares about but nobody remembers to close. The mesh is the belt; NetworkPolicy is the suspenders; you wear both because they map to two different sentences the assessor will read.
Requirement 4.2 — strong cryptography in transit. PeerAuthentication set to STRICT gives you mutual TLS on every hop inside the cluster, with SPIFFE-identified, auto-rotated certificates you never touch. This is the cleanest mapping on the whole map: the requirement says "encrypt PAN over open networks," and the mesh makes every internal network open-by-assumption and encrypted-by-default. The subtlety worth naming to an assessor: mTLS proves confidentiality and peer identity, which is more than req 4 asks for and exactly what req 7 needs next.
Requirement 7 — access by business need-to-know. Default-deny AuthorizationPolicy, then allow narrowly, is req 7's least-privilege principle expressed as a cluster primitive. The mesh names which workload identity may call which service. Entra supplies the fine-grained half — app roles and scopes — so that "need to know" is a claim on a token, not a tribal memory. Deny-all, then watch what screams: the screaming is your undocumented access map becoming documented.
Requirement 8 — identify and authenticate. Two planes, one requirement. For users, Entra carries the identity and — post-8.4.2 — phishing-resistant MFA into the CDE via Conditional Access; passkeys and certificate-based auth are how you satisfy 8.5.1's "resist replay, cannot be bypassed." For workloads, federated identity gives each service a verifiable identity with no secret in config to steal. RequestAuthentication at the edge validates the Entra token; it rejects nothing on its own, so it always travels with an AuthorizationPolicy behind it.
Requirement 10 — log and monitor all access. This is the requirement the mesh was born to satisfy, and the mapping is almost literal — which is the subject of the next section.
Requirement 11.5 and 10.7 — detect change, detect control failure. A drift-detection loop (Gatekeeper's audit pass, or Kyverno's background scans) comparing desired state to actual is exactly the "change-detection mechanism" of 11.5.2 and the "detect failures of critical security controls" of 10.7 — pointed at your security posture instead of at arbitrary files. When someone deletes the default-deny policy, the loop is what notices the wall is gone.
That's six requirements — 1, 4, 7, 8, 10, 11 — with a clean line to a primitive. Now the honest part.
What the mesh does not do
A mapping that claims the mesh "does PCI" is the tell of someone who has never sat through a ROC. The mesh is silent on most of the standard, and saying so out loud is what makes the six requirements above credible.
Requirement 3 — protecting stored account data — is a database, Key Vault, and key-management problem; the mesh moves data, it doesn't store it. Requirement 5 — malware — lives below the mesh, at the node and runtime layer (this is Falco and Tetragon territory, not Envoy's). Requirements 6.4.3 and 11.6.1 — the e-skimming clauses that inventory and monitor every script on a payment page — are a browser-side concern the mesh cannot see; if a vendor tells you their service mesh covers payment-page script integrity, end the meeting. Requirement 9 is physical. Requirement 12 is policy, people, and third-party governance — paperwork the mesh will never generate.
The mesh does not make you compliant. It makes six of your requirements provable — turns them from a screenshot into a query — and it makes the honest gap list for the rest shorter and clearer. That is a smaller claim than the marketing wants, and a far more defensible one in front of an assessor.
Show the mapping: requirement 10.2.2 in YAML
The tightest mapping on the whole standard is req 10.2.2, which enumerates exactly what every audit-log record must contain. Put the clause and the config side by side and the arrow draws itself.
PCI DSS 4.0.1, Requirement 10.2.2 — each audit log record must capture: user identification, type of event, date and time, success or failure indication, origination of event, and the identity or name of the affected data, system component, resource, or service.
Now the Istio Telemetry access-log provider that emits precisely those fields, mTLS-proven, on every request the mesh sees:


Two things an assessor will appreciate that a hand-rolled logger cannot offer. First, peer_identity is a SPIFFE SAN pulled from the mTLS handshake — the caller's identity is cryptographically proven, not self-asserted in a header. Second, response_flags captures the RBAC denial, so your log records the access that was refused as well as the access that succeeded — req 10.2.1 wants both, and most application loggers only record what they served.
The application still logs the object — which PAN-adjacent record was read, under req 10.2.1.1 — because the mesh sees the call, not the row. The two logs stitch on trace_id. That's the division of labour req 10 quietly assumes: the mesh proves who called what, the service proves what they touched, and the trace id makes them one record.

Security · Audit · Integration
Security property. The band the mesh covers — 1, 4, 7, 8 — are all preventive: default-deny traffic, enforced mTLS, least-privilege authorization, authenticated identity. They stop the unauthorized access PCI exists to prevent, and enforce it uniformly instead of one service at a time.
Audit evidence. Requirements 10 and 11.5/10.7 are detective and evidential: the mesh emits a cryptographically-attributed record of every enforcement decision, and the drift loop emits a record of the control's own health — retained in-country, signed, tamper-evident. That record is the artifact you hand the QSA instead of a live demo.
Integration. This is the article where the previous nine stop being separate features and become one compliance surface. mTLS (Art. 14) is req 4. Default-deny (Art. 16) is req 7. Audit logging (Art. 24) is req 10.2. The LGTM store (Art. 25) is req 10.5 retention. Signed evidence (Art. 27) is req 10.5 protection-from-alteration. Drift (Art. 28) is req 11.5. The map is the integration story.
Alternatives, and where the mesh is the wrong tool
Policy packs that ship "PCI compliance." Kyverno and Gatekeeper both have community policy libraries labelled for PCI, and cloud-security platforms — Prisma Cloud, Wiz — map cloud configuration to PCI clauses out of the box. These are genuinely useful for the configuration half of the standard (is encryption enabled, are public buckets blocked). Pick these instead when the requirement is about resource posture rather than live traffic. They do not see a request in flight, so they cannot satisfy req 10.2's per-access record — that remains the mesh's job.
GRC and compliance-automation platforms — Vanta, Drata, and the like — manage the program: the evidence workflow, the control-owner attestations, the req-12 paperwork, the annual 12.5.2 scope confirmation. Pick these instead — alongside the mesh, not instead of it — for everything above the technical-control line. The mesh produces evidence; the GRC platform files it. Confusing the two is how you end up rebuilding a workflow tool you should have bought.
The build-it-yourself compliance operator. The temptation, once the map is this clean, is to write an operator that reads a ComplianceProfile CRD and emits the PCI mapping as signed evidence per control. That is the right destination — and it is the Mesh Compliance Plane's entire reason to exist — but only because it composes the primitives above (NetworkPolicy, PeerAuthentication, AuthorizationPolicy, Telemetry, the drift loop) rather than reimplementing them. The moment you find yourself rewriting Gatekeeper's audit pass or Envoy's access logger inside your operator, you have stopped building a compliance product and started rebuilding the mesh badly.
From a map to a compliance program
The toy version of this article is a spreadsheet: requirement in column A, primitive in column B, a link to the YAML in column C. That spreadsheet is worth building this week — it is the difference between "we use Istio" and "requirement 4.2 is satisfied by this PeerAuthentication, evidenced by this signed log stream, retained here." An assessor can follow the second sentence. The first one earns a follow-up question you don't want.
The industry-standard version turns that spreadsheet into code. Each mapping becomes a control the compliance operator continuously evaluates: is the PeerAuthentication still STRICT, is the default-deny policy still present, did the audit log stream stay unbroken across the window? Every evaluation feeds the signed evidence pack from Art. 27, and the drift loop from Art. 28 closes the completeness gap — proving not just that the control existed at assessment time, but that it held across the whole period. That continuity is what turns a PCI pass into something SAMA's maturity model will also accept.
Which is the next question. PCI is one framework. An institution in Mumbai or Riyadh answers to three or four at once, and they do not agree on where the data lives or how often you have to prove it. Next up: mapping the same primitives to RBI, SAMA, the UAE regulators, and ISO 27001 — one control surface, four frameworks, and the places they diverge.
If you're mapping controls to a mesh in a regulated environment, the honest gap list is worth more than the coverage claim. What has your assessor refused to accept as evidence?
Key skills & topics in this article
PCI DSSAuthorizationPolicyCompliance evidenceDrift & posturemTLSPolicy as codeAudit loggingSupply-chain signing
Also on LinkedIn.