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.
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
- AWS accounts and Organizations: the vocabulary (management account, member account, OU, SCP). This lesson is the design reasoning that lesson did not have room for.
- Secure your AWS account and Cost guardrails: your sandbox organisation and budgets.
- Policy evaluation logic: why a deny in one place wins everywhere.
- Tools: AWS CLI v2 with the
learn-managementSSO profile (read-only commands only), optionally the .NET 10 SDK.
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
| Isolation | What it means in practice | What it stops |
|---|---|---|
| Identity | Every 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 it | A compromised developer role in dev reaching production data |
| Blast radius | A mistake or an attacker is limited to what the account's identities can reach | One bad script deleting everything |
| Quotas | Most service quotas apply per account per Region | A load test starving production |
| Billing | Every charge is attributed to an account | "Who spent this?" without perfect tagging |
| Policy | Organisation policies (SCPs, RCPs, tag policies) can differ per account or OU | Strict 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.
| # | Question | Typical Harbourline answer |
|---|---|---|
| 1 | Environment: would a mistake in dev, test or sandbox be able to touch production data? | Yes, so one account per environment |
| 2 | Data 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 |
| 3 | Segregation 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 |
| 4 | Ownership: does a different team own the budget, roadmap or on-call for it? | Often yes, so one account per team per environment |
| 5 | Quota and noisy neighbour: could its load or experiments exhaust shared quotas? | Yes for load-test and data-platform jobs |
| 6 | Lifecycle and risk: is it short-lived, experimental or untrusted? | Yes, so sandboxes and acquired code get separate accounts |
| 7 | Function: 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 equivalent | What's different |
|---|---|---|
| Entra ID tenant (one identity plane for everything) | IAM Identity Center for people; separate IAM in every account | In 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 account | An account is also the identity boundary, not only billing and quotas, so it is a stronger wall |
| Management groups | AWS Organizations OUs | Similar inheritance of policy; OUs nest up to five levels |
| Resource group (lifecycle and RBAC scope) | Tags, CloudFormation stacks, or a separate account | There is no resource group with RBAC; the nearest hard boundary is the account |
| Azure Policy at subscription scope | SCPs, RCPs, tag policies at OU or account | SCPs only cap permissions and never grant any |
| Subscription quota requests | Service Quotas, per account per Region | Many quotas are per Region as well, so a multi-Region design multiplies requests |
| Landing zone accelerator | AWS Control Tower, or your own IaC landing zone | See 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.
- 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.
- Open Policies → Service control policies. Note
FullAWSAccessand your Region guardrail from Module 0, and which targets each is attached to. - 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.Organizationsusing 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
new AmazonOrganizationsClient()uses the default credential chain. WithAWS_PROFILE=learn-managementit picks up your SSO profile; there are no keys in the code.- 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). - The
do … whileloop followsNextToken.ListAccountsreturns pages, and forgetting to page is a classic bug that works fine with 10 accounts and silently hides account 11 onwards. page.Accounts ?? []is there because in SDK v4 collection properties arenullwhen the service returns nothing, not empty lists.ListTagsForResourceis 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.- The program returns exit code
1when 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:
| Account | Why it exists (questions) | Owner |
|---|---|---|
harbourline-management | Billing and Organizations only | Cloud platform |
log-archive | Q3 duties, Q6 immutability | Security |
security-tooling | Q3 duties | Security |
network-hub | Q7 function | Network |
shared-services | Q7 function (CI/CD runners, artefacts) | Platform |
payments-prod / payments-dev | Q1 environment, Q2 card scope, Q5 quota | Payments |
dataplatform-prod / dataplatform-dev | Q1, Q2 (personal data), Q5 (large jobs) | Data |
notifications-prod / notifications-dev | Q1 environment (but see below) | Notifications |
sandbox-<engineer> | Q6 lifecycle | The 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
| Symptom | Likely cause | Fix |
|---|---|---|
AccessDeniedException on ListAccounts | Wrong account or profile: you are in a member account | Run aws sts get-caller-identity; use the learn-management profile |
AWSOrganizationsNotInUseException | Calling Organizations from an account that is not in an organisation | Sign in to the management account |
ConstraintViolationException: ACCOUNT_NUMBER_LIMIT_EXCEEDED when creating an account | The organisation reached its account quota | Request an increase in Service Quotas (management account) or close unused accounts and wait out the post-closure period |
ConstraintViolationException: EMAIL_ALREADY_EXISTS style error | The e-mail is already used by another AWS account | Use a unique address (plus-addressing often works, but check your mail system) |
| The program lists fewer accounts than the console | Pagination not followed | Loop on NextToken |
ThrottlingException | Too many Organizations calls per second | Add 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
Payments scores yes on Q1 (production money movement must be unreachable from dev), Q2 (card or card-adjacent data should have the smallest possible audit scope), Q3 (the people who run payments are not the people who audit its logs), Q4 (a dedicated Payments team owns the roadmap and budget) and Q5 (a payment peak must not be throttled by another team's batch job). That gives payments-prod and payments-dev. The CLI inventory should show your management account, your sandbox account and the accounts you created in Module 0. Notice that your sandbox sits in a Sandbox OU: Q6.
Q1: no change, it is production either way. Q4: yes, a different team and budget, but ownership alone is a weak reason if the systems are identical. Q6: marketing e-mail has a faster change cadence and higher risk of mistakes (wrong list, wrong send rate). Q5: a campaign blast can exhaust SES or SNS quotas the transactional alerts need. Reasonable decision: split, mainly for Q5 and Q6, so a marketing mistake cannot throttle fraud alerts. Cost of splitting: another set of baseline services, cross-account roles for shared templates, a second budget to monitor, and a second place for on-call to look.
Measure first: how many accounts have no owner, how many resources were created in the wrong account (CloudTrail CreateXxx calls by environment tag), and what the per-account baseline costs. The two incidents were caused by missing guardrails, not too many accounts, so the fix is an SCP or Terraform pipeline rule that stops production-tagged resources being created in dev, plus a single approved deployment path. Automate account creation and the baseline so accounts become cheap. Merge only accounts with the same owner, same data scope and same environment (for example two idle dev accounts for one team). Cutting to 4 would put dev and prod back together, which recreates the blast-radius problem that justified accounts in the first place.
Knowledge check
Answer: No, not by default. IAM is per account. The role has no identity in prod, and the prod bucket's policy would need to grant access to that principal (or the prod account's own role trust policy would need to trust it). Admin in one account is power over that account only.
Answer: (c). Connecting accounts with Transit Gateway or peering creates a network path. Security groups and route tables decide what flows. Roles, quotas and billing remain per account.
Answer: SCPs and RCPs do not restrict it, so guardrails cannot be applied to anything running there, and anyone with access to it can administer the whole organisation. Keep it to billing and organisation administration.
Answer: Any two of: per-account baseline services (CloudTrail data events, Config, GuardDuty), duplicated network components, cross-account roles and policies to maintain, separate quota requests, an owner and on-call, and the account limit and closure delays.
Answer: Logs delivered to a dedicated log archive account that workload accounts and engineers cannot modify, protected by bucket policy, Object Lock and an SCP. Logging in the same account the engineers administer is a weak answer because an administrator can change it.
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
A company runs a production payments API and a developer test environment. Auditors require that developers cannot access production data and that a runaway test cannot affect production capacity. The team wants the least operational effort that meets both needs. What should they do?
A) Use one account with separate VPCs and IAM tags for each environment. B) Use separate AWS accounts for production and development under AWS Organizations. C) Use one account and an SCP that denies developers production resources. D) Use separate Regions for each environment in one account.
Answer: B. Accounts separate identity and service quotas, so both requirements hold with no extra tagging logic. A relies on tag discipline and shares quotas. C is wrong because SCPs do not apply in a single account with no Organizations hierarchy, and an SCP is a ceiling, not an isolation boundary for quotas. D separates data location but not identity or account-level quotas (Region quotas are separate, but the identity wall is not).
A security team must ensure that engineers who administer workload accounts cannot delete the audit logs of those accounts. Which design best meets the requirement?
A) Store logs in an S3 bucket in each workload account with MFA delete. B) Deliver logs to a bucket in a separate log archive account that workload principals cannot modify. C) Give engineers read-only IAM policies for CloudTrail. D) Rely on CloudTrail log file validation alone.
Answer: B. A separate account puts the logs outside the administrators' identity boundary. A leaves an administrator of that account able to change policies. C does not stop a role with broader permissions elsewhere. D detects tampering but does not prevent deletion.
Which statement about AWS accounts is correct?
A) All IAM users in an organisation share one set of IAM policies. B) An AWS account is a boundary for resources, identities and billing. C) AWS accounts cannot be grouped for centralised billing. D) Every AWS account in the world shares one service quota.
Answer: B. IAM is per account (A wrong), AWS Organizations provides consolidated billing (C wrong) and quotas are per account and Region (D wrong).
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.
Module 15: Multi-Account Governance & FinOps
Set up and govern many AWS accounts the way a bank must: organisational units, guardrails, central logging and security tooling, and evidence an auditor can use. You also learn FinOps, so every team can see, explain and reduce what it spends.
AWS Organizations structure: OUs, the management account and policy inheritance
Design an OU tree for a bank, keep the management account nearly empty, attach policies so they inherit correctly, and check the whole design with a tested validator before you touch a real organisation.