
In 2026, the corporate VPN is still the default front door for most DevOps teams. A developer logs in from home, receives a flat route into the network, and can reach databases, Kubernetes control planes, staging environments, and production jump hosts. It worked when the network itself was the perimeter. It does not work anymore.
The problem is not encryption. It is trust. Once someone is inside the VPN, the network trusts them by default. A stolen session cookie, a reused password, or a forgotten service account becomes a free pass to production. For small and midsize businesses without a dedicated security team, one leaked credential is often a full-blown incident.
Why the Corporate VPN Is the Wrong Perimeter
VPNs grant broad access based on a single authentication event. After login, there is little differentiation between a junior developer and the person who owns production. SSH jump hosts make it worse: long-lived private keys sit on laptops, shared bastion accounts are common, and when someone leaves the company, key rotation is easy to forget.
Zero Trust flips the model. Access decisions are based on identity, device posture, and context — not on whether the user is inside the corporate network. Every request is authenticated, authorized, and encrypted individually.
Zero Trust for DevOps: Identity, Not Location
Start with an identity provider your team already uses — Google Workspace, Microsoft Entra ID, Okta, or similar. Every access request flows through OIDC, so there are no long-lived SSH keys to rotate and no shared bastion passwords to guard. Add device posture checks where possible, and issue short-lived tokens instead of permanent credentials.
Here is the legacy pattern most teams still rely on:
# Legacy: flat network, long-lived key, shared bastion
ssh -J jump.prod.example.com -i ~/.ssh/id_rsa [email protected]
Compare that with an identity-based flow: the developer authenticates through the IdP, receives a short-lived session, and connects only to the specific service they are authorized to reach. No open SSH port on the internet. No jump host to maintain.
Network segmentation matters too. Inside Kubernetes, a default-deny posture stops lateral movement even if an attacker lands inside the cluster:
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: prod-backend-zero-trust
spec:
podSelector:
matchLabels:
app: backend
env: production
policyTypes:
- Ingress
ingress:
- from:
- podSelector:
matchLabels:
app: frontend
env: production
ports:
- protocol: TCP
port: 8080
Reference Architecture for a Lean DevOps Team
You do not need an enterprise stack. A practical Zero Trust setup for an SMB DevOps team looks like this:
- Identity provider (Google Workspace, Entra ID, Okta) as the source of truth.
- Access proxy (Cloudflare Access, Tailscale, or Pomerium) sitting in front of internal tools.
- OIDC-based authentication for GitHub Actions, Terraform runs, and kubectl contexts.
- Security groups that accept traffic only from the Zero Trust overlay network, not from 0.0.0.0/0.
Infrastructure as code keeps the network policy explicit and reviewable. The following Terraform snippet allows SSH into the bastion only from the Zero Trust overlay range and blocks everything else:
resource "aws_security_group_rule" "prod_ssh_from_overlay" {
type = "ingress"
from_port = 22
to_port = 22
protocol = "tcp"
cidr_blocks = ["100.64.0.0/10"] # Zero Trust overlay network only
security_group_id = aws_security_group.bastion.id
description = "SSH only from Zero Trust overlay network"
}
resource "aws_security_group_rule" "deny_all_other_ingress" {
type = "ingress"
from_port = 0
to_port = 65535
protocol = "all"
cidr_blocks = ["0.0.0.0/0"]
security_group_id = aws_security_group.bastion.id
description = "Deny all other ingress"
}
Roll this out incrementally. Start with the tools that carry the most risk — production dashboards, cloud consoles, and database access — and leave internal wiki pages for last. Teams that try to flip every service to Zero Trust in a single migration usually stall after two weeks. Pick one service, measure the friction, and prove the model before expanding.
Just-in-Time Access to Production
Standing access is the enemy of Zero Trust. Nobody should have permanent production access. Instead, grant access for a fixed window — for example, four hours during an incident — and revoke it automatically.
A simple break-glass flow works well for small teams: an on-call engineer opens a ticket or posts in a Slack channel, a lead approves, and the access proxy grants temporary rights. Log the request, the approver, and the duration. When the window expires, access disappears without anyone remembering to revoke it.
Pair this with least-privilege RBAC inside Kubernetes and cloud IAM so that even after authentication, the user can only touch what the task requires.
Just-in-time access also changes incident response for the better. During an outage, the pressure to grant broad access is highest — which is exactly when discipline matters most. A time-boxed window with automatic expiry gives responders what they need without leaving standing access behind after the incident closes. Review every temporary grant in the post-incident review and ask whether the access was still needed once service was restored.
Audit Trails and the Compliance Payoff
One side effect of Zero Trust is that every access event leaves a trace. You know who connected, to what, when, and from which device. That is the same evidence auditors ask for during SOC 2 or ISO 27001 reviews.
Zero Trust also strengthens your other controls. Combine it with least-privilege Kubernetes RBAC, secure secrets management, and regular cloud misconfiguration scans, and you get defense in depth without hiring a large security team.
Read more on related controls: