Skip to content
On this page 7

Zero trust access for engineers

How people should reach production: federated sessions instead of users, no long-lived keys anywhere, and access that ends the day someone leaves.

Zero trust access means no person holds a standing credential to production. Engineers authenticate to an identity provider, receive a time-limited session scoped to one role in one account, and are authorized per request by policy. Being on the corporate network grants nothing. Being on the VPN grants nothing. The session is the access, and it expires.

This is one of the most oversold phrases in security and one of the most useful ideas underneath it. Stripped of the marketing, it is four properties, all of them testable, none of them requiring a product with the phrase in its name.

The four properties

#
  • No standing credentials. Nothing durable exists that authenticates a person to production. No cloud user, no access key in a laptop’s configuration file, no shared account password in a manager’s vault.
  • An identity per session. Every action traces to a named human through a session that was issued at a known time, for a known role, with an expiry.
  • Authorization per request. Permission is evaluated by policy at the moment of the call, against the role being used and the account it is used in. Not once at login, and never by location.
  • One revocation point. All of the above resolve to directory group membership, so removing a person from a group removes every path they had.

The last one is what makes the model operationally real rather than architecturally pleasing. Everything else can be defeated by one forgotten side door.

Federated sessions instead of cloud users

#

A cloud IAM user is a durable object that outlives the reason it was created. It carries durable credentials, it can have access keys attached, and it exists independently of whether its human still works here. Every organization that has run one for a few years has a handful whose purpose nobody remembers and which nobody dares delete.

Federation replaces that with a permission set: a reusable definition of a role that can be applied to many accounts at once. A person is placed in a directory group, the group is assigned a permission set in a set of accounts, and when they sign in they choose an account and a role and get a session. Four things improve at once.

Revocation becomes one action. Remove the group membership and every account it granted goes with it, immediately, with no per-account cleanup.

The grant becomes reviewable. “Who can write in production?” is a question about group membership, answerable from one place and exportable for an access review.

Multi-factor enforcement has one home. It is applied at the directory rather than configured per user in each account, which means it cannot be partially true.

The permissions are reusable. A ReadOnly permission set applied to fifteen accounts is one definition, so it cannot drift into fifteen slightly different versions of read-only.

Figure 1
Access paths resolving to a single directory identity

A person authenticates to the identity provider with multi-factor authentication and belongs to directory groups. Group membership grants three things: a permission set giving a time-limited role session in specific accounts, a VPN authorization rule granting routes for one environment, and an auditor role with read-only access and an explicit denial on data. Removing the group membership closes all three paths. Pipelines and workloads use their own federated identities and never a human’s credentials.

personMFA · directory groupidentity providerissues the sessionrole session · 12 hoursone account, one permission setVPN authorizationroutes for one environmentauditor roleread config · deny datapipelines and workloadstheir own federated identities · never a person’sremove the group membership → all three paths close
Every path resolves to one directory identity. The engineer's session, the VPN authorization and the auditor's read-only access are all granted by group membership, so removing the membership closes all three at once.

What the permission sets encode

#

The interesting content of an access model is not the mechanism; it is the opinions written into the roles. A useful set answers three questions before anyone asks them.

Who may change production? In the AWS Enterprise Baseline — the AWS edition of the BuiltForProd Baseline — production is read-only for everyone except the platform and DevOps leads. Not “should be”. Is. Application engineers, data engineers and AI engineers hold roles that read production and change non-production, and every change to production arrives through a reviewed pull request and a gated pipeline instead of through a console.

What may an auditor see? Auditors get their own roles with an explicit denial on reading customer data. They need to verify that a control is configured, which is a configuration question, and giving them data access expands exposure without improving their evidence.

How long is a session? Twelve hours in that edition: a working day, after which everybody reauthenticates. It is a compromise and worth naming as one. Shorter sessions are more defensible and more disruptive, because they expire during long operations. The property that matters is that sessions expire at all — a session that lasts a week is a credential with extra steps.

That edition ships twelve permission sets covering platform administration and engineering, DevOps administration and engineering, application, data and AI engineering, read-only access, two auditor roles, management account access and a one-hour break-glass set for the backup account. The count is less important than the shape: distinct roles, each with a job, rather than one admin role that everybody ends up in because it is the one that works.

No long-lived keys anywhere, enforced above the accounts

#

Removing the keys is not the hard part. Keeping them gone is, because a deadline will eventually make creating one feel reasonable.

Structure solves what discipline does not. A service control policy that denies the creation of cloud users and access keys, applied across the organization, means the property is enforced above every account rather than agreed inside each one. A second policy requiring multi-factor authentication for actions — with carve-outs only for service-linked and federated roles — makes the same point about how people authenticate.

That covers humans. The other two identities need the same treatment:

  • Pipelines federate per job rather than holding a key, which is the subject of zero long-lived cloud credentials. A deploy role trusts a specific repository, workflow and environment, and the credential expires with the job.
  • Workloads use a platform-native identity — a pod identity, an instance role — so the application holds a role, not a secret. Where an application needs a configuration secret, it reads it at runtime through that identity, which is where secrets management without a vault cluster picks up.

When all three are done, the sentence “no long-lived credential exists for anyone, human or machine” is true and testable rather than aspirational. An access key report with zero rows is the evidence; the policy denying creation is what keeps the report true next quarter.

The VPN grants routes, not trust

#

Private resources still need a network path, and a VPN is a reasonable way to provide one. The mistake is letting the connection be the authorization.

Two rules keep it honest. Authenticate against the same directory, through SAML, so a VPN session is the same identity as everything else and ends when that identity does — not a certificate on a laptop that nobody can revoke centrally. Authorize per group and per environment, so an authorization rule grants a specific group the routes for a specific environment. A connected developer reaches the development network and nothing else. Connection is not admission.

Split tunneling is worth the configuration: only traffic for private ranges goes over the tunnel, so the endpoint does not become an expensive general-purpose router for everybody’s video calls.

It also has an honest cost model, which is the reason it is a switch rather than a default. In the AWS Enterprise Baseline, Client VPN is built and switched off, with the price in the comment above the switch: roughly $80 to $440 a month depending on how many subnets are associated and how many people are connected, since the charges are per associated subnet per hour and per connection per hour. Capacity is on the order of a thousand concurrent sessions. For a team of twelve who need private access twice a week, a bastion pattern or the cloud provider’s session manager may be the better answer, and saying so is not a weakness of the design.

The leaver test

#

Here is the test that tells you whether any of this is real. Someone leaves today. Count the systems that must be touched, and ask how you would prove it was done.

Access pathGranted byEnds whenProvable by
Console and CLI sessionsDirectory group → permission setGroup membership is removedThe group’s membership list, exported
VPNDirectory group → authorization ruleThe same removalThe same list
Auditor accessDirectory group → auditor roleThe same removalThe same list
A personal access keyNothing central; it just existsSomeone remembers to delete itNothing, until an inventory finds it
A shared admin passwordA documentNever, in practiceNothing
A pipeline credential a person createdNothing centralSomeone remembersNothing

The top three rows are one action with one piece of evidence. The bottom three are a checklist that must be completed correctly, by a person, on a day when they are also doing other things. Every credential model is judged by how many bottom rows it has.

There is a related test for vendors, and it is worth applying to us as much as anyone: when an engagement ends, does the vendor retain any standing access? The right answer is that they had no separate access path in the first place — they worked through your directory groups, your pull requests and your pipelines — so removing the group membership is the whole of the offboarding. That is how BuiltForProd Managed works, and it is a question you should ask any vendor with production access.

Where to start this week

#
  1. Inventory the users and keys. Every cloud user, every access key, with a creation date and a last-used date. The old and unused ones are the finding; the actively used ones are the work.
  2. Pick the revocation point. If it is not your directory today, making it your directory is the highest-value change on this list.
  3. Write down who can change production. Then check whether the permissions agree. The gap between the two answers is the actual access model.
  4. Run the leaver test on paper, using the last person who left. Count the systems. Count the ones you could prove.
  5. Set a session length and an unused-access review. Identities unused for 90 days should surface automatically rather than being discovered during an audit.

If the inventory in step one takes longer than a day, that is itself the answer, and the BuiltForProd Assessment measures the estate against the BuiltForProd Standard and returns the ordered list of what to fix first. The foundation that makes the access model a property rather than a project is the BuiltForProd Baseline — deployed into your own accounts, with the repositories and the documentation handed to you, and no path left behind for us.

Questions

What does zero trust mean for engineer access to cloud accounts?

It means no one holds a standing credential to production. People authenticate to an identity provider, receive a session scoped to a role in one account for a limited time, and are authorized per request by policy rather than by being inside a network perimeter. Being on the VPN, or in the office, grants nothing on its own.

Why use identity center federation instead of cloud IAM users?

An IAM user is a durable object with durable credentials that exist independently of the person. Federation issues a temporary session tied to a directory identity, so access is granted by group membership and ends when that membership ends. It also gives you one place to enforce multi-factor authentication and one place to revoke.

How long should an engineer session last?

Long enough to do a day of work and short enough that a stolen session is not a durable foothold. Twelve hours suits a working day and forces reauthentication daily; shorter is defensible for high-privilege roles and is more disruptive than it sounds, since sessions expire in the middle of long operations. The important property is that sessions expire at all.

Does a VPN still have a place in a zero trust model?

Yes, as a network control for reaching private resources, not as a trust decision. The VPN should authenticate against the same identity provider and apply authorization rules per group, so a connected session can reach only the routes that group is entitled to in one environment. Treat connection as network access, never as authorization.

How do you prove access actually ended when someone left?

By showing that every access path resolved to one directory identity, and that removing it removed all of them: no cloud users, no personal access keys, no shared VPN certificates, no local database credentials. If any path is independent of the directory, offboarding becomes a checklist that someone has to complete correctly every time.

This is what we build.

BuiltForProd deploys a production foundation into your own cloud accounts, hands over the repositories and the documentation, and, if you want it, keeps running it with your team. Tell us what you are running and what is coming next. The first call is 30 minutes, with an engineer who scopes engagements, not a salesperson.

The calendar invite and the video link go to this address. Prefer to write? Send a message instead.