# AWS Best Practices for 2026: The Decisions That Are Hard to Undo

URL: https://www.devopsness.com/blog/aws-best-practices
Author: Kiril Urbonas
Published: 2026-11-19
Updated: 2026-11-19
Categories: Cloud
Tags: AWS, Cloud, Infrastructure as Code, FinOps, DevOps

Summary: Most AWS mistakes are cheap to fix. Account structure, identity, IP plans and backup isolation are not. Get those six decisions right first.

---
# AWS Best Practices for 2026: The Decisions That Are Hard to Undo

The AWS practices worth obsessing over are the ones you cannot cheaply reverse: how accounts are split, how people and machines authenticate, how IP space is allocated, and where backups live. Instance sizes, alarms and even databases can change in a sprint. A single shared production account with overlapping CIDRs takes a year to unwind.

> [!VERIFIED]
> AWS CLI 2.41.1, against the AWS Organizations user guide (SCP behavior and quotas), the Organizing Your AWS Environment whitepaper, the AWS Backup Vault Lock guide and the Amazon VPC pricing page. Checked November 2026.

We've reviewed and inherited enough AWS estates to see the same pattern: the painful migrations are almost never about compute. They are about an account that holds six teams' workloads, a VPC that collides with the one you need to peer with after an acquisition, or backups that a compromised admin role could delete. This guide orders the work by reversal cost. Security controls get their own checklist in our [AWS security best practices](/blog/aws-security-best-practices) post; here we cover the architecture those controls sit on.

## Accounts are your blast radius, so start with Organizations

An AWS account is the strongest isolation boundary AWS gives you. IAM policies can be wrong, tags can be missing, but a resource in account A cannot be touched from account B unless someone explicitly built a trust path. That makes the account, not the VPC or the tag, the unit you design around.

The default we'd use: **one account per workload per environment**. `payments-prod`, `payments-staging`, `payments-dev` are three accounts, not three VPCs. This sounds heavy until you count what it buys you. Service quotas stop being shared between noisy neighbors. Cost allocation works without perfect tagging. A leaked dev credential cannot reach production data. Deleting a failed experiment means closing an account instead of hunting for orphaned ENIs.

Organize those accounts into OUs that mirror how you apply policy, not your org chart. AWS's own whitepaper recommends a **Security OU** (log archive, security tooling) and an **Infrastructure OU** (networking, shared services) as the foundation, a **Workloads OU** split into Prod and NonProd, a **Sandbox OU** for experiments with a hard budget, and procedural OUs such as **Suspended** and **Policy Staging**. You will not need all of them on day one; the whitepaper says as much. You will need the Security and Infrastructure OUs before your second workload account.

The management account should run nothing. It is special in one dangerous way: **SCPs do not apply to users or roles in the management account**. Anything deployed there is outside your guardrails. Use delegated administration so GuardDuty, Security Hub, Config and IAM Identity Center are operated from the security or infrastructure account instead.

### Service control policies, and their limits

SCPs are the ceiling on what any principal in a member account can do, including the account's root user. They never grant permissions; an action still needs an identity or resource policy that allows it. The two SCPs we put on every organization are "deny leaving the organization" and a region restriction. AWS publishes a region-deny sample; here it is trimmed (the full `NotAction` list of global services is longer, take it from the source):

```json
# scp/deny-unapproved-regions.json (trimmed from aws-samples/service-control-policy-examples)
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Deny",
      "NotAction": [
        "iam:*", "organizations:*", "sts:*", "route53:*",
        "cloudfront:*", "budgets:*", "ce:*", "support:*",
        "kms:*", "health:*", "waf:*", "wafv2:*", "shield:*"
      ],
      "Resource": "*",
      "Condition": {
        "StringNotEquals": {
          "aws:RequestedRegion": ["eu-central-1", "eu-west-1"]
        },
        "ArnNotLike": {
          "aws:PrincipalARN": "arn:aws:iam::*:role/OrgBreakGlass"
        }
      }
    }
  ]
}
```

Know the quotas before you design a policy hierarchy around them. As of November 2026, an SCP is capped at **10,240 characters**, you can attach at most **10 SCPs** to the root, to each OU and to each account, and OUs nest at most **five levels** deep. Teams that write one SCP per control run out of attachment slots fast; group related denies into a few policies per OU. SCPs also do not restrict service-linked roles, so they are not a substitute for detective controls.

**Control Tower or hand-rolled?** Control Tower orchestrates Organizations, IAM Identity Center and Service Catalog into a landing zone with preventive, detective and proactive controls plus an Account Factory, and it can enroll existing accounts. For a team without a dedicated platform group, it is the right default. Teams already fluent in Terraform often prefer building the same structure themselves with `aws_organizations_*` resources and an account-vending module, trading the console guardrails for full control. Either works. What does not work is "we'll add Organizations later" with ten workloads in one account.

## Humans get Identity Center, machines get roles

In 2026 there is no good reason for a human to have an IAM user. IAM Identity Center federates your IdP (Okta, Entra ID, Google Workspace), assigns **permission sets** to groups per account, and hands out short-lived credentials through `aws sso login`. Offboarding becomes one action in the IdP. Access reviews become a group membership export.

Design permission sets around jobs, not people: `ReadOnly`, `Developer` (NonProd write, Prod read), `Operator` (Prod with change ticket), `BreakGlass` (rare, alarmed). Attach permission boundaries to anything that can create IAM roles, or "Developer" quietly becomes "Admin" through a role they created.

Machines get IAM roles with no static keys: instance profiles, EKS Pod Identity or IRSA, Lambda execution roles, and OIDC federation for CI. If your pipeline still stores an `AWS_SECRET_ACCESS_KEY`, fix that this week; our walkthrough of [OIDC federation for GitHub Actions](/blog/oidc-federation-github-actions-aws) takes about an hour. Every long-lived key is a breach waiting for a public repo.

## Plan the network once: IPAM, non-overlapping CIDRs, centralized egress

Re-addressing a VPC means rebuilding it. That makes the IP plan the single most irreversible networking decision you make, and the one most teams make by accident by accepting `10.0.0.0/16` in every account.

Use **VPC IPAM** from the start. Carve one top-level pool (say `10.0.0.0/8`), split it into regional pools, then per-environment pools, and let accounts allocate from those. Sharing pools with member accounts across the organization needs the Advanced Tier, billed at $0.00027 per active IP address per hour as of November 2026 (about $2 a month per 10 active IPs). The Free Tier is fine for trying the pool design in one account first.

```bash
# Create an IPAM in the networking account, operating in two regions
$ aws ec2 create-ipam \
    --description "org-ipam" \
    --operating-regions RegionName=eu-central-1 RegionName=eu-west-1 \
    --tier advanced
# A top-level pool, then give it the whole private range to carve from
$ aws ec2 create-ipam-pool \
    --ipam-scope-id ipam-scope-0abc123 \
    --address-family ipv4 \
    --description "org-root-10-8"
$ aws ec2 provision-ipam-pool-cidr \
    --ipam-pool-id ipam-pool-0def456 \
    --cidr 10.0.0.0/8
```

Connectivity choices, in order of preference:

- **VPC sharing through AWS RAM** when teams can share a network owned by the infrastructure account. Fewest moving parts, no transit charges between subnets in the same VPC.
- **Transit Gateway** when you have many VPCs that must route to each other or to on-premises. Plan route tables per environment so NonProd cannot reach Prod by default.
- **PrivateLink** when one service is exposed to many consumers who should not see each other's networks.

Egress is where bills hide. NAT gateway costs $0.045 per hour plus $0.045 per GB processed in US East (Ohio) as of November 2026, and that per-GB charge applies to traffic that never needed to leave AWS. **Gateway VPC endpoints for S3 and DynamoDB are free**, with no hourly or data processing charge, so add them to every VPC that has a NAT gateway. Centralizing egress in the infrastructure account cuts NAT gateway count; whether it cuts the total bill depends on Transit Gateway data charges, which we break down in [NAT gateway costs, the silent line item](/blog/nat-gateway-costs-cutting-the-silent-line-item).

## Everything through IaC and a pipeline, including the boring stuff

ClickOps is fine for learning and for incident response. It is not fine for anything you expect to exist next month. The test: if this account were deleted tonight, could you rebuild it from Git and backups? If the answer involves someone's memory, you have an outage you have not had yet.

What "everything" means in practice:

- **Account baselines** (CloudTrail settings, Config recorders, default EBS encryption, S3 Block Public Access, IAM roles for the pipeline) applied by Terraform, CDK or Control Tower customizations to every account at vend time.
- **State per account and per component.** One Terraform state for the whole organization turns every plan into a 20-minute blast-radius gamble. Store state in the account it describes, or in a dedicated tooling account with per-account roles.
- **Production write access only through the pipeline.** Human permission sets in Prod are read-only by default. An SCP or permission boundary that denies mutating calls unless the principal is the deploy role makes this enforceable rather than cultural.
- **Drift detection on a schedule.** A nightly `terraform plan` with `-detailed-exitcode` that alerts on exit code 2 catches console edits before they become the new truth.
- **Tag policies at the organization level** for `owner`, `environment` and `cost-center`, with an SCP that denies creating key resource types without them. Tagging after the fact is archaeology.

Pick one IaC tool per layer and hold the line. A mix of CloudFormation, Terraform and console-created resources in one account is how drift becomes permanent.

## Multi-AZ is the floor, not the disaster recovery plan

Running across at least two, preferably three, Availability Zones is table stakes for production: load balancers across AZs, Auto Scaling groups spanning them, Multi-AZ RDS or Aurora, and no single-AZ dependencies hiding in a NAT gateway or a self-managed cache. Multi-AZ protects against a data center problem. It does nothing for a regional outage, an accidental `terraform destroy`, or ransomware with admin credentials; we covered a real case in [why multi-AZ is not DR](/blog/aws-bahrain-region-lost-multi-az-is-not-dr).

Disaster recovery starts with tiers. Assign every workload an RTO and RPO, because "everything active-active" is unaffordable and "everything from backups" is unacceptable for revenue paths. Three tiers usually suffice: backup and restore (hours), pilot light or warm standby (minutes to an hour), and multi-region active (near zero).

Backups themselves need **isolation from the account they protect**. Use AWS Backup with copy jobs into a vault in a dedicated backup account, and lock that vault. AWS Backup Vault Lock has two modes. **Governance mode** can be removed by users with sufficient IAM permissions. **Compliance mode**, after a grace period of at least 72 hours, makes the vault and its lock immutable: no user and not AWS can change or delete them while they hold recovery points. Use governance mode while you tune retention, then switch to compliance mode for production vaults. Then schedule restore tests, because a backup you have never restored is a hypothesis.

## Cost is an architecture property, not a monthly report

Cost problems are almost always design problems surfacing late: chatty cross-AZ traffic, NAT-routed S3 reads, oversized always-on clusters, logs retained forever by default. The practices that keep spend predictable, by the stage at which they start paying for themselves:

| Practice | AWS service | Adopt at | Why then |
|---|---|---|---|
| Account per workload and environment | Organizations | First production workload | Cost attribution without tagging discipline |
| Budgets and anomaly alerts | AWS Budgets, Cost Anomaly Detection | Day one | A runaway resource is caught in hours, not at invoice |
| Mandatory cost tags | Tag policies plus SCP | 5+ accounts | Shared accounts need allocation that accounts alone don't give |
| Graviton by default | EC2, RDS, Lambda, Fargate | Any new service | Better price-performance with minimal code change for most runtimes |
| Commitments after rightsizing | Savings Plans, Reserved Instances | 3+ months of stable usage | Committing before rightsizing locks in waste |
| Data transfer review | Cost Explorer, VPC Flow Logs | Monthly from 50+ accounts | Transfer is the line item that grows silently |

Two rules sit above the table. First, rightsize before you commit: buying Savings Plans for an oversized fleet just makes the waste non-refundable. Second, set CloudWatch Logs retention on every log group at creation; the default is to keep logs forever, and nobody remembers to change it later.

## Guardrails and observability that run themselves

The last layer is the one that tells you when the first five drift. It should be organization-wide and require no per-account effort:

- **An organization CloudTrail trail** delivering to the log archive account, with S3 Object Lock on the bucket. Member accounts cannot disable it.
- **AWS Config with conformance packs** aggregated in the security account, so "which accounts have unencrypted volumes" is a query, not a project.
- **Security Hub and GuardDuty** with delegated admin, auto-enabled for new accounts, findings routed to the same on-call tool as production alerts.
- **Workload telemetry on SLOs**, not on CPU. Alarm on error rate and latency at the load balancer or API, instrument services with OpenTelemetry, and keep CPU graphs for diagnosis. A CPU alarm at 80% pages someone for a healthy batch job and stays silent during a total outage caused by bad config.

The test for this layer: when a new account is vended, does it arrive with logging, detection and baseline controls already on, without anyone filing a ticket? If yes, the guardrails scale with the organization.

## Questions people ask

### How many AWS accounts should a startup have?

Start with the management account, a log archive account, a security tooling account, and one production plus one non-production account per workload, about five to seven. That is enough to keep production isolated and logs tamper-resistant. Accounts cost nothing to exist; you pay for resources in them. Add accounts as workloads appear rather than packing new services into existing ones.

### Is AWS Control Tower worth it?

For most teams, yes. It builds a working landing zone in under an hour, ships preventive and detective controls, and gives you an Account Factory for consistent account vending. Teams with strong Terraform skills sometimes outgrow its opinions and build the same structure in code. The real mistake is neither choice; it is running production workloads with no multi-account structure at all.

### What is the AWS Well-Architected Framework?

It is AWS's set of design principles and review questions organized into six pillars: operational excellence, security, reliability, performance efficiency, cost optimization and sustainability. The free Well-Architected Tool lets you review a workload against them. It is a good audit checklist; it does not tell you how to order the work, which is why we rank by reversal cost here.

## The decision, concretely

- **Still running multiple workloads in one account?** Create the Organization, move new workloads into their own accounts now, and migrate the old ones by priority. New sprawl is the part you can stop today.
- **Engineers using IAM users or CI using access keys?** Switch humans to IAM Identity Center and pipelines to OIDC roles before anything else on this list. It is the cheapest high-impact change.
- **Every VPC using `10.0.0.0/16`?** Stand up IPAM and allocate non-overlapping ranges for all new VPCs. Re-address old ones only when they need to connect.
- **Backups in the same account as production?** Add a backup account with cross-account copy jobs and a compliance-mode vault lock, then run a restore test this quarter.

## The call we'd make

Spend the first week on structure, not services: Organizations with Security, Infrastructure and Workloads OUs, Identity Center for every human, an IPAM pool, and an isolated, locked backup vault. Everything else on AWS is tunable later. The caveat is honesty about scale: a two-person team can run one workload in two accounts and skip Transit Gateway entirely, as long as the account boundaries and IP plan already assume growth.

## Sources

- [AWS Organizations: service control policies](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html)
- [AWS Organizations quotas](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_reference_limits.html)
- [Organizing Your AWS Environment: recommended OUs and accounts](https://docs.aws.amazon.com/whitepapers/latest/organizing-your-aws-environment/recommended-ous-and-accounts.html)
- [AWS Backup Vault Lock](https://docs.aws.amazon.com/aws-backup/latest/devguide/vault-lock.html)

