Start With Sign-In in the App

If you run one public app with its own sign-in and no internal network behind it, there is no network trust to remove. Zero trust matters once there is an inside: a VPN, internal services, and a habit of trusting whatever is already on the network.

In the 2021 Colonial Pipeline attack, according to the company's own testimony, the way in was a legacy VPN account protected only by a password. Once on the VPN, a valid credential was trusted. Plenty of companies still work this way: one phished password, and every internal app is reachable.

Zero trust removes that bonus trust. Every request proves who is asking, from what device, for which app, and each app has its own least-privilege rule. It is an architecture you migrate to one app at a time, not a product you buy. Below are the NIST SP 800-207 principles, the building blocks, and a migration order that works.

If the VPN is your main defence
  • Your internal services run on HTTP because they're “behind the firewall”
  • The VPN is the only thing between an attacker and your databases
  • Production credentials live in environment variables on bastion hosts
  • Anyone in the office subnet can reach the staging database

NIST SP 800-207 and the BeyondCorp papers map cleanly onto modern cloud primitives. You don't need to buy a Zero Trust appliance — you need identity, mTLS, and policy enforcement at every hop.

Five Core Principles (a Subset of NIST 800-207's Seven Tenets)

  1. All data sources and computing services are resources.
  2. All communication is secured, regardless of network location.
  3. Access is granted on a per-session basis.
  4. Access is determined by dynamic policy — identity, device, behavior.
  5. The enterprise monitors and measures the integrity of all owned assets.

The Reference Architecture


flowchart LR
    U[User / Workload] -->|request| PEP["Policy Enforcement Point<br/>(gateway, sidecar, proxy)"]
    PEP -->|evaluate| PDP["Policy Decision Point<br/>(OPA, Cedar, IAM)"]
    PDP -.->|inputs| ID[Identity Provider]
    PDP -.->|inputs| DEV[Device Trust]
    PDP -.->|inputs| RISK["Risk Signals<br/>(IP, behavior, MFA)"]
    PEP -->|allow + scoped token| R[Resource]
      

Every request flows through a Policy Enforcement Point (PEP) — could be Envoy, an API gateway, a service mesh sidecar, or application middleware. The PEP asks a Policy Decision Point (PDP) — OPA, Cedar, IAM — using identity, device, and risk inputs.

Identity-Centric, Not Network-Centric

In a Zero Trust system, the IP address is metadata, not authorization. The principal identity carries through every hop: user via OIDC, workload via SPIFFE/SPIRE, device via certificate. Every request is signed in some form.

# SPIFFE identity for a workload — used by Istio, Linkerd, mTLS gateways
spiffe://prod.example/ns/payments/sa/processor

# The cert presented by every payments-processor pod includes this URI in SAN
# Other services authorize on the SPIFFE ID, never on IP / hostname / port
✅

Check it: Pick two internal services and capture a call between them. It should be encrypted, and the receiver should know which workload is calling.

Microsegmentation

Default-deny between every workload pair. Only explicit allow rules let traffic through. Kubernetes NetworkPolicy, AWS security groups scoped per service, Azure NSG + Application Security Groups, or a service mesh with mTLS + authorization policies.

# Kubernetes NetworkPolicy — orders pod can only call payments
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata: { name: orders-egress, namespace: prod }
spec:
  podSelector: { matchLabels: { app: orders } }
  policyTypes: [Egress]
  egress:
    - to:
        - podSelector: { matchLabels: { app: payments } }
      ports: [{ protocol: TCP, port: 8443 }]
    - to:
        - namespaceSelector: { matchLabels: { kubernetes.io/metadata.name: kube-system } }
          podSelector: { matchLabels: { k8s-app: kube-dns } } # match your cluster's DNS pods
      ports: [{ port: 53, protocol: UDP }, { port: 53, protocol: TCP }]
✅

Check it: From a pod or machine with no business reason to reach the database, try to connect. It should be refused.

Continuous Verification

Authentication isn't a one-time event. Token lifetimes are short (5–15 min); refresh requires re-evaluating risk. With conditional access configured, an IP change to another country mid-session can trigger step-up auth, and degraded device posture (root detected, MDM beacon lost) can block the next refresh. None of that happens by itself: a JWT already issued stays valid until it expires unless your services check for revocation.

✅

Check it: Look up your access token lifetime, and what is checked again at refresh. Then ask whether a token that is already issued can be cut off.

BeyondCorp — The Pragmatic Implementation

Google's BeyondCorp ditched the VPN entirely. Every internal app sits behind an identity-aware proxy. The user authenticates with their Google identity + device certificate. The proxy enforces per-app, per-user policy. No network membership grants trust.

Cloud equivalents: Google IAP, Cloudflare Access, AWS Verified Access,Microsoft Entra Private Access. All implement the same shape: identity-aware reverse proxy in front of every internal app.

✅

Check it: Try to open one internal app from an unmanaged device that is on the VPN. Being on the network shouldn't be enough to get in.

Cloud Zero Trust Building Blocks (2026)

ConcernAWSAzureGCP
Workload identityIAM Roles for Service Accounts (IRSA)Workload Identity FederationWorkload Identity
Identity-aware proxyVerified AccessEntra Private AccessIAP
Service mesh mTLSIstio on EKS (App Mesh is retiring — AWS cut off new onboarding in 2024 and shuts it down Sept 2026; migrate to VPC Lattice or Istio)Istio / Linkerd on AKSCloud Service Mesh (formerly Anthos Service Mesh)
Per-request policyCedar / IAMAzure RBAC + ABACIAM Conditions

A Migration Order That Works

  1. Inventory and identity baseline. Every workload gets a stable identity (managed identity, IRSA, SPIFFE). Every user has MFA and a managed device.
  2. mTLS everywhere. Deploy a service mesh or sidecar proxies; default-deny without a valid client cert.
  3. Identity-aware proxy in front of internal apps; retire the VPN one app at a time.
  4. Microsegmentation: NetworkPolicy + per-service security groups, default-deny.
  5. Policy as code: OPA / Cedar bundles, peer-reviewed, deployed via CI.
  6. Continuous monitoring: behavioral baselines, alerting on policy denies, regular access reviews.

Pitfalls

Buying a “Zero Trust Platform” without changing how you build

Tools enforce policies; they don't write them. If apps still trust the network because “the firewall handles auth”, the appliance you bought is a $200k VPN replacement, nothing more.

Identity inconsistency between humans and workloads

Humans get OIDC, workloads get long-lived API keys in environment variables. That asymmetry is where the next breach starts. Use workload identity federation so services authenticate to clouds and to each other without static credentials.

Policy sprawl with no review

Three years in, you can have thousands of IAM policies and nobody knows which are still needed. Tag every policy with an owner and a review date; auto-flag stale ones. Access reviews quarterly, minimum.

Try It on Your Own System This Week

Three checks on your own estate, about an hour in total:

  1. Count the long-lived API keys your services hold. Each one is a candidate for workload identity.
  2. Pick ten access policies and find their owners. A policy with no owner and no review date is probably stale.
  3. Check how your admins sign in. Phishing-resistant authentication should be mandatory for them.

Non-Human Identities and Agents

Zero trust was designed mostly around people and their devices. In most companies today, non-human identities outnumber people by a wide margin: service accounts, CI jobs, API keys and now AI agents. These identities are often over-privileged and rarely reviewed, and they have no MFA to fall back on.

Apply the same principles to them. Each workload should have its own verifiable identity, rather than a shared key. SPIFFE gives workloads short-lived, automatically rotated identity documents, and cloud managed identities do the same job within one provider. A credential that expires in an hour is far less dangerous than one that lives forever in a config file.

What agents change

An AI agent is a strange kind of principal, as it decides what to do at runtime, and its behaviour can be changed by what it reads. That breaks an assumption behind most access control, namely that a principal's intent is fixed. So add a few rules for agents:

  • Give every agent its own identity, never a shared service account, so that logs can tell agents apart.
  • Prefer delegated access, so that an agent acts with the user's permissions rather than its own broad ones.
  • Scope credentials to the task, and let them expire when the task ends.
  • Authorise each tool call at runtime, because a session that was safe at the start may have read something hostile since.

That last point is the essence of zero trust: never trust, always verify. It fits agents better than it fits people. OWASP's Agentic Top 10 covers the specific risks.

Protecting the management plane

Attackers increasingly go after identity systems themselves, stealing session tokens and tricking help desks into resetting MFA. Phishing-resistant authentication such as passkeys or FIDO2 keys closes the biggest hole, and it should be mandatory for admins. Use conditional access that takes device health into account, and just-in-time elevation, so that nobody holds standing admin rights. Audit who can change your identity provider's configuration, as that's the keys to everything.

Start small

Don't try to do this all at once. Pick one critical application, put it behind identity-aware access, and remove the network path that bypassed it. Then move to the next. Measure what's actually changed, such as the percentage of apps behind the policy engine, or standing admin accounts removed. Zero trust is a direction you keep moving in, so measure progress rather than waiting for a finished state.