Skip to Content
Cloud Engineering Academy
15. Multi-Account Governance & FinOps

Why a bank uses many AWS accounts

Decide when to split workloads into separate AWS accounts, justify each split with blast radius, segregation of duties, quotas, data scope and cost, and write the decision down so an auditor can follow it.

intermediate⏱ 1 h 🟢 FreeCLF-C02SAA-C03SAP-C03SCS-C03

Assumes: .NET 10 LTS · AWS SDK for .NET v4 (AWSSDK.Organizations 4.1.x) · AWS CLI v2 · Terraform AWS provider v6 · Region us-east-1. Verified against official sources on 2026-11-18.

Learning objectives

By the end of this lesson you can:

  • Name the five things an AWS account isolates (identity, blast radius, quotas, billing, policy) and the two things it does not (the network once you connect it, and anything the management account can reach).
  • Apply a repeatable "split by" test to decide whether a workload needs its own account.
  • Explain to an auditor, in plain language, how separate accounts support segregation of duties and a smaller scope for card data.
  • Count the hidden per-account costs (baseline services, humans, quota requests) so that you do not create accounts by reflex.
  • Write a one-page account-strategy decision record for Harbourline Bank.
  • Run a small .NET program that inventories every account in an organisation and flags accounts nobody owns.

Prerequisites

Why this matters in banking

Picture Harbourline Bank's first year on AWS, run in one account "to keep it simple".

  • Month 3. A developer debugging a failed payment runs a clean-up script with the wrong profile. It deletes a DynamoDB table that happened to hold production idempotency keys. "Admin" in this account means admin over everything, because there is only one account.
  • Month 6. A load test for the Accounts API exhausts the Region's concurrent Lambda executions. Production payment processing is throttled at the same moment, because both share one quota.
  • Month 9. The QSA (the external assessor for card data rules) asks which systems are in scope for PCI DSS. In one account with one flat network and a shared permission model, the honest answer is "all of them". The assessment is four times larger and four times as expensive.
  • Month 12. Finance asks what the Payments Service costs. Tags are 70 percent complete. Nobody can say.
  • Month 13. An engineer's laptop session is phished. The attacker can delete the audit logs, because the audit logs are in the account the engineer administers.

Every one of those is a scope problem, and an AWS account is the cleanest scope AWS offers. Regulators do not mandate "many accounts", but they do expect segregation of environments, segregation of duties and tamper-resistant logs. Separate accounts are the most direct way to show all three. That is why banks run tens to hundreds of them.

The idea in plain language

An AWS account is not a login. It is a container: a set of resources, a private identity system (IAM), a set of quotas and one line on the bill. Two containers share nothing unless someone, deliberately and in writing (a policy), opens a door between them.

So the design question is never "how many accounts?" It is: "which things must not be able to hurt, see, starve or bill each other?" Put those things in different containers. Put things that must change together in the same one.

Analogy: a bank's buildings. Cash handling, the records archive, the staff canteen and the construction site next door do not share a vault, a keycard system or a fire-door plan, even though they are all "the bank". A fire in the canteen must not burn the records. You do not build one building per person either, because every building needs guards, cleaners and a lease. Account design is the same trade-off: isolate what must be isolated, and no more.

The five isolations an account gives you

IsolationWhat it means in practiceWhat it stops
IdentityEvery account has its own IAM users, roles and policies. A role in account A has no power in account B unless B's role trust policy allows itA compromised developer role in dev reaching production data
Blast radiusA mistake or an attacker is limited to what the account's identities can reachOne bad script deleting everything
QuotasMost service quotas apply per account per RegionA load test starving production
BillingEvery charge is attributed to an account"Who spent this?" without perfect tagging
PolicyOrganisation policies (SCPs, RCPs, tag policies) can differ per account or OUStrict guardrails on production, freedom in the sandbox

What an account does not isolate

  • The network, once you connect it. Two accounts joined by a Transit Gateway or VPC peering are one flat network unless route tables and security groups say otherwise. See Multi-account networking.
  • Anything the management account or the identity provider can reach. A person who can administer AWS Organizations, or who controls the workforce directory, can usually reach every account. That is why the management account runs no workloads and why identity administration is tightly guarded (Federation and segregation of duties).
  • Shared resources you chose to share. Resource sharing, cross-account roles, shared KMS keys and shared S3 buckets are deliberate holes in the wall. Each is a decision to review.
  • Regulatory responsibility. Putting a system in its own account reduces what an assessor must examine. It does not make it compliant. Whether segmentation is sufficient is the assessor's call, not yours or AWS's.

What problem the AWS service solves

AWS Organizations (covered in the next lesson) is the tool that makes many accounts manageable: central billing, account creation by API, OUs and policies. This lesson is about the earlier question, when is a new account worth it.

The "split by" test

For each workload or data set, ask these questions in order. A "yes" to any is a reason for a separate account.

#QuestionTypical Harbourline answer
1Environment: would a mistake in dev, test or sandbox be able to touch production data?Yes, so one account per environment
2Data classification and scope: does it hold regulated data (card data, special-category personal data) that should have a smaller audit scope?Yes, so the card-handling service gets its own account
3Segregation of duties: should the people who run it be different from the people who audit it?Yes, so logs and security tooling live in their own accounts
4Ownership: does a different team own the budget, roadmap or on-call for it?Often yes, so one account per team per environment
5Quota and noisy neighbour: could its load or experiments exhaust shared quotas?Yes for load-test and data-platform jobs
6Lifecycle and risk: is it short-lived, experimental or untrusted?Yes, so sandboxes and acquired code get separate accounts
7Function: is it shared plumbing (network hub, CI/CD runners, DNS)?Yes, so one account per shared function

If the answer to all seven is "no", keep it with its neighbours. Many small internal tools do not need an account each.

Honest costs of more accounts

Isolation is not free. Each account you add brings:

  • Baseline services in every account. CloudTrail, AWS Config, GuardDuty and Security Hub are enabled per account (and per Region). The per-account base cost is small, but it multiplies. A NAT gateway or interface endpoints in every account's VPC can cost more than the workload.
  • Cross-account plumbing. Roles, trust policies, resource policies, KMS key policies and DNS delegation. Each is another thing to get wrong and another place for an AccessDenied.
  • Quota requests. New accounts start with default quotas, and some are lower for new accounts. You request increases per account.
  • Human overhead. Someone owns each account, answers its alarms, rotates its break-glass credentials and closes it when it is no longer needed.
  • An account limit. The default is only 10 accounts per organisation ⚠ VERIFY current default in Service Quotas; increases are requested from the management account. Account creation is asynchronous and only five can be in progress at a time. Plan before you script it.

The cure for these costs is automation (a landing zone, account vending and baseline stacks), not fewer accounts. The rest of this module shows how.

Microsoft / Azure comparison

You know (Microsoft/Azure)AWS equivalentWhat's different
Entra ID tenant (one identity plane for everything)IAM Identity Center for people; separate IAM in every accountIn Azure one directory sees all subscriptions. In AWS each account has its own roles, and people reach them through Identity Center permission sets
Subscription (billing and quota scope)AWS accountAn account is also the identity boundary, not only billing and quotas, so it is a stronger wall
Management groupsAWS Organizations OUsSimilar inheritance of policy; OUs nest up to five levels
Resource group (lifecycle and RBAC scope)Tags, CloudFormation stacks, or a separate accountThere is no resource group with RBAC; the nearest hard boundary is the account
Azure Policy at subscription scopeSCPs, RCPs, tag policies at OU or accountSCPs only cap permissions and never grant any
Subscription quota requestsService Quotas, per account per RegionMany quotas are per Region as well, so a multi-Region design multiplies requests
Landing zone acceleratorAWS Control Tower, or your own IaC landing zoneSee Control Tower and landing zones

The most common surprise for .NET and Azure teams: an AWS account is a much heavier wall than a subscription, so patterns like "one subscription per environment" are the minimum in AWS, not the maximum.

Architecture

One account for everything, versus the split:

The security-boundary view: what a compromised developer role can and cannot do.

Step-by-step implementation

This lesson is a design exercise first and a console task second. You will end with an account-strategy decision record and an inventory of your real organisation.

List the systems and data

From Harbourline's system table in the course conventions, list each system and the most sensitive data it handles: Core Banking connector, Accounts API, Payments Service, Notifications Service, Data Platform, Partner Gateway, plus shared things (network, CI/CD, logging).

Run the seven-question test on each

Mark every "yes". Do not decide yet; just collect reasons. Write the reason next to each "yes" (for example "Payments: Q2 card scope, Q3 duties, Q5 quota").

Group, then name

Merge workloads that share the same reasons, owner and environment. Name accounts predictably: <system>-<environment>, for example payments-prod, payments-dev, network-hub, log-archive. A naming convention is not decoration: scripts and SCPs will match on it.

Assign an owner and a budget to each account

An account with no owner and no budget is how forgotten spending happens. Record a named team, an e-mail distribution list (never one person) and a monthly budget. You build the budgets in the FinOps lessons later in this module; for now decide the number.

Write the decision record

One page: context, the seven questions, the account list, what you deliberately did not split and why, the review date. The sample in the Assignment below is the format.

Inventory the real organisation

Run the CLI commands and the C# program below against your sandbox organisation. They are read-only.

AWS Console instructions

Sign in to the management account with the learn-management SSO profile.

  1. Console → AWS Organizations → AWS accounts. You see the tree of OUs and accounts. Select an account to see its ID, e-mail, joined method (created or invited) and tags.
  2. Open Policies → Service control policies. Note FullAWSAccess and your Region guardrail from Module 0, and which targets each is attached to.
  3. Console → Billing and Cost Management → Cost Explorer, group by Linked account. This shows the "billing isolation" in practice: one line per account.

AWS CLI

# Who am I, and in which account? Always check before you run anything else.
aws sts get-caller-identity --profile learn-management

# The organisation: its ID, management account and feature set (must be ALL for SCPs)
aws organizations describe-organization --profile learn-management

# Every account, compact table. Status ACTIVE or SUSPENDED (PENDING_CLOSURE during the post-closure period)
aws organizations list-accounts --profile learn-management \
  --query "Accounts[].{Id:Id,Name:Name,Status:Status,Joined:JoinedMethod}" --output table

# Tags on one account (ownership information lives here)
aws organizations list-tags-for-resource --resource-id 111122223333 --profile learn-management

# Look up a Service Quotas value: how many accounts may this organisation have?
aws service-quotas list-service-quotas --service-code organizations \
  --profile learn-management --query "Quotas[?contains(QuotaName,'accounts')]"

Infrastructure as Code

You rarely create accounts with IaC in the first week, but you should know what it looks like and why it needs care. Accounts are not like other resources: removing one from your code does not delete it.

using Amazon.CDK;
using Amazon.CDK.AWS.Organizations;
using Constructs;

// L1 construct for AWS::Organizations::Account. Run from the MANAGEMENT account.
// Compiled against Amazon.CDK.Lib 2.277.0, not deployed. ⚠ VERIFY property names if you use another version.
public class AccountStack : Stack
{
    public AccountStack(Construct scope, string id, string parentOuId) : base(scope, id)
    {
        var account = new CfnAccount(this, "PaymentsDev", new CfnAccountProps
        {
            AccountName = "payments-dev",
            Email = "aws-payments-dev@example.org",   // a distribution list, never a person
            ParentIds = new[] { parentOuId },
            Tags = new[]
            {
                new CfnTag { Key = "Owner", Value = "payments-team" },
                new CfnTag { Key = "Environment", Value = "dev" }
            }
        });

        // Deleting the stack leaves the account (and its bill) behind. Be explicit about that.
        account.ApplyRemovalPolicy(RemovalPolicy.RETAIN);
    }
}

Complete code

An account inventory that flags accounts with no Owner tag. It compiles against AWSSDK.Organizations 4.1.x on .NET 10. Create a console project and add the package:

dotnet new console -n AccountInventory
cd AccountInventory
dotnet add package AWSSDK.Organizations
Program.cs
using Amazon.Organizations;
using Amazon.Organizations.Model;

// Account inventory: every account, its status and how it joined, plus the owner tag.
// Run in the MANAGEMENT account:  AWS_PROFILE=learn-management dotnet run
var org = new AmazonOrganizationsClient();

var accounts = new List<Account>();
string? token = null;
do
{
    var page = await org.ListAccountsAsync(new ListAccountsRequest { NextToken = token });
    accounts.AddRange(page.Accounts ?? []);
    token = page.NextToken;
} while (token is not null);

var withoutOwner = 0;
Console.WriteLine($"{"Id",-14}{"Name",-28}{"Status",-18}{"Joined",-10}Owner");
foreach (var a in accounts.OrderBy(a => a.Name, StringComparer.OrdinalIgnoreCase))
{
    var tags = await org.ListTagsForResourceAsync(new ListTagsForResourceRequest { ResourceId = a.Id });
    var owner = tags.Tags?.FirstOrDefault(t => t.Key == "Owner")?.Value;
    if (owner is null) withoutOwner++;
    Console.WriteLine($"{a.Id,-14}{a.Name,-28}{a.Status?.Value,-18}{a.JoinedMethod?.Value,-10}{owner ?? "(none)"}");
}

// A governance smell: accounts with no Owner tag have nobody to call when they cost money or misbehave.
Console.WriteLine($"{accounts.Count} account(s); {withoutOwner} without an Owner tag.");
return withoutOwner == 0 ? 0 : 1;

Code explained line by line

  1. new AmazonOrganizationsClient() uses the default credential chain. With AWS_PROFILE=learn-management it picks up your SSO profile; there are no keys in the code.
  2. Organizations is a global service homed in us-east-1. The SDK resolves the right endpoint, but your profile must be the management account (or a delegated administrator for the calls that allow it).
  3. The do … while loop follows NextToken. ListAccounts returns pages, and forgetting to page is a classic bug that works fine with 10 accounts and silently hides account 11 onwards.
  4. page.Accounts ?? [] is there because in SDK v4 collection properties are null when the service returns nothing, not empty lists.
  5. ListTagsForResource is one call per account. That is fine for tens of accounts. For hundreds, add a small delay or parallelism limit, because Organizations API calls are throttled per account.
  6. The program returns exit code 1 when any account has no owner, so you can run it in a scheduled pipeline and fail loudly.

Security considerations

⚠ Learning shortcut — not for production

In this course your sandbox account and the management account are the only two accounts you really use, and you run read-only commands from your laptop with an SSO profile. A bank would never let day-to-day engineering sign in to the management account at all. Read-only organisation inventories run from a delegated administrator or an automation role in a security tooling account, and the management account is used a few times a year by a very small, monitored group.

  • The management account is the keys to the kingdom. Treat it like the bank's board room: no workloads, no engineering access, hardware MFA on root, alerts on every sign-in.
  • Account e-mail addresses are credentials-adjacent. The address on an account controls root password recovery. Use a monitored distribution list at your own domain, never a personal address, and never reuse one address for two accounts (AWS requires unique addresses).
  • Account IDs are not secrets, but are not public either. Do not rely on hiding an ID. Do not publish it unnecessarily.
  • Do not claim isolation you have not tested. "Separate accounts" is a claim. Prove it with a test that a dev role cannot read a production bucket, and keep the output as evidence.
  • Compliance is not automatic. A smaller card-data scope is something your assessor may or may not accept. Bring the QSA into the design early.

Banking use case

Harbourline's first-pass account strategy (fictional) after running the seven questions:

AccountWhy it exists (questions)Owner
harbourline-managementBilling and Organizations onlyCloud platform
log-archiveQ3 duties, Q6 immutabilitySecurity
security-toolingQ3 dutiesSecurity
network-hubQ7 functionNetwork
shared-servicesQ7 function (CI/CD runners, artefacts)Platform
payments-prod / payments-devQ1 environment, Q2 card scope, Q5 quotaPayments
dataplatform-prod / dataplatform-devQ1, Q2 (personal data), Q5 (large jobs)Data
notifications-prod / notifications-devQ1 environment (but see below)Notifications
sandbox-<engineer>Q6 lifecycleThe engineer

The decision record also says what it did not split: the Notifications Service and the Partner Gateway share a channels-prod account because they are owned by one team, hold no card data and have similar change cadence. A later review may split them. Writing down "not split, and why" is what stops the account count growing by habit.

Common mistakes

  • One account per person's idea of "environment" with no owner. Reason: creating an account is easy. Avoid it with the owner-and-budget rule above.
  • Putting the audit logs in the account being audited. An administrator there can delete them. Logs go to a separate log archive account the workloads cannot modify (Centralised logging).
  • Running workloads in the management account "just for now". SCPs and RCPs do not restrict it, so it can never be governed. Move the workload out.
  • Splitting by technology layer ("a database account, an app account"). That creates cross-account calls on every request and little security gain. Split by environment, data scope, ownership and duties.
  • Using one shared e-mail inbox for every account root. One compromised mailbox then resets every account.
  • Assuming accounts are free to delete. A closed account stays in a 90-day post-closure period and still counts against your account quota.

Troubleshooting

SymptomLikely causeFix
AccessDeniedException on ListAccountsWrong account or profile: you are in a member accountRun aws sts get-caller-identity; use the learn-management profile
AWSOrganizationsNotInUseExceptionCalling Organizations from an account that is not in an organisationSign in to the management account
ConstraintViolationException: ACCOUNT_NUMBER_LIMIT_EXCEEDED when creating an accountThe organisation reached its account quotaRequest an increase in Service Quotas (management account) or close unused accounts and wait out the post-closure period
ConstraintViolationException: EMAIL_ALREADY_EXISTS style errorThe e-mail is already used by another AWS accountUse a unique address (plus-addressing often works, but check your mail system)
The program lists fewer accounts than the consolePagination not followedLoop on NextToken
ThrottlingExceptionToo many Organizations calls per secondAdd retries (the SDK has them) and reduce parallelism

Cost and cleanup

Cost: free. AWS Organizations has no charge. The CLI commands and the C# program are read-only, and Cost Explorer's console is included. What you have designed has a cost, which is worth estimating now: for each planned account, the monthly baseline of CloudTrail data events you choose to log, Config recorder items, GuardDuty and any NAT gateway or VPC endpoints.

# Cleanup: nothing was created. Confirm that nothing tagged for this lesson exists.
aws resourcegroupstaggingapi get-resources --tag-filters Key=Project,Values=cea-lab \
  --profile learn-sandbox --region us-east-1 --query "ResourceTagMappingList[].ResourceARN"

If you tried the Terraform account example against a real organisation, remember: do not run terraform destroy expecting the account to disappear. Close the account from the console (management account) and track the 90-day post-closure period ⚠ VERIFY current wording.

Exercises

  • 🟢 Guided: Run the seven-question test for Harbourline's Payments Service and write the result in a table like the one above. Then run the CLI inventory against your sandbox organisation and compare it with the structure you drew.
  • 🟡 Challenge: The Notifications Service starts sending marketing e-mail on behalf of a new team with its own budget and a looser change process. Decide whether it should move to its own account. Justify with the seven questions and name one cost of splitting.
  • 🔴 Live problem: The Head of Engineering says, "We have 14 accounts and two incidents of someone building production resources in the dev account. Cut it to 4." You think that would make things worse. Write the one-page response: what you would measure first, what you would automate, and which accounts (if any) you would merge.

Assignment

Produce docs/adr/0001-account-strategy.md in your portfolio repository: Context, Decision (account table with owner and monthly budget), Seven-question test results, What we did not split, Consequences (cost, access, quotas), Review date. Add the output of the CLI inventory as an appendix, with account IDs replaced by placeholders.

Solutions

Knowledge check

Interview questions

  • How would you decide how many AWS accounts a bank needs? Start from the questions "what must not hurt, see, starve or bill what?" and use environment, data scope, duties, ownership, quotas, lifecycle and function as the splitting criteria. Then automate the baseline so each account is cheap, and write the decision down with a review date.
  • What is the difference between an Azure subscription and an AWS account? A subscription is mainly a billing and quota scope under one tenant identity; an AWS account is also an independent IAM boundary, so it is a harder wall by default.
  • Why do banks separate the log archive from workload accounts? Segregation of duties and tamper resistance: the people and roles that run systems must not be able to alter the evidence about them.
  • What is the downside of too many accounts? Baseline cost multiplication, cross-account complexity, quota overhead and governance load. The remedy is automation, not fewer boundaries.

Certification practice

Completion checklist

  • I can list the five isolations an account provides and two things it does not
  • I ran the seven-question test on at least three Harbourline systems
  • I wrote the account-strategy decision record
  • I ran the inventory and understand every row
  • I confirmed this lesson left nothing billing

Key takeaways

  • An account is a container for identity, blast radius, quotas, billing and policy. Split by what must not affect what.
  • More accounts mean more baseline cost and plumbing. The answer is automation, not fewer accounts.
  • The management account runs no workloads; the log archive is outside every workload's reach.
  • Isolation is a claim: test it, and keep the evidence. Compliance is never automatic.

Further reading

Independent learning resource — not affiliated with, endorsed or sponsored by Amazon Web Services. AWS and related marks are trademarks of Amazon.com, Inc. or its affiliates. All banking data in examples is fictional. Sample architectures are for learning and are not automatically compliant with GDPR, PCI DSS or any banking regulation.

On this page