A service control policy sets the maximum permissions available to every account beneath it in a cloud organization. It cannot grant anything. It can only bound what an identity policy is allowed to permit — which makes it the one control that an account administrator, or someone who has become one, cannot widen from inside the account.
That property is why preventive guardrails are worth designing carefully and why most of them fail. A guardrail is not a rule; it is a permanent constraint on people who have deadlines. If it blocks legitimate work, they will get an exemption, and the exemption is where the control quietly ends.
How guardrails actually fail
#Not by being bypassed. By being made irrelevant, in three predictable ways.
The account-shaped exemption. A policy blocks something a team genuinely needs, so their whole account is moved into an organizational unit where the policy is not attached. One legitimate need has now removed every unrelated protection from that account, permanently, and nobody revisits it.
The wildcard workaround. The policy breaks an automation role, and rather than diagnose the condition, someone creates a new role with a broad trust policy and a broad permission policy to “get the deploy working.” The guardrail is intact and the estate is less safe than before it existed.
The unreadable policy set. Twelve policies, each written by a different person during a different incident, none with a comment explaining what it prevents. Nobody can say what is denied without testing it, so nobody changes anything, so the set ages into folklore.
All three have the same root cause: the guardrail was designed as a prohibition rather than as a system with a defined escape hatch. A control that says no without saying “and here is the supported path” is a control that will be routed around.
Three policies, not thirty
#Start with consolidation, for two reasons.
The first is mechanical: there are quotas on how many policies may attach to an entity and on the size of each policy document, and inheritance means an account is subject to everything attached at every level above it. Check the current AWS quotas before you plan a structure around a number — they are revised — but plan as though the budget is tight, because it is.
The second is human. A policy set that cannot be read in one sitting will not be reviewed, and an unreviewed guardrail drifts from what the organization actually intends.
The AWS Enterprise Baseline attaches three, grouped by intent. The numbers and names describe that edition.
| Policy | What it denies | The exemption that keeps it usable | The failure it prevents |
|---|---|---|---|
| Security guardrails | Creating IAM users and long-lived access keys; removing S3 public access blocks; acting without multi-factor authentication | Service roles, single sign-on roles, and automation roles identified by tag | A standing credential that outlives the person, and a bucket that becomes public by accident |
| Region restriction | Every action outside the approved regions | Global services that have no regional endpoint | Resources created where nobody is looking, and an audit scope that is larger than the map |
| Audit protection | Stopping or deleting the organization trail and the configuration recorders | None; this one has no exemption by design | The first move of a competent intruder, and the erasure of your own evidence |
Alongside those sits a tag policy defining the six required tags, which ships report-only and becomes enforcing with a single flag. That sequencing is deliberate: a tag policy switched straight to enforcing breaks deploys on its first day, and the team learns that guardrails are hostile.
The patterns worth copying
#Deny by default, with a named exception list
#A region restriction is the clearest example of the pattern. You do not enumerate what is allowed; you deny everything outside the allowed set, and then name the global services that legitimately have no region:
{
"Effect": "Deny",
"NotAction": ["iam:*", "organizations:*", "route53:*", "support:*", "cloudfront:*"],
"Resource": "*",
"Condition": {
"StringNotEquals": {
"aws:RequestedRegion": ["us-west-2"]
}
}
}
The value of this shape is that a new service is denied until someone thinks about it, rather than allowed until someone notices. The cost is that the exception list is a living document — when a team adopts a genuinely global service, the policy needs a pull request. That is the correct amount of friction: visible, reviewed, and attached to a reason.
The multi-factor condition, and its exemption
#Denying actions performed without multi-factor authentication is one of the highest-value guardrails available, and one of the easiest to get wrong, because a naive version breaks every automated call in the organization.
Three exemptions make it workable, and they are exemptions to mechanisms, not to people:
- Service-linked and service principal calls, which are not human sessions and are outside the policy’s intent.
- Single sign-on roles, where multi-factor was already enforced at the identity provider before the session existed. Requiring it twice adds no security and removes all goodwill.
- Automation roles carrying a specific tag, so a pipeline role assumed through federation can act without a human present.
The third one is where the design either holds or collapses, and the reason is worth stating plainly: an exemption granted by a tag is only as strong as the control on who may apply that tag. If any account administrator can add it to a role, you have built a self-service exemption with extra steps. Restrict tagging that key to the platform role, in code, and review changes to it like any other policy change.
Protect the audit trail with no exemption at all
#Every other guardrail can have a supported escape hatch. This one should not.
Denying the actions that stop or delete the organization trail and the configuration recorders is what makes your audit log admissible as evidence rather than merely present. An auditor’s question is not “do you have logs” — it is “could the person you are testing have removed them.” The answer you want is that nobody in any account could, because the denial lives above every account.
Pair it with a log archive in a separate account that the logged systems cannot reach, and integrity validation on the trail so tampering is detectable rather than merely discouraged. We covered that full pattern in SOC 2: what your infrastructure has to produce.
Deny the credential, not the behavior
#The strongest version of “no long-lived keys in CI” is not a policy document or a lint rule. It is an organization-level denial of iam:CreateUser and iam:CreateAccessKey, so the credential that would leak cannot be created in the first place.
That guardrail only works if the supported alternative exists first. Federated pipeline identity has to be in place before the denial lands, or the first team to hit it will build something worse — the sequence and the trust policy details are in zero long-lived cloud credentials.
Where the policy sits in an evaluation
#Understanding the order removes most of the confusion about why something is denied.
Two consequences follow from that drawing and both matter operationally. An explicit denial at the organization boundary cannot be overridden by any policy inside the account, which is the entire point. And the management account is not bounded by the policies it attaches, which is the strongest argument for keeping it empty — a point we make structurally in multi-account strategy for enterprises.
How to test a policy before it blocks production
#There is no dry-run mode. The staged rollout is the test, and the discipline is what keeps it from being an incident.
- Write the denial and its exemptions, with a comment saying what it prevents. If the comment is hard to write, the policy is not ready.
- Query the audit log for the actions you are about to deny, over at least ninety days. You are looking for which principals performed them and whether the exemptions cover all of them. This step finds the forgotten nightly job every time.
- Attach to a sandbox organizational unit first. Let it run for a week with real work happening in it.
- Attach to non-production. Watch specifically for access-denied events, which name the organization policy as the cause and are therefore easy to distinguish from ordinary permission errors.
- Alert on denials caused by the policy for the duration of the rollout, routed to the team doing the rollout rather than to a general channel. A guardrail rollout without visibility is a guessing game.
- Attach to production last, on a day when the people who wrote it are available and nothing else is shipping.
- Keep the rollback to a single reverted commit. If backing a policy out requires a console session and a calm head, it will not happen quickly enough.
The part guardrails cannot do
#Preventive policy is a boundary, not a strategy. It stops categories of mistake; it does not decide who should have access, and it does not notice a permitted action being used badly. That work belongs to the identity model — the subject of permission sets that survive an audit — and to detection, which is a different apparatus with different alerting.
Guardrails also do not survive being written once. A policy set is a living document, reviewed when the estate changes shape: a new region, a new regulated workload, a new automation path. Put it in the same repository, under the same review rules, as everything else.
If you want the whole preventive layer to arrive already designed, tested and documented, that is part of what the BuiltForProd Baseline delivers into your own accounts, with the code handed over and no standing access retained — see the security page for how the pieces fit. If you would rather start by finding out what your current guardrails would actually stop, run step two of the rollout above against your own audit log this week. It is free, it takes an afternoon, and what it returns is usually the most interesting security document your team will read this quarter.