Skip to content
On this page 7

Multi-account strategy for enterprises

The account boundary is the first security control you get. Here is how to decide what deserves its own account, and how the structure survives growth.

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.

TestThe questionYes looks like
Blast radiusIf this were fully compromised, what else would I want untouched?A payments service next to an internal reporting tool
Data sensitivityDoes it hold data a different group of people may see?Customer records next to anonymized analytics
Regulatory scopeWould an auditor want a hard line around it?A cardholder data environment, a regulated workload
PeopleDo different humans need standing write access?A contractor-built integration, a third-party managed system
LifecycleDoes 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.
Figure 1
Deciding whether a workload needs its own account

A new workload is tested against five questions: different blast radius, different data sensitivity, different regulatory scope, different people with write access, and a different lifecycle. Any yes leads to a new account created from the account factory. All five no leads to placement in an existing account with its own role and namespace.

new workloadwhere does it go?the five testsblast radiusdata sensitivityregulatory scopepeople with write accesslifecycleany yes → its own accountnew accountfrom the factoryexisting accountown role, namespaceif this is a projectrather than a pull request,the answer will alwaysbe “existing account”
The account decision, in order. The five isolation tests are asked first; only workloads that fail all five are placed in an existing account. The final question is the one that decides whether the structure will keep growing.

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 accountAccount sprawl
What it looks likeEverything in one place, separated by tags and naming conventionsDozens of accounts, no two configured the same way
How it happenedIt was correct at five people, and nobody chose a date to change itAccounts created by hand, on request, with no template
The security symptomLeast privilege is a policy-writing exercise; every role is one wildcard from everythingNo policy applies uniformly; nobody can answer “is logging on everywhere”
The operational symptomQuota exhaustion in one workload throttles an unrelated oneNobody 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 listEvidence has to be gathered per account, by hand, every time
The remedyDraw boundaries from the five tests, move the cheapest workloads firstBuild 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-root sits 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. security and audit separate the systems that watch from the systems being watched, and put the log archive beyond the reach of a compromised workload. identity holds single sign-on. network holds the hub, address management and private DNS. dns, artifacts, auto, corp and public each isolate a capability that belongs to the organization rather than to a workload — with public existing so that “public” is a deliberate place rather than an accident somewhere else. backup holds locked copies of the workload accounts’ backups, beyond the reach of the accounts they came from.
  • Four workload accounts from one template. sandbox, dev, staging and prod differ 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.

  1. 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.
  2. 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.
  3. 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.
  4. Move stateful production last, and only once the previous three categories have moved without incident. Budget a migration window and rehearse the rollback.
  5. 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.

Questions

How many cloud accounts should an enterprise have?

Enough to separate the concerns that must not mix — organization management, security and audit, shared infrastructure, and each workload environment — and no more than you can create from a template. The count matters far less than whether adding the next account is a pull request or a project.

Should every team get its own cloud account?

Usually not. Team structure changes more often than architecture should, and an account per team produces sprawl without producing isolation. Give a team its own account when its blast radius, data sensitivity, regulatory scope or lifecycle genuinely differs from its neighbors, not because it is a different reporting line.

What is wrong with running everything in one cloud account?

Everything inside one account shares a permission surface, a quota pool, a network and an audit scope. A misconfiguration is contained by nothing, least privilege becomes a policy-writing exercise instead of a boundary, and the answer to "which systems hold regulated data" becomes a survey of tags rather than a list of accounts.

What causes account sprawl?

Creating accounts by hand. When each new account is configured manually, every account is slightly different, no policy applies uniformly, and nobody can say what is in the estate. Sprawl is a symptom of a missing account factory, not of having too many accounts.

How do you move from one account to many without a big migration?

Stop adding to the old account first: new workloads land in new accounts from day one. Then move the cheapest things — stateless services, build and artifact storage, non-production environments — and leave stateful production until the network, identity and logging paths are proven by the earlier moves.

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.

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.