case_study:
id: case-01
title: Multi-account AWS baseline
scope: platform foundation
engagement: audit + build
status: draft
timeline: example · 14 weeks · 3 environments
team: example · 2 platform engineers + 1 product owner
problem: |
Fourteen AWS accounts had grown alongside the product: one per
environment, one per team that was acquired, one that existed only
because a contractor needed a sandbox in 2019 and nobody closed it
afterwards. Each account kept its own conventions for naming,
tagging and networking, and each was administered by whoever
happened to have the console open at the time.
The consequences were ordinary rather than dramatic. Nobody could
answer which account a service lived in without asking. The monthly
bill arrived as a single number with no way to attribute it to a
team. Standing up a new environment took three weeks, because it was
assembled by hand from a checklist that had drifted away from
reality. And the network between accounts had been wired project by
project, so every new connection was a new exception.
Nothing was on fire. That was the problem: the estate worked well
enough that fixing it never became urgent, while every new service
made it slightly harder to reason about.
what_i_did:
- step: 01
title: Inventory and ownership
description: |
Started with a map, not a design. Every account, service,
database, bucket and DNS zone got an owner and an environment.
The output was one page per account, published in the repository
and reviewed with the teams — including the accounts everybody
assumed were unused.
- step: 02
title: Account structure
description: |
Defined the structure once: environments separated by account,
shared services in one place, and a naming rule that does not
depend on who created the resource. Accounts without a purpose
were emptied and closed instead of being kept as an archive of
decisions nobody remembers.
- step: 03
title: Network model
description: |
Replaced per-project connections with one network model: a
single place where shared services live, environment boundaries
that cannot be crossed by accident, and one documented path for
a new service that needs to reach another account.
- step: 04
title: Cost attribution
description: |
Tagging enforced at creation time instead of audited afterwards,
budgets per team instead of per account, and a monthly read-out
that names the owner of every line that grew. The goal was not a
dashboard — it was being able to answer why this number is
higher than last month, in the meeting where somebody asks.
- step: 05
title: New account template
description: |
The last piece was making the baseline reproducible: a template
that creates an account with the same guardrails, logging,
budgets and network defaults as the rest. Standing up an
environment stopped being a project and became a request.
result:
summary: |
A new account starts from a template, not from somebody's memory of
how the previous one was built. Every service has an address: one
owner, one account, one place to look. The bill can be split by team
without a spreadsheet exercise, and a connection between two
accounts follows a documented path instead of creating another
exception.
The less measurable part matters as much. Questions that used to
take a day now take a link to the repository. When a person leaves,
the account does not leave with them.
details:
# placeholders — replace with measured values,
# keep the source line
- name: monthly infrastructure spend
before: $48k
after: $31k
delta: -35%
source: billing export,
rolling 3-month average
- name: new environment lead time
before: 3 weeks
after: 2 days
delta: -90%
source: delivery board,
median of 6 environments
- name: accounts without a named owner
before: 14
after: 0
delta: -100%
source: repository review,
completed
- name: time to answer "which account runs this"
before: ~1 day
after: ~1 min
delta: -99%
source: team survey,
5 responses
stack:
aws: [Organizations, IAM Identity Center, VPC, Transit Gateway,
EKS, RDS, S3, Route 53]
iac: [Terraform, Terragrunt, GitHub Actions OIDC]
policy: [SCPs, permission boundaries, OPA checks in CI]
cost: [Tagging rules, budgets per team, monthly read-out]
logging: [Organization trail, central log archive]
docs: [One page per account, runbooks, onboarding notes]