Skip to content
On this page 7

Permission sets that survive an audit

Least privilege fails when people cannot do their jobs. Here is an identity model with read-only production and an access review that produces evidence.

A permission set is a named job — not a person and not a policy document. It is defined once in a single sign-on directory, assigned to a group in a specific account, and it produces a time-limited role when someone signs in. Get the set of jobs right and an access review takes an hour. Get it wrong and least privilege becomes a thing everybody agrees with and nobody practices.

An auditor asks four questions about access, in this order: who had it, when was it granted, when was it revoked, and who approved. An identity model that answers those from its own records is worth more than one that is theoretically tighter and has to be reconstructed by hand.

Why least privilege usually fails

#

Not because teams disagree with it. Because of how it gets implemented.

It is designed as a taxonomy instead of as a set of jobs. Someone enumerates services and builds policies per service. The result does not map to anything a person does on a Tuesday, so requests for access arrive constantly and get resolved by adding permissions to whichever role is nearest.

The exception becomes the default. An engineer is blocked during an incident, so they are given administrator access “temporarily.” The temporary grant has no expiry, and six months later it is the role they use every day. That single role is the most common finding in a real access review.

Revocation is a separate process from offboarding. Access was granted in three places, offboarding removes it from one, and nobody notices because the remaining two are not attached to anything that alerts.

The common fix for all three is the same: make the normal path the easy path, keep production write access out of human hands, and put the assignments in code so that granting and revoking are the same kind of event — a reviewed change with a date attached.

Eleven jobs, not fifty roles

#

Here is a concrete model. The AWS Enterprise Baseline uses IAM Identity Center with 12 permission sets and no IAM users anywhere in the organization. The names and numbers describe that edition; the shape is the part worth copying.

Permission setThe jobNon-productionProduction
PlatformAdminOwns the foundation: accounts, network, guardrailsFullWrite, as a named lead
PlatformEngineerBuilds and changes foundation codeFullRead-only
DevOpsAdminOwns pipelines and deployment pathsFullWrite, as a named lead
DevOpsEngineerOperates pipelines, investigates failuresFullRead-only
AppDeveloperBuilds and runs application workloadsWrite in dev and sandboxRead-only
DataEngineerBuilds data pipelines and storageWrite in dev and sandboxRead-only
AIEngineerBuilds and operates model workloadsWrite in dev and sandboxRead-only
ReadOnlyEveryone else who needs to lookRead-onlyRead-only
SecurityAuditorReads control configuration; denied dataRead-only, no dataRead-only, no data
LeadSecurityAuditorThe same, with the additional scope a lead needsRead-only, no dataRead-only, no data
BackupBreakGlassRecovers or repairs protected backups, one approved hour at a time—Backup account only
ManagementAdminAccessAdministers the organization itself—Management account only

Three design choices are doing the work in that table.

Production is read-only for everyone except the platform and DevOps leads. Not because engineers are not trusted, but because the supported way to change production is a pull request that a pipeline applies, gated on an environment approval. Human write access is the exception path, and an exception path that is used daily is not an exception.

Every set is assigned to a group, never to a person. Joining a team grants access; leaving removes it. There is no separate list to maintain, and the offboarding failure mode disappears because there is only one place to remove someone from.

The assignments live in code. Which means every grant is a pull request with a reviewer, a date and a reason — and your change-management evidence for access is generated as a by-product of granting access. That is the same argument we make about infrastructure changes in if deployment requires a hero, it isn’t automated.

The auditor role: configuration yes, data no

#

Auditors need to verify that controls are in place. That is a configuration question — is the bucket encrypted, does the database require TLS, did access reviews happen, is logging enabled and tamper-resistant. None of it requires reading a customer record.

So the auditor sets get a read-only role over control state with an explicit denial on data-plane reads. They can see that a storage bucket is encrypted; they cannot open the objects. They can see that a database enforces encryption in transit; they cannot query the rows.

This is a better deal for everyone involved. It is easier to grant, because nobody has to escalate it. It is easier to defend to your own customers, who increasingly ask who can see their data. And it makes the access review of your auditors a two-minute item instead of an argument.

Session duration, and the control that matters more

#

Twelve hours is a defensible session length: long enough for a working day plus an evening incident, short enough that a session left open on a laptop is not a standing grant.

The temptation is to shorten it aggressively. Resist it a little. A one-hour session in an organization where people work in four accounts produces about a dozen re-authentications a day, and the predictable result is someone scripting a credential cache into a file — which is precisely the thing the model exists to prevent.

The control that matters more than duration is that no long-lived credential exists anywhere. In this model, that is enforced rather than agreed: an organization-level policy denies creating IAM users and access keys, so “everyone signs in through single sign-on” stays true after the week somebody is in a hurry. The policy design is in service control policies that hold, and the equivalent for pipelines — which also hold no keys — is in zero long-lived cloud credentials.

Two more settings earn their place: an unused-access analyzer reporting at ninety days, so roles nobody assumes become visible, and multi-factor enforced at the identity provider rather than re-prompted per account.

Figure 1
Access paths into a production account

A person authenticates at the identity provider with multi-factor, assumes a permission set and receives a twelve-hour read-only session in the production account. A change reaches production through a reviewed pull request applied by a federated pipeline role gated on an environment approval. A dashed break-glass path runs from a sealed management account root credential and triggers a root-use alarm.

engineergroup memberidentity providermulti-factor12-hour sessionpermission setprod accounthumans: read-onlypipeline: applyroot use: alarmedpull requestreviewedpipeline rolefederated, no keysenvironment gatebreak-glasssealed root credentialrehearsed quarterly · alarms on use
Two paths into production and one that should almost never be used. People read; the pipeline writes, gated on an environment approval; break-glass runs through the management account root credential, which organization policies do not bound, and which raises an alarm the moment it is used.

Break-glass, and why it goes through the root account

#

Every identity model needs an answer to “what if the identity model is the thing that is broken.” Single sign-on has an outage, a policy change locks out the administrators, a federation misconfiguration takes the pipeline’s role with it.

The break-glass path is the management account’s root credential, and it works precisely because organization policies do not bound the management account. That is also why the management account runs no workloads: it is outside the boundary every other account lives inside.

Six properties make it safe to have:

  1. The credential is sealed — a physical hardware multi-factor device and a password, split so no single person holds both, stored where a documented procedure retrieves them.
  2. Using it is alarmed. Root usage is one of the CloudWatch alarms the AWS Enterprise Baseline ships, alongside alarms for unauthorized API calls, IAM policy changes, trail changes, console sign-in failures, bucket policy changes and network changes. Seven in total, in that edition.
  3. The procedure is written, including what may be done with it and what may not.
  4. Use is a declared incident, with a timeline and a review afterward, regardless of the outcome.
  5. It is rehearsed quarterly, because an emergency procedure nobody has performed is a hypothesis. The rehearsal is also the evidence that it works.
  6. Nothing else depends on it. It is not a convenience path for rare tasks; the moment it becomes one, the alarm on it becomes noise.

The quarterly access review that produces evidence

#

Most access reviews fail the audit not because access was wrong but because the review left no artifact. Run it so that the artifact falls out of the process.

Four inputs, all machine-generated:

InputWhat it tells you
Assignment export from the identity directoryWho is assigned to which permission set in which account, right now
Unused-access findings, at ninety daysWhich roles and permissions nobody has used, which is the fastest path to removal
Audit log of role assumptionsWhich roles are real, which are theater, and who is using the broad ones
Version control history of assignment changesEvery grant and revocation in the period, with reviewer and date

The meeting, in about an hour: walk the broad sets first — the admin tiers and anything with production write — then the unused findings, then the exceptions from last quarter to see whether they are still justified. Decide removals in the room and raise them as pull requests before it ends.

The artifact, which is the point: a dated record containing the assignment export as it was, the removals made, the exceptions retained with a named approver and a reason, and the sign-off. Store it where your evidence lives. When an auditor asks for the last four reviews, that is the answer, and it takes a minute rather than a week — the broader version of that argument is in SOC 2: what your infrastructure has to produce.

What this model does not fix

#

It does not stop a legitimate user doing something damaging with permissions they are supposed to have. That is a detection problem, not an identity problem, and it needs alerting and an incident process behind it.

It does not cover the identities that are not people: third-party integrations, vendor roles and anything with a long-lived credential that predates the policy. Those are usually where the real exposure is, and they deserve their own inventory with an owner and an expiry date per entry.

And it does not survive neglect. A permission model is only as good as the last review, which is why the quarterly cadence matters more than the elegance of the sets.

If you want to know where your current model stands, start with one query against the last ninety days of audit logs: list every identity that performed a write action in production, and mark the ones that were a pipeline. The names left over are your real identity model, whatever the documentation says.

If you would rather inherit a model that already has the 11 jobs, the production restriction, the auditor denial and the review procedure written down, that is part of what the BuiltForProd Baseline delivers into your own accounts — with the repositories handed over and no standing access kept afterward. The BuiltForProd Assessment measures what you have today against the BuiltForProd Standard, and the security page describes how identity, guardrails and evidence fit together.

Questions

What is a permission set?

A permission set is a named, reusable collection of permissions that a single sign-on directory assigns to a group inside a specific account. It produces a role in that account when someone signs in, so access is granted by group membership and time-limited session rather than by a standing identity with its own credential.

How many permission sets should an organization have?

One per job that people actually do, which is usually somewhere between eight and fifteen. The AWS Enterprise Baseline ships 11. Too few and everyone gets more access than they need; too many and nobody can review the model, which is its own kind of failure.

Should engineers have write access to production?

Almost never as a standing permission. If the supported way to change production is a reviewed pull request applied by a pipeline, then human write access is not the normal path — it is the exception path, and it should be limited to a small number of named leads and visible when used.

What access should an auditor be given?

A dedicated read-only role over control configuration, with an explicit denial on reading data. Auditors verify that a control is in place, which is a configuration question. Giving them data access expands your exposure without improving their evidence, and it makes your own customers a harder conversation.

How long should a cloud session last?

Long enough to do a day of work and short enough that a forgotten laptop is not a standing grant. Twelve hours is a defensible choice for a working day. The control that matters more than duration is that no long-lived credential exists at all, so revoking someone at the identity provider actually ends their access.

What does a quarterly access review need to produce?

A dated artifact: the full list of assignments at the time of review, the unused-access findings, the removals that resulted, the exceptions with a named approver and a reason, and the date it was completed. A review that leaves no record is work you did and cannot prove.

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.

Service control policies that hold

A guardrail works only if engineers cannot route around it. Here is how to design, exempt and test a service control policy before it blocks production.