Skip to content
On this page 8

The multi-account landing zone, explained

Account boundaries are the first security control you get and the hardest to add later. Here is what each account in a landing zone is for, and why.

A landing zone is the account structure, identity model, network topology, logging pipeline and guardrails that everything else in a cloud organization is built on top of. It is the layer no workload owns and every workload inherits. Get it right and most security and compliance questions have boring answers. Get it wrong and every subsequent decision is made inside a constraint nobody chose.

The reason it matters more than it looks is simple: the account boundary is the strongest isolation a cloud provider gives you. A security group is a rule inside an environment. An IAM policy is a rule inside an account. An account boundary is enforced above both, by the provider, and it holds even when the thing inside it is compromised. It is also the boundary that billing, quotas, audit scope and blast radius all happen to follow.

Why account structure is a security control

#

Most teams arrive at the multi-account question from the wrong direction. They start with one account because one account is simple, add a second when production and development collide, and end up with a structure that records their history rather than their requirements.

Three properties make the account boundary different from anything inside it:

  • It is enforced by the provider. Cross-account access has to be granted explicitly. There is no default path, no shared network, no accidental permission inherited from a policy someone wrote in a hurry.
  • It is the natural audit scope. “Which systems handle regulated data” becomes a list of accounts instead of a survey of tags.
  • It fails safe. A misconfiguration inside an account is contained by the account. A misconfiguration in a single shared account is contained by nothing.

The trade-off is real: more accounts mean more automation is required, because manual management does not scale past about three. That is the actual decision. Not “how many accounts” but “are we willing to automate the boundary we need”.

A worked example: 15 accounts, 2 organizational units

#

Abstract advice about landing zones is easy to agree with and hard to use. So here is a concrete one. The AWS Enterprise Baseline — the AWS edition of the BuiltForProd Baseline — deploys one AWS Organization with 15 accounts across 2 organizational units. The numbers below describe that edition specifically.

Figure 1
A 15-account organization in two organizational units

A management account sits at the top, outside both organizational units. Below it, the core organizational unit holds ten accounts: security, audit, identity, network, dns, artifacts, auto, corp, public and backup. The plat organizational unit holds four workload accounts: sandbox, dev, staging and prod.

core-rootmanagement accountempty by designcoresecurityauditidentitynetworkdnsartifactsautocorppublicbackupplatsandboxdevstagingprodone template, four environments
The AWS Enterprise Baseline: an empty management account outside the organizational units, ten core accounts that provide shared capabilities, and four workload accounts generated from one template.

The management account is empty

#

core-root sits outside both organizational units and runs nothing. It exists to own the organization: the account tree, the service control policies, the tag policy. That is all.

This is the decision in the layout that pays back the most for the least effort. The management account is the one account that can change the rules everything else lives under. If a workload runs there, then compromising that workload means compromising the guardrails, and every other control in the organization is downstream of a thing an attacker now owns. Keeping it empty is not fastidiousness. It removes an entire class of incident.

Ten core accounts, each with one job

#
AccountWhat lives thereWhy it is separate
securityDelegated administration for the security services, and the observability sinkThe account that watches everything should not be an account that runs anything
auditThe log archive and the configuration aggregatorEvidence must survive a compromise of the thing it is evidence about
identityThe single sign-on directory and permission setsOne place to grant and, more importantly, revoke
networkThe hub network, address management, private DNSNetwork topology is shared infrastructure, not a workload concern
dnsPublic DNS zonesPublic name resolution has a different risk profile from private
artifactsContainer registriesBuild outputs are shared across environments and outlive any one of them
autoCI/CD federation, deployer roles, runnersThe automation identity is a high-value target; it gets its own boundary
corpInternal toolingEmployee-facing systems are not customer-facing systems
publicAssets that are deliberately publicMaking “public” an explicit place stops it becoming an accident elsewhere
backupLocked copies of the workload accounts’ backupsA copy that the source account can delete is not a backup; this one survives the loss of the account it came from

The pattern is the same in every row: a capability that belongs to the organization rather than to a workload gets its own boundary, so that granting access to it is a deliberate act.

Four workload accounts from one template

#

sandbox, dev, staging and prod are generated from a single definition. They differ in sizing, retention and who may act in them — not in structure. That is what makes “it works in staging” a meaningful sentence: staging and production are the same code with different inputs, so a difference between them is a bug rather than a fact of life.

Prod is also where the network stops being permissive. In this edition, the transit gateway carries deliberate blackhole routes between the production and non-production isolation domains: they cannot reach each other, by construction rather than by firewall rule.

The test: what does adding an account cost?

#

A landing zone is healthy when growth is cheap. The question to ask about any structure — yours or a vendor’s — is not how many accounts it has today. It is what happens when you need the sixteenth.

In the AWS Enterprise Baseline, a new account is an entry in a map and a folder in a repository: two pull requests, reviewed and applied by the same pipeline as everything else. The same property holds for regions. A region is a folder; the address plan, the region-restriction policy and the tag policy discover it automatically. The address plan itself is sized for 16 regions with 8 workload stages each, so expansion is a decision rather than a redesign.

When adding an account is a project, three things follow, and they follow every time: teams share accounts they should not share, environments diverge because nobody wants to touch the structure, and the eventual restructure lands during the quarter when something urgent is already happening.

What a landing zone does not solve

#

Being honest about the boundary of the idea:

  • It does not make your application secure. It makes the failure of your application survivable.
  • It does not produce compliance. It produces the evidence sources that make compliance work possible — a different and much smaller claim. We wrote about that distinction in SOC 2 on cloud infrastructure.
  • It does not remove the need for people who understand it. It reduces the number of things they have to hold in their heads, and it writes the rest down.

Where to start

#

If you are on a single account today, the useful first move is not a migration. It is a map: list every system, the data it touches, who may change it, and what would happen if it were compromised. The account boundaries usually draw themselves from that list, and the ones that do not are the ones worth arguing about.

If you would rather inherit a structure than design one, that is what the BuiltForProd Baseline is: a foundation deployed into your own accounts, with the repositories and documentation handed over, so the thing you run is yours rather than rented. If you want an outside read first, the BuiltForProd Assessment exists for that, and we will tell you if we are not the right fit.

Questions

What is a landing zone?

A landing zone is the account structure, identity model, network topology, logging pipeline and guardrails that a cloud organization is built on. It is the layer every workload inherits, and it is decided once at the start and changed slowly thereafter.

How many accounts should we start with?

Enough to separate the four concerns that must not mix: management, security and audit, shared infrastructure, and each workload environment. In practice that is more than three and fewer than fifty. The number matters less than whether adding the next one is cheap.

Why should the management account stay empty?

Because it is the account that can change the organization itself, including the guardrails. Running workloads there means any compromise of a workload is a compromise of the organization. Keeping it empty removes that path entirely.

Is one account per team a good model?

Only if the team boundary is also the blast-radius boundary you want. Accounts should follow isolation requirements — environment, data sensitivity, regulatory scope — not the current org chart, because the org chart changes more often than the architecture should.

Can we restructure accounts later?

Yes, but it is expensive. Moving a workload between accounts means new identities, new network paths, new logging destinations and usually a migration window. This is why the account layout is worth an argument on day one and worth very little argument on day four hundred.

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.