Migrating from one or two AWS accounts into a true multi-account strategy is one of those projects that looks straightforward on a whiteboard and turns into a six-month exercise in organizational politics and IAM archaeology. I've led this transition twice — once for a 400-person SaaS company that had outgrown a monolithic production account, and again for a regulated fintech that needed to prove workload isolation to auditors. In both cases, the technology was the easy part. The hard part was deciding where to draw boundaries, who owns what, and how much automation you need day one to prevent the new structure from drifting back into chaos. This article covers the architecture I now use as a baseline: AWS Organizations as the skeleton, Organizational Units (OUs) for blast-radius grouping, and Control Tower as the automated landing zone — with the customizations that make it workable in production.
When a Single AWS Account Becomes a Liability
In my experience, teams don't decide to go multi-account because they read a whitepaper. They do it because something painful happened. A developer deleted the wrong DynamoDB table because everything lived in one account. Or Finance couldn't allocate costs without relying on flaky resource tags. Or a security audit flagged that every engineer had broad IAM access because scoping permissions per environment in a single account had become unmanageable.
A single account concentrates blast radius. A misconfigured IAM policy, a compromised access key, or an errant Terraform apply can affect production, staging, and data infrastructure simultaneously. Service quotas are also account-scoped, so a load test in dev can starve production of API capacity. And from a compliance perspective, you lose the strongest isolation boundary AWS offers: the account itself. SCPs, VPCs, and IAM boundaries are useful, but nothing isolates like a hard account wall.
Cost allocation is the other forcing function. AWS Cost Explorer and Cost and Usage Reports work best when you can group spend by account. I've found that chasing tag compliance across 2,000 resources is a losing battle. When you give each business unit or product its own account and map that account to a cost center via Organizations, attribution becomes automatic. Finance can finally answer "what did team X spend last quarter?" without a spreadsheet and a prayer.
That doesn't mean you should create 50 accounts on day one. The goal is to create enough isolation to be useful but not so much that you drown in operational overhead. For most mid-size organizations, I start with 8-12 foundational accounts and a vending process for creating more as needed. This keeps the initial migration manageable while establishing the patterns for scale.
What Belongs in the Foundational Layer
Regardless of your business, a few accounts are non-negotiable. You need a Management (payer) account that does almost nothing except house Organizations and centralized billing — no workloads should run here. A Log Archive account centralizes CloudTrail, Config, and VPC Flow Logs from every other account. An Audit account hosts Security Hub, GuardDuty delegated administration, and read-only security tooling. And a Shared Services or Network Hub account typically owns Transit Gateway, Direct Connect gateways, and shared Egress VPCs. From there, you add workload accounts per environment (prod, non-prod) and per business unit.
If you are mapping this to broader architectural principles, it helps to view the landing zone through the lens of the AWS Well-Architected Framework: Applying the Five Pillars in Practice — especially the security pillar's emphasis on separation of duties and the operational excellence pillar's push for automation over manual control.
Structuring Organizational Units Around Blast Radius and Ownership
Organizations and OUs look simple in the console — just folders. In practice, how you nest them determines how cleanly you can apply policies, manage delegated administrators, and reason about access. I've seen two anti-patterns repeatedly: mirroring the corporate org chart too literally, and creating a flat structure with 30 accounts at the root. Both make policy management miserable.
The structure that has held up best for me is a two-tier model based on security posture and lifecycle, not department names. At the top level, I use four OUs:
Security OU: Contains Log Archive, Audit, and any security tooling accounts. This OU has the strictest SCPs and is administered only by the cloud platform/security team. No application teams get write access here.
Infrastructure OU: Contains Network, Shared Services, and CI/CD tooling accounts. This is where Transit Gateway, Route 53 hosted zones for centralized DNS, and your artifact registries live.
Workloads OU (with nested child OUs): Contains Sandbox, Dev, Staging, and Production child OUs. Each child OU holds the actual product accounts. This nesting is critical — it lets you attach progressively restrictive policies as you move toward production.
Suspended/Quarantine OU: An empty OU with a deny-all SCP. When you offboard a product or isolate a compromised account, you move it here. It prevents any API calls from succeeding while you investigate.
Nesting matters because SCPs are inherited. An SCP attached to Workloads > Production applies to every prod account automatically. When you add a new product's prod account, it inherits the right baseline without manual policy attachment. That inheritance is also why you should keep the tree shallow — three levels deep is usually the sweet spot. Deeper trees make it hard to trace effective policies.
Applying Service Control Policies Without Locking Yourself Out
SCPs are your preventive guardrails, but they are easy to misconfigure. Remember that SCPs don't grant permissions; they filter what the account's IAM principals can do, even the root user. I always start with a small, high-impact set and expand based on real incidents, not hypotheticals.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DenyLeavingOrganizations",
"Effect": "Deny",
"Action": "organizations:LeaveOrganization",
"Resource": "*"
},
{
"Sid": "DenyRootUserActions",
"Effect": "Deny",
"Action": "*",
"Resource": "*",
"Condition": {
"StringLike": {
"aws:PrincipalArn": "arn:aws:iam::*:root"
}
}
},
{
"Sid": "RequireEncryptedS3Uploads",
"Effect": "Deny",
"Action": "s3:PutObject",
"Resource": "*",
"Condition": {
"StringNotEquals": {
"s3:x-amz-server-side-encryption": "aws:kms"
}
}
}
]
}
I deploy this as a baseline deny for the entire organization, with an exception for the Management and Security OUs where break-glass access is required. Another common early SCP is region restriction. If you only operate in us-east-1 and eu-west-1, denying all other regions reduces risk and simplifies compliance. Just remember to exclude global services like IAM, Route 53, and CloudFront from that deny, or you'll break legitimate calls. I've found that testing every new SCP in a dedicated Sandbox OU for a week — with CloudTrail Lake queries watching for AccessDenied errors — prevents the 2 a.m. pages that come from an overly broad deny.
Inside Control Tower: Landing Zone Automation and Preventive Guardrails
Before Control Tower, teams built landing zones with custom CloudFormation StackSets and a lot of bash. It worked, but drift was constant and upgrades were painful. Control Tower is AWS's opinionated answer: it automates Organizations, creates your foundational OUs and accounts, configures SSO (now IAM Identity Center), and applies a set of guardrails as SCPs and Config rules.
When you launch Control Tower, it creates a Landing Zone with three core accounts — Management, Log Archive, and Audit — and two OUs: Security and Sandbox. It also provisions baseline guardrails. Strongly recommended guardrails like "Disallow public read access to S3 buckets" and "Enable MFA for IAM users" are enforced as SCPs, while detective guardrails like "Detect whether EBS volumes are encrypted" run as AWS Config rules that flag non-compliance.
What Control Tower gets right is the lifecycle management. It handles the undifferentiated heavy lifting of setting up CloudTrail organization trails, Config aggregators, and cross-account IAM roles that would otherwise take weeks to wire correctly. It also gives you Account Factory — a Service Catalog product that lets approved users vend new accounts with pre-approved baselines. That self-service aspect is crucial for scale; you don't want the platform team to be a ticket bottleneck for every new environment.
Where it fights you is customization. By default, Control Tower owns the baseline and will revert manual changes made to its managed resources. If you edit the Log Archive bucket policy by hand, Control Tower will flag drift and attempt to remediate it. For the first year I used Control Tower, I tried to work around this with manual StackSets and regretted it. The sustainable path is Account Factory for Terraform (AFT) or the newer Customizations for Control Tower (CfCT) framework. Both let you inject your own Terraform or CloudFormation without fighting the managed lifecycle. If you are provisioning infrastructure as code, the Terraform Documentation for the AWS provider is the reference I keep open — particularly the sections on aws_organizations_organizational_unit and aws_controltower_control.
Guardrail Selection Is a Policy Decision, Not Just a Technical One
Control Tower ships with over 30 guardrails categorized as mandatory, strongly recommended, and elective. Enabling all of them on day one is a common mistake that generates a flood of non-compliant findings and erodes trust with application teams. I start with mandatory guardrails everywhere, add strongly recommended guardrails to the Production OU only, and treat elective guardrails as opt-in per team. For example, "Disallow internet connection through RDGW" is essential for a PCI workload but breaks a data science sandbox that needs direct internet egress. Let teams request exceptions through a documented process rather than enforcing uniformity that doesn't fit the risk model.
Building a Self-Service Account Vending Machine That Engineers Actually Use
An account vending machine is just an automated workflow that creates a new AWS account, applies baselines, and hands it over to the requester. If the process takes more than 15 minutes or requires a manual approval chain of three managers, engineers will go back to creating resources in the existing shared account. Speed and sensible defaults matter more than exhaustive governance at this stage.
My current setup uses Control Tower Account Factory for Terraform (AFT). The requester opens a pull request adding a simple HCL file, an AFT pipeline validates it, and the account is vended with VPC baselines, IAM Identity Center group assignments, and mandatory tags. Here's a simplified version of the request and the baseline module it triggers:
# account-requests/dev-team-alpha-prod.tf - opened as PR by product team
module "team_alpha_prod" {
source = "./modules/aft-account-request"
control_tower_parameters = {
AccountEmail = "aws-team-alpha-prod@company.com"
AccountName = "team-alpha-prod"
ManagedOrganizationalUnit = "Workloads (ou-ab12-11111111)"
SSOUserEmail = "platform-team@company.com"
SSOUserFirstName = "Platform"
SSOUserLastName = "Admin"
}
account_tags = {
"cost-center" = "cc-9876"
"product" = "alpha"
"environment" = "prod"
"owner" = "team-alpha"
}
change_management_parameters = {
change_requested_by = "j.doe@company.com"
change_reason = "New prod account for Alpha launch"
}
}
That request alone doesn't do much until you pair it with account customization. In AFT, the global customizations and account-specific customizations are Terraform modules that run post-provisioning. This is where I apply the non-negotiable baselines:
# aft-global-customizations/terraform/baseline.tf
resource "aws_s3_account_public_access_block" "block" {
block_public_acls = true
block_public_policy = true
ignore_public_acls = true
restrict_public_buckets = true
}
resource "aws_ebs_encryption_by_default" "default" {
enabled = true
}
resource "aws_iam_password_policy" "strict" {
minimum_password_length = 14
require_lowercase_characters = true
require_numbers = true
require_uppercase_characters = true
require_symbols = true
allow_users_to_change_password = true
max_password_age = 90
}
module "centralized_logging" {
source = "./modules/forward-cloudtrail-to-central-bucket"
log_archive_bucket = "arn:aws:s3:::company-log-archive-123456789012"
kms_key_arn = data.aws_kms_key.log_archive.arn
}
The key lesson from operating this: baselines should be minimal and fast. Enable EBS encryption by default, block public S3 access, forward logs, and set up IAM Identity Center assignments. Don't try to deploy a full VPC topology or EKS cluster as part of vending — that's workload-specific and belongs in the team's own pipeline. The vending machine's job is to deliver a secure, empty, and compliant account quickly. I've found that adding more than 4-5 minutes of Terraform to the vending flow leads teams to cache accounts or reuse old ones, which defeats the purpose.
Enforcing Cross-Account Networking, Identity, and Audit Foundations
Once you have 10+ accounts, the question is no longer "how do I create accounts?" but "how do these accounts talk to each other and to my security team without opening the internet to everything?" The three foundations I prioritize are networking, identity, and audit logging. Get these wrong and every other initiative becomes harder.
For networking, avoid VPC peering at scale. Peering is point-to-point, non-transitive, and becomes an N^2 mesh that is impossible to manage. The pattern that scales is a hub-and-spoke Transit Gateway hosted in your Network account, shared via AWS Resource Access Manager (RAM) to workload OUs. Each workload account gets a single attached VPC per environment with private subnets only; all egress goes through a centralized inspection VPC with AWS Network Firewall or a third-party firewall, and all ingress comes via centralized Application Load Balancers or PrivateLink. This gives you a single place to enforce network guardrails and avoids the "every team builds their own NAT gateway and IGW" sprawl. If you're evaluating connectivity options, the trade-offs are laid out well in Cloud Networking: VPC Peering, Transit Gateway and PrivateLink, and the firewall centralization pattern saves significant operational overhead after about 6 workload accounts in my experience.
For identity, centralize on IAM Identity Center (successor to SSO) in the Management account and federate it to your identity provider (Okta, Azure AD, etc.). Create permission sets once — e.g., ReadOnly, Developer, NetworkAdmin, SecurityAudit — and assign them to groups per account via Organizations. Do not create IAM users in workload accounts. When a user leaves the company, disabling them in the IdP revokes access everywhere instantly. I also enforce a break-glass role in each account that is assumable only from the Audit account with MFA and that triggers an EventBridge alert to Slack whenever it's assumed.
For audit, centralization is everything. Control Tower already creates an organization CloudTrail that writes to the Log Archive bucket, but you should also aggregate AWS Config, GuardDuty findings, and Security Hub results into the Audit account using delegated administrator features. Set S3 Object Lock in compliance mode on the Log Archive bucket so logs cannot be deleted or altered even by an administrator — auditors will ask for this explicitly. And stream CloudTrail management events to a SIEM or to CloudWatch Logs in the Audit account with near-real-time alerting. In regulated environments, I've had to prove that even the platform team cannot tamper with logs without generating an alert; Object Lock plus a detective Config rule on bucket policy changes gives you that evidence.
| Approach | Best For | Management Overhead | Customization Flexibility |
|---|---|---|---|
| Manual Organizations + Custom Scripts | 2-5 accounts, highly specialized requirements | High — you own lifecycle, drifts, upgrades | Maximum, but at cost of consistency |
| Control Tower (native) | 5-30 accounts, standard compliance needs | Low — AWS manages baseline and guardrails | Limited without AFT/CfCT |
| Control Tower + AFT / CfCT | 10-100+ accounts, enterprise scale | Medium — pipeline to maintain, but upgrades are clean | High — Terraform/CDK baselines injected safely |
| Third-Party Landing Zone (e.g., Terraform modules) | Teams heavily invested in Terraform, avoiding Service Catalog | Medium-High — depends on module maturity | High — full code ownership |
Choosing between these is less about features and more about who will own it at 2 a.m. If you have a dedicated platform team comfortable with Terraform pipelines, Control Tower + AFT gives you the best balance of automation and control. If you're a small team without that bandwidth, native Control Tower with elective guardrails disabled is a pragmatic starting point; you can add AFT later without re-architecting OUs, which is also the approach I recommend if you're mid-migration and weighing scope — a narrower start aligns with Cloud Migration Strategies: The 6 Rs and How to Choose where rehosting the landing zone first and refactoring baselines incrementally beats a big-bang rebuild.
Frequently Asked Questions
Should the Management (payer) account host any workloads?
No. Keep the Management account as empty as possible — no EC2 instances, no S3 buckets beyond billing reports, and no human access except for break-glass and Organizations administration. If that account is compromised, the attacker controls your entire organization, including the ability to remove SCPs. In both environments I've run, Management IAM is limited to 3-4 platform admins with hardware MFA, and all operational tooling lives in Infrastructure or Audit accounts instead.
How do we migrate existing resources from a monolithic account into the new OU structure?
You don't move the account; you create new workload accounts and migrate workloads via infrastructure-as-code redeployment, not resource moves. In-place separation inside one account rarely preserves history cleanly. I use a strangler pattern: keep the legacy account as a Workloads > Legacy OU, freeze new deployments there, and redeploy services one by one into fresh accounts using Terraform or CloudFormation. For stateful data, use native replication (RDS snapshots, S3 replication, EBS snapshots shared cross-account) and cut over DNS. Budget for IP re-allocation and VPC CIDR planning upfront — overlapping CIDRs will block Transit Gateway attachments later.
What happens if we need to leave Control Tower — are we locked in?
You're not locked in, but exiting is deliberate. Control Tower is largely automation around Organizations, CloudFormation StackSets, and Config — your accounts and OUs remain standard AWS resources. You can disable Control Tower's drift detection and take over management of its StackSets manually, though AWS doesn't provide a one-click "uninstall." In practice, I've never needed to leave entirely; when native guardrails were too rigid I extended them via AFT customizations rather than removing Control Tower. If you anticipate needing extreme customization, starting with Control Tower + AFT from day one preserves an exit path where you can keep the OU structure and replace the automation layer later.
How many accounts is too many?
There is no hard AWS limit that most teams hit — the default quota is 10 accounts and you can raise it to thousands. Operationally, the pain point is not count but consistency. When you have more than ~20 accounts, manual console checks become useless and you must rely on aggregated Config, Security Hub, and Cost Explorer views from the Audit and Management accounts. I've seen 150-account organizations run smoothly because vending, baselines, and networking were fully automated, and 12-account setups that were chaotic because every account was a snowflake. Scale your automation before you scale your account count.