0%
AWS in Practice: Services, Limits, and Failure Modes
Compute
Storage
Databases
Networking
Delivery and Visibility
Limits, Cost and Recovery
Accounts, Organizations, and Service Control Policies
Every AWS architecture diagram starts with boxes inside a rectangle, and almost nobody draws the rectangle carefully. The rectangle is the account, and it is the most important boundary in the platform. It is not an administrative grouping that happens to hold resources. It is the thing AWS actually isolates. Permissions, quotas, billing, network address space, encryption keys and the reach of a compromised credential all stop at the account edge by default, and almost nothing else in AWS stops anything by default.
That sentence is worth unpacking, because the rest of this course leans on it. A virtual private cloud is a network boundary, but two VPCs in the same account are administered by the same principals, so anyone who can change one can usually change the other. A tag is a label, and a policy can refer to it, but a tag is only as strong as the permission to change it, which in most accounts is granted broadly. An IAM path or a naming convention is a convention. The account is the one boundary that holds even when every convention inside it has been broken.
What stops at the account edge
There are five things worth naming, because each of them is a reason to create a separate account rather than a separate folder.
The first is identity. An IAM role or user exists in exactly one account. A principal in account A has no access to anything in account B unless something in account B explicitly says so, typically a role trust policy or a resource policy naming account A. That explicit grant is visible, reviewable and revocable in one place. Inside a single account, by contrast, access is granted by identity policies scattered across hundreds of roles, and the question "who can delete this bucket" requires evaluating every one of them.
The second is service quotas. Most quotas are per account per region. Lambda's default concurrency is one thousand concurrent executions per account per region, shared by every function in that account. EC2 on demand instance quotas are counted in vCPUs per account per region and per instance family group. API request rates for many control plane operations are throttled per account. A batch job that consumes all the Lambda concurrency in an account will throttle the customer facing API that shares it, and no amount of careful code in the API will help. A separate account gives each workload its own quota pool.
The third is billing. Every charge is attributed to an account first. Cost allocation tags exist and are useful, but they are applied inconsistently, they cannot be retroactively applied to charges that were never tagged, and some charges, such as certain data transfer and support fees, are awkward to tag at all. An account is a cost centre that cannot be forgotten.
The fourth is blast radius. If a credential leaks, if a deployment tool misbehaves, if an engineer runs a destructive command against the wrong profile, the damage is bounded by what that principal could reach, which in a well run organisation is one account. The difference between "an attacker obtained a deploy role and deleted the staging database" and "an attacker obtained a deploy role and deleted every database the company owns" is very often the difference between one account and many.
The fifth is the default network and encryption scope. KMS keys are account resources, VPCs are account resources, and cross account sharing of either is an explicit act. Nothing leaks across by accident.
Why one big account fails slowly
Most companies start with one account, and for the first year it is fine. The failure arrives gradually and is not obvious from inside. A second team starts deploying into the same account and needs broad permissions to do their job, so they get a role with AdministratorAccess because writing a narrower policy would take a week. A data science group starts running large batch jobs, and the first time their jobs spike, the production API's Lambda functions throttle. Somebody creates a staging environment in the same account with a slightly different name prefix, and six months later a script that matched on prefix deletes production resources.
None of these is a dramatic failure on its own, and each one has a local fix: a narrower policy, a reserved concurrency setting, a better naming convention. The problem is that every local fix is a convention that has to be maintained by everyone, forever, and conventions decay. Security reviews of single account environments almost always find the same three things: dozens of roles with administrator access, no way to answer who can touch production data, and a CloudTrail configuration that the workloads themselves could disable.
How many accounts is normal
The answer surprises people the first time. A company with a dozen engineering teams commonly runs between thirty and a hundred accounts, and large enterprises run thousands. The usual decomposition is by workload and environment, so a service has a production account, a staging account and often a development account, plus a handful of shared accounts for logging, security tooling, networking and identity.
That number sounds like overhead, and it would be if accounts were created by hand. They are not, in a mature organisation. An account is created by a pipeline, called account vending, that applies a baseline of roles, logging, guardrails and network configuration automatically. Once vending exists, the marginal cost of an account is close to zero, and the question changes from "should we create another account" to "is there any reason these two workloads should share one".
A concrete decomposition makes the arithmetic less abstract. Take a company with ten services, each with production, staging and development environments. That is thirty workload accounts. Add a log archive, a security tooling account, a network hub, a shared services account for artefact repositories and build runners, and an identity account, and the organisation has thirty five accounts before anyone has asked for a sandbox. Give each of forty engineers a personal sandbox and it has seventy five. None of those accounts is idle overhead: each one corresponds to a distinct blast radius, quota pool and cost line, and each one can be reasoned about on its own.
There are good reasons for sharing. Two services that call each other constantly over private networking, that are always deployed together and that are owned by the same team gain little from separation and pay a real cost in cross account plumbing. The default should still be separation, with sharing as the exception that needs a reason, because separating accounts later means migrating resources that were never designed to move.
The cost of the boundary
The account boundary is not free, and it is worth being honest about what it costs. Cross account access requires roles and trust policies in both directions. Cross account networking requires peering, Transit Gateway or PrivateLink, each with its own charges. Some services are awkward across accounts: a shared KMS key needs both a key policy and an identity policy, and a cross account event bus needs a resource policy on the target bus. Engineers need a way to move between accounts without juggling dozens of credentials, which is what IAM Identity Center provides. Observability needs to be aggregated, because a dashboard that only sees one account is a dashboard that misses most of the system.
Each of those costs is paid once, by a platform team, and then reused by everyone. The costs of the single account, by contrast, are paid continuously by every team in the form of incidents, slow security reviews and quota collisions. That asymmetry is the real argument for many accounts.
Every other isolation mechanism inside an account, whether a naming prefix, a tag, an IAM path or a separate VPC, depends on every principal in the account respecting it. The account boundary depends on nothing inside the account. That is why it is the right default unit for separating environments, teams and data classifications, and why the question to ask is not whether you need another account but whether two workloads have a concrete reason to share one.