A multi-account strategy is the set of written rules that decide which workloads get their own cloud account, what each account inherits, and what it costs to add the next one. It is not a diagram of the accounts you happen to have. Without the rules, an estate records the order in which things were built rather than the isolation the business actually requires.
The reason this is worth an argument early: the account boundary is the first security control you get, and the most expensive one to add later. Everything else — roles, security groups, policies — is a rule inside a boundary. The boundary itself is enforced by the provider, above all of them.
Why the account boundary is the first control
#A security group filters traffic inside an environment. An identity policy constrains a principal inside an account. Both are rules a sufficiently determined mistake can get around, because both are evaluated inside the thing being protected.
An account boundary is different in four specific ways:
- It is provider-enforced. Cross-account access has to be granted deliberately. There is no default path and no permission accidentally inherited from a policy written in a hurry.
- It fails safe. Compromise inside an account is contained by the account. Compromise inside a single shared account is contained by nothing except the attacker’s patience.
- It is the natural scope for everything else. Billing, service quotas, audit scope, log destination and blast radius all follow the account line without anyone maintaining a mapping.
- It survives your org chart. Teams reorganize every year or two. A boundary drawn around isolation requirements does not need to move when they do.
That last point is the one enterprises get wrong most often, and it is worth stating as a rule: accounts follow isolation requirements, not reporting lines.
What deserves its own account?
#Five tests. If the answer to any of them is yes, the workload has earned a boundary. If the answer to all five is no, it belongs in an existing account with its own namespace, role and tags.
| Test | The question | Yes looks like |
|---|---|---|
| Blast radius | If this were fully compromised, what else would I want untouched? | A payments service next to an internal reporting tool |
| Data sensitivity | Does it hold data a different group of people may see? | Customer records next to anonymized analytics |
| Regulatory scope | Would an auditor want a hard line around it? | A cardholder data environment, a regulated workload |
| People | Do different humans need standing write access? | A contractor-built integration, a third-party managed system |
| Lifecycle | Does it get created, changed or destroyed on a different clock? | Ephemeral experiments, a sandbox, an acquisition being absorbed |
And the tests that look convincing but are not:
- “It is a different team.” Teams change. If two teams’ workloads share a blast radius and a data class, they share an account and differ by role and namespace.
- “It is a different microservice.” An account per service is how a hundred-account estate happens without a hundred accounts’ worth of isolation.
- “We want separate billing.” Tags and cost allocation solve this. Do not spend a security boundary on an accounting preference — though if an account already exists for a real reason, the clean billing line is a genuine bonus.
The annotation on the right of that figure is the whole strategy in four lines. When creating an account is expensive, every decision resolves toward reuse, regardless of what the isolation tests say. The structure then stops growing at precisely the moment growth mattered.
The two failure modes
#Estates fail in opposite directions, and the remedies are opposite too.
| One large account | Account sprawl | |
|---|---|---|
| What it looks like | Everything in one place, separated by tags and naming conventions | Dozens of accounts, no two configured the same way |
| How it happened | It was correct at five people, and nobody chose a date to change it | Accounts created by hand, on request, with no template |
| The security symptom | Least privilege is a policy-writing exercise; every role is one wildcard from everything | No policy applies uniformly; nobody can answer “is logging on everywhere” |
| The operational symptom | Quota exhaustion in one workload throttles an unrelated one | Nobody knows who owns account 7; the credential in it is two years old |
| The audit symptom | “Which systems hold regulated data” is a survey, not a list | Evidence has to be gathered per account, by hand, every time |
| The remedy | Draw boundaries from the five tests, move the cheapest workloads first | Build the factory, re-derive every account from it, delete what nobody claims |
Notice that sprawl is not caused by having many accounts. It is caused by creating accounts by hand. An estate of forty accounts generated from one template is easier to reason about than an estate of six that were each set up by a different engineer on a different afternoon.
A worked example: 15 accounts, 2 organizational units
#A structure is easier to argue with than a principle, so here is a concrete one. The AWS Enterprise Baseline — the AWS edition of the BuiltForProd Baseline — deploys one organization with 15 accounts across 2 organizational units. The numbers describe that edition.
The layout is what the five tests produce when you apply them to an enterprise estate:
- The management account runs nothing.
core-rootsits outside both organizational units and owns only the organization itself: the account tree, the service control policies, the tag policy. It is empty because it is the one account that can change the rules every other account lives under. - Ten core accounts, one job each.
securityandauditseparate the systems that watch from the systems being watched, and put the log archive beyond the reach of a compromised workload.identityholds single sign-on.networkholds the hub, address management and private DNS.dns,artifacts,auto,corpandpubliceach isolate a capability that belongs to the organization rather than to a workload — withpublicexisting so that “public” is a deliberate place rather than an accident somewhere else.backupholds locked copies of the workload accounts’ backups, beyond the reach of the accounts they came from. - Four workload accounts from one template.
sandbox,dev,stagingandproddiffer in sizing, retention and who may act in them, not in structure. That is what makes “it works in staging” a meaningful sentence.
The per-account reasoning is laid out in the multi-account landing zone, explained, so it is not repeated here. What matters for strategy is the second column of that design: what each account inherits. In that edition, organizational-unit membership carries three service control policies — security guardrails, region restriction and audit protection — plus a tag policy, and the identity account carries 12 permission sets that define who may do what, with production read-only for everyone except the platform and DevOps leads. Those two mechanisms are what make the boundary mean something; they have their own posts, in service control policies that hold and permission sets that survive an audit.
How the structure absorbs growth
#An enterprise strategy is judged on the sixteenth account, the second region and the fourth acquisition. Three growth paths are worth designing for explicitly.
A new team. Most of the time the answer is not an account. It is a role and a namespace in an existing workload account, with cost allocation by tag. Reserve accounts for teams whose isolation requirements actually differ — the group handling regulated data, the group with contractors, the group whose experiments should never touch shared quota.
A new environment or stage. This should be a template instantiation. In the AWS Enterprise Baseline the four workload accounts come from a single definition, and adding another is a map entry and a folder: two pull requests, reviewed and applied by the same pipeline as everything else.
A new region. This is where estates usually discover their address plan was a spreadsheet. A region should be a folder, and the address allocation, the region-restriction policy and the tag policy should discover it rather than be edited for it. The AWS edition’s address plan is sized for 16 regions with 8 workload stages each, which makes expansion a decision rather than a redesign.
An acquisition. Two useful properties: an account you can enroll into the organization inherits your guardrails on day one, and an account you can isolate in its own organizational unit lets you apply a stricter policy set while it is being absorbed. Design for both, because you will use both.
Moving from one account to many
#If you are on a single account today, the wrong first move is a migration plan. The right first move is to stop making it worse.
- Freeze the old account for new work. Every new workload lands in a new account from day one, created from whatever factory you have, even if the factory is currently thin.
- Stand up the boundaries that do not require moving anything: a separate audit and log archive destination, single sign-on, and preventive policies at the organization level. These pay off immediately and independently.
- Move the cheap things first. Build infrastructure, artifact storage, non-production environments. Each one proves a network path, an identity path and a logging path before anything stateful depends on it.
- Move stateful production last, and only once the previous three categories have moved without incident. Budget a migration window and rehearse the rollback.
- Delete the old permissions as you go, not at the end. A migration that leaves the original account’s wildcard roles in place has moved the workload without moving the risk.
The whole sequence is slower than it sounds and cheaper than the alternative, which is restructuring during the quarter when something urgent is already happening.
What a multi-account strategy does not do
#It does not make your application secure; it makes the failure of your application survivable. It does not produce compliance, only the evidence sources that make an audit answerable. And it does not remove the need for people who understand it — it reduces what they have to hold in their heads and writes down the rest.
If you want a structure to inherit rather than design, the BuiltForProd Baseline is deployed into your own accounts with the repositories and documentation handed over, and no standing access retained afterward. If you would rather get an outside read on the estate you have — including which of the two failure modes you are currently in — that is the BuiltForProd Assessment, measured against the BuiltForProd Standard. Before either, run the five tests against your three most sensitive workloads. The boundaries usually draw themselves, and the ones that do not are the ones worth the argument.