A small, practical AWS Organizations layout for a startup: which accounts to create, how people sign in with IAM Identity Center, the service control policies worth adding first, and how deploys reach each account.

Most startups begin with one AWS account where production, staging, someone's test Lambda and the founder's root login all live together. It works until an intern's script deletes the wrong bucket, an auditor asks who can read production data, or the bill needs splitting by environment and every resource lacks a tag.
AWS's answer is several accounts under one organization, since an account is the strongest isolation boundary AWS has for IAM, quotas and billing. The full landing zone guidance is written for enterprises. This guide is the smaller version: the accounts worth creating first, sign-in, a few guardrails and deploy access.
This mirrors the structure in AWS's organizing your environment whitepaper, trimmed to what a team of five to fifty uses. Put the workload accounts in a Workloads OU with Prod and NonProd children, and the log and security accounts in a Security OU, so policies can target a group rather than individual accounts.
Enable Organizations from the account that will become the management account, usually the one you already have. If that account already runs production, a cleaner path is to create a new management account and invite the old one as the production account, so the management account stays empty.
Each account needs a unique email; a plus-addressed group mailbox works. AWS Control Tower does the same setup plus organization CloudTrail, the log archive and audit accounts and a set of controls, which is the quicker route if you are starting fresh.
Enable IAM Identity Center in the management account and connect it to Google Workspace, Okta or Entra ID. Create permission sets, such as AdministratorAccess for staging and a read-only set for production, and assign groups to accounts. Developers then sign in once and get short-lived credentials for whichever account they pick:
Delete IAM users with access keys as you migrate people. The fewer long-lived keys exist, the less there is to leak into a repository or an AI agent's context.
Service control policies set the maximum permissions for every principal in an account, including its administrators. Start with a small set attached to the workload OUs: deny leaving the organization, deny disabling CloudTrail or GuardDuty, and deny regions you do not use.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DenyUnusedRegions",
"Effect": "Deny",
"NotAction": ["iam:*", "organizations:*", "sts:*", "support:*", "cloudfront:*", "route53:*"],
"Resource": "*",
"Condition": {
"StringNotEquals": { "aws:RequestedRegion": ["us-east-1", "eu-west-1"] }
}
},
{
"Sid": "ProtectAuditTrail",
"Effect": "Deny",
"Action": [
"cloudtrail:StopLogging",
"cloudtrail:DeleteTrail",
"cloudtrail:UpdateTrail",
"cloudtrail:PutEventSelectors",
"guardduty:DeleteDetector",
"guardduty:UpdateDetector",
"guardduty:DisassociateFromAdministratorAccount",
"guardduty:DisassociateFromMasterAccount",
"organizations:LeaveOrganization"
],
"Resource": "*"
}
]
}
Global services such as IAM, CloudFront and Route 53 are excluded from the region rule since they live in us-east-1 regardless of where you deploy. Test SCPs on the sandbox OU first; a bad deny can block your own pipeline.
Deploys should not use a person's credentials. Create a deploy role in each workload account that trusts your CI provider through OIDC, so a pipeline assumes it with a short-lived token and no stored keys. The GitHub Actions to AWS without long-lived keys guide walks through the trust policy. Scope the production role to the production branch or environment in the token claims.
Best fit: any startup past its first production customer. Five accounts take an afternoon to set up and remove a class of mistakes and audit questions.
Encore brings infrastructure from code and deploys it into your own cloud accounts, which slots into the layout above as the deploy path for workload accounts. In the Connect Cloud flow you create an IAM role, require the external ID Encore provides, and connect the role to the Encore Platform. The docs suggest a dedicated account or sub-organization to keep that role's scope clear. You connect the staging and production accounts, each environment deploys into its account, and each gets its own VPC, database and queues.
The application code is the same for both accounts. Infrastructure is declared once and provisioned per environment in that environment's account:
package billing
import (
"encore.dev/pubsub"
"encore.dev/storage/sqldb"
)
// Provisioned separately in the staging account and the production account.
var db = sqldb.NewDatabase("billing", sqldb.DatabaseConfig{Migrations: "./migrations"})
type InvoiceIssued struct {
InvoiceID string `json:"invoice_id"`
}
var InvoicesIssued = pubsub.NewTopic[*InvoiceIssued]("invoices-issued", pubsub.TopicConfig{
DeliveryGuarantee: pubsub.AtLeastOnce,
})
var secrets struct {
StripeKey string // a different value per environment, never in the repo
}
Secrets are set per environment and stored in AWS Secrets Manager in that environment's account, so the production Stripe key never reaches the staging account or the repository. Encore provisions an IAM role for the service.
This also changes who needs production credentials. Developers and coding agents push code; the Encore Platform holds the deploy role, and engineers keep their Identity Center access to production for incidents rather than for every release.
Best fit: startups that want separate staging and production accounts from the start, with one codebase deploying to both and no deploy scripts per account.
Create the five accounts, enable Identity Center and add the two SCPs above this week; Control Tower is worth it if you want the logging and guardrails set up for you. Give every deploy path its own role per workload account. If you deploy with Encore, connect the staging and production accounts and let environments map onto them, and keep production console access for the people on call.
A practical starting point is five: a management account that only holds billing and the organization, a log archive account, a security tooling account, and separate staging and production workload accounts. Add sandbox accounts for experiments and more workload accounts when teams or compliance boundaries need them.
Control Tower sets up the organization, log archive and audit accounts, CloudTrail and guardrails for you, and adds an account factory. It is the faster path for most teams. Setting up Organizations by hand gives more control and fewer moving parts, but you configure CloudTrail, Config and SCPs yourself.
Use IAM Identity Center with your identity provider. Developers sign in once and pick an account and permission set, and the CLI gets short-lived credentials through aws sso login. Avoid IAM users with long-lived access keys in each account.
You connect an AWS account in the Connect Cloud flow by creating an IAM role, requiring the external ID Encore provides, and linking that role. The docs recommend a dedicated account or sub-organization to scope that access. You connect your workload accounts, and environments deploy into them, so developers do not need standing credentials for production to ship.
Deploy to your cloud on AWS and Google Cloud
without managing infrastructure
Encore lets developers and agents define application infrastructure directly in code, then automatically provisions it from local development to production in your AWS or GCP account.