How to read and write a banking architecture
Use the 15-section architecture template, measurable non-functional requirements and architecture decision records to produce a design a bank's design authority can approve, and check your own documents with a small C# linter.
Assumes: .NET 10 LTS (file-based apps) · AWS Well-Architected Framework · Mermaid diagrams · Region us-east-1. Verified against official sources on 2026-11-18.
Learning objectives
By the end of this lesson you can:
- Explain what a design authority (architecture board) checks, and why a design that "works" can still be rejected.
- Write each of the 15 sections of the module's architecture template, and say what separates a strong section from a weak one.
- Turn a vague business wish into measurable non-functional requirements (latency, availability, RPO/RTO, throughput, retention).
- Record a decision as an architecture decision record (ADR) that names the alternatives you rejected and the consequences you accept.
- Read someone else's architecture critically using a short question list, and run a C# linter that flags missing sections.
- Mark every compliance statement as "needs specialist review" instead of claiming a design is compliant.
Prerequisites
- Cloud architecture fundamentals and the Well-Architected introduction
- Threat modelling with STRIDE for the security-architecture section
- Operational resilience and third-party risk for impact tolerances
- Tools: a text editor and, optionally, the .NET 10 SDK or Docker for the linter in this lesson
Why this matters in banking
You have probably already built something a bank depends on. Now picture the meeting where it is judged. A payments service is proposed. The developer demonstrates it working. Then the design authority, a panel of senior architects plus representatives from security, risk, compliance and operations, asks questions the demo cannot answer:
- "What happens to a payment in flight when the sanctions provider times out?"
- "Which AWS accounts hold the ledger, and who can read it?"
- "How long can this service be down before it breaks our stated impact tolerance?"
- "Where is the evidence that the control you describe actually runs?"
- "Why this service and not the one the platform team already operates?"
Teams that cannot answer in writing get sent away for another cycle, often weeks. Teams that answer well get approval with conditions. The difference is rarely cleverness. It is structure: a document that puts the same questions in the same order every time, so the reviewers can find the answer, or see at once that it is missing.
This lesson gives you that structure. It is the foundation for every other lesson in Module 14: each later lesson applies the template to one banking domain.
Educational content, not legal or regulatory advice
Everything here uses the fictional Harbourline Bank. Where a design touches KYC/AML, sanctions, PSD2-style open banking, PCI DSS, UK GDPR or operational resilience, this module tells you which team must review and what to ask them. It never states that a design "is compliant". Statements about specific regulations carry a ⚠ VERIFY marker until your own legal or compliance function confirms them.
The idea in plain language
An architecture document is an argument, not a diagram. The diagram is one piece of evidence. The argument runs like this:
- Here is the problem and its measurable targets (sections 1 to 3).
- Here is the shape of the solution (sections 4 to 10).
- Here is how it fails, grows and costs (sections 11 to 13).
- Here is how we will build it, and who must still approve parts of it (sections 14 and 15).
A reader who disagrees with a design should be able to point at a specific section and say "I disagree with this choice because...". If they cannot, the document is too vague to review.
Analogy: a building's architectural drawings. The floor plan (diagram) matters, but the planning office also wants the fire-escape routes (failure scenarios), the load calculations (scalability), the materials list and cost (service selection, cost) and a list of the inspections still required (compliance touchpoints). A beautiful floor plan with none of those is not a submission.
The 15-section template
| # | Section | The question it answers | A weak answer looks like | A strong answer looks like |
|---|---|---|---|---|
| 1 | Business requirements | Why are we doing this, and what is out of scope? | "Modernise payments" | "Cut average card-to-account posting time from 4 hours to under 60 seconds for retail current accounts; corporate payments out of scope" |
| 2 | Functional requirements | What must the system do? | A feature list with no actors | Numbered requirements per actor, each testable ("Customer can cancel a payment until it is submitted") |
| 3 | Non-functional requirements | How well, how fast, how safe? | "Highly available, secure" | "99.95% monthly availability for initiation; p99 under 800 ms; RPO 0 for ledger, RTO 15 min" |
| 4 | Architecture diagram | What are the parts and how do they connect? | One box labelled "AWS" | Context and container diagrams, numbered flows, trust zones drawn |
| 5 | Service selection | Why these services, and why not the others? | A list of services | A table: service, role, reason, rejected alternative, trade-off accepted |
| 6 | Network architecture | What can reach what? | "Runs in a VPC" | Subnet tiers, endpoints, egress path, how on-premises is reached, which flows are blocked |
| 7 | Security architecture | Who can do what, and what is encrypted? | "Uses IAM and KMS" | Identity flows, key hierarchy, data classification, logging, STRIDE threats mapped to controls |
| 8 | API design | What is the contract? | A list of endpoints | Resources, idempotency, error model, versioning, auth scopes, rate limits |
| 9 | Database design | Where does each fact live, and who owns it? | "DynamoDB" | Tables or schemas, keys, access patterns, consistency needs, retention |
| 10 | Data flow | What path does a piece of data take, and what is stored along the way? | Arrows with no data names | One numbered flow per use case, naming payload, store and classification at each hop |
| 11 | Failure scenarios | What breaks, and what happens next? | "Retries on failure" | A table: failure, detection, automatic response, customer impact, manual step |
| 12 | Scalability | What happens at 10 times the load? | "Auto Scaling" | Peak model, first bottleneck, scaling trigger, quotas that must be raised |
| 13 | Cost | What does it cost to run and to build? | "Pay as you go" | Monthly estimate with assumptions, top three cost drivers, cost per transaction |
| 14 | Implementation steps | In what order do we build it, and how do we know each step worked? | A to-do list | Phased plan, each phase with an exit test and a rollback |
| 15 | Compliance touchpoints | Which obligations touch this design, and who must review? | "Compliant with GDPR" (a claim you cannot make) | Table: obligation area, where it touches the design, reviewing team, evidence needed |
Two rules make the template work:
- Every section is mandatory. Writing "not applicable, because..." is allowed. Silence is not.
- Sections cross-reference. A failure scenario in section 11 should name the component from section 4 and the control from section 7.
What problem the AWS services solve
This lesson is about documents more than services, but AWS publishes guidance that you should use instead of inventing your own criteria.
| Resource | What it gives you | Limits and sharp edges |
|---|---|---|
| AWS Well-Architected Framework | Six pillars (operational excellence, security, reliability, performance efficiency, cost optimisation, sustainability) with question sets | Generic. It tells you what to consider, not what to build |
| Financial Services Industry Lens | Well-Architected guidance specific to regulated financial workloads | Guidance, not a certification. Check the current lens text; it is updated over time ⚠ VERIFY current structure |
| AWS Well-Architected Tool | A console service for running a structured review and tracking improvements | Records answers and risks; does not validate your design |
| AWS Architecture Center and Solutions Library | Reference architectures and deployable guidance, sometimes with infrastructure-as-code | A reference is a starting point. You still own every decision in it |
| AWS Prescriptive Guidance | Patterns and process guides, including guidance on decision records ⚠ VERIFY exact title | Written for a general audience; add your bank's standards |
Honest limitation: none of these produces an approved design. The approval comes from your own organisation's reviewers, who apply the bank's policies.
Microsoft / Azure comparison
| You know (Microsoft/Azure) | AWS equivalent | What's different |
|---|---|---|
| Azure Architecture Center, Cloud Adoption Framework | AWS Architecture Center, Well-Architected, Cloud Adoption Framework | Both are guidance libraries. AWS ties its review to six pillars and a console tool |
| Azure Well-Architected Review | AWS Well-Architected Tool | Same idea: workload-level questions, results become an improvement plan |
| Azure Landing Zone design areas | AWS multi-account landing zone (Control Tower, Organizations) | The account is the main isolation boundary in AWS, so "which account?" belongs in every design |
| Architecture decision records in a repo (Markdown) | Same practice, tool-neutral | No AWS product replaces a Git-reviewed ADR folder |
| Visio, draw.io, Structurizr | draw.io with AWS icons, Mermaid in Markdown, Structurizr | Text-based diagrams diff in pull requests; this course uses Mermaid |
| Azure Policy / Defender for Cloud recommendations as "architecture evidence" | AWS Config, Security Hub, Audit Manager | Section 15 evidence often comes from these services |
Architecture
The review pipeline
How the 15 sections connect
Notice that non-functional requirements (section 3) feed three later sections. If you leave them vague, failure, scalability and cost all become guesswork.
Security-boundary view of the documents themselves
Architecture documents describe sensitive things: network layouts, control gaps, partner connectivity. Treat them as internal-confidential artefacts.
| Asset | Where it lives | Who can change it | Control |
|---|---|---|---|
| ADR folder | Git repository, protected main branch | Authors via pull request, reviewers approve | Branch protection, signed commits where the bank requires them |
| Diagrams as code | Same repository | Same | Reviewed like code |
| Approved baseline | Tagged release or wiki export | Design authority secretary | Read-only after approval; changes need a new ADR |
Step-by-step implementation
Start with the NFR table, not the diagram
Write section 3 first. Use this format and refuse to proceed while any cell says "high", "fast" or "secure":
| Quality | Target | How measured | Source of the target |
|---|---|---|---|
| Availability (payment initiation) | 99.95% per calendar month | Synthetic probe plus success ratio of POST /payments | Business service owner |
| Latency | p99 under 800 ms for POST /payments, excluding scheme settlement | API Gateway and application metrics | Product requirement |
| Durability of ledger | No acknowledged posting is ever lost (RPO 0) | Multi-AZ commit plus reconciliation | Risk appetite statement |
| Recovery time | RTO 15 minutes for initiation, 4 hours for reporting | DR game-day timing | Impact tolerance for the important business service ⚠ VERIFY your firm's tolerance |
| Throughput | 200 payments per second sustained, 800 at peak | Load test | Volume forecast |
| Retention | Payment records 7 years ⚠ VERIFY with compliance | Lifecycle rules, Object Lock | Records-retention policy |
Why: every later choice is justified against these numbers. "99.95%" allows about 22 minutes of downtime in a 30-day month. If a design cannot meet that arithmetic, you find out in section 11, not in production.
Draw context first, then containers
Use the C4 model levels. Level 1 (context): your system, its users and the external systems it talks to. Level 2 (containers): the deployable parts (service, database, queue). Stop there for the authority pack. Component-level diagrams belong with the team that builds it. Number every arrow and refer to the numbers in section 10.
Fill section 5 as a decision table
For each service write a row with: role, why chosen, the alternative you rejected, and the trade-off you accept. The rejected-alternative column is the one reviewers read first, because it shows you considered more than one option.
Write the failure table before the happy path is polished
List at least eight failures. Include one each from: dependency timeout, duplicate request, poison message, data-store throttling, Availability Zone loss, credential or key problem, bad deployment, and a malicious or erroneous input. For each: how it is detected, what the system does by itself, what the customer sees, and what a human must do.
Record each significant decision as an ADR
Use a short, stable template (below). One decision per record. Never edit an accepted ADR to change history; write a new one that supersedes it.
Finish with section 15, and keep it honest
List each obligation area that touches the design, the place in the design where it touches, the team that must review, and the evidence you will collect. Do not write "satisfies" or "complies". Write "requires review by".
Lint the document, then ask a colleague to attack it
Run the linter below to catch missing sections, then give the document to a colleague with the question list in "Reading someone else's architecture".
AWS Console instructions
The AWS Well-Architected Tool is the one console service that supports this lesson. It is free to use (you pay only for the resources you review, not for the tool ⚠ VERIFY current pricing).
- Console → Well-Architected Tool → Define workload.
- Enter a name such as
harbourline-payments-design, environment type Pre-production, and select the Regions and accounts that apply. - Apply the Financial Services Industry Lens if it is offered for your workload ⚠ VERIFY availability, then answer the questions for the pillars you are reviewing.
- Open Improvement plan to see the high-risk issues and copy them into section 11 or 14 of your document.
Use fictional workload names in the sandbox. Do not paste real account IDs or customer information into any review tool.
AWS CLI
# List the Well-Architected lenses available to your account (read-only call).
aws wellarchitected list-lenses --profile learn-sandbox --region us-east-1
# Create a workload record for the design review. Fictional names only.
aws wellarchitected create-workload \
--workload-name harbourline-payments-design \
--description "Learning design review for the Harbourline payments architecture" \
--environment PREPRODUCTION \
--review-owner "learner@example.com" \
--lenses wellarchitected \
--aws-regions us-east-1 \
--tags Project=cea-lab,Lab=m14-l1,Environment=learn,Owner=learner \
--profile learn-sandbox --region us-east-1The second command creates a small metadata record with no running resources. The --review-owner value is an email-style string; use a reserved example.com address. If the CLI rejects a flag, check aws wellarchitected create-workload help for the current shape ⚠ VERIFY.
Infrastructure as Code
An architecture's IaC is evidence for section 14. For this lesson, the useful IaC is the repository structure for your documents. Tools like CDK and Terraform come in the later lessons.
architecture/
payments/
README.md # the 15-section document
diagrams/
context.mmd # Mermaid source, reviewed in pull requests
containers.mmd
adr/
0001-use-step-functions-for-payment-saga.md
0002-fail-closed-when-screening-unavailable.md
0003-dynamodb-for-idempotency-aurora-for-ledger.md
evidence/
nfr-test-results.md
failure-game-day-2026-11.mdComplete code
The linter below is a single-file .NET 10 program. It reads a Markdown architecture document and reports which of the 15 sections are missing, which are suspiciously short, and whether banned compliance phrases appear.
// Run with: dotnet run ArchLint.cs -- path/to/README.md
// (.NET 10 file-based app: no project file needed.)
using System.Text.RegularExpressions;
string[] required =
[
"business requirements", "functional requirements", "non-functional requirements",
"architecture diagram", "service selection", "network architecture",
"security architecture", "api design", "database design", "data flow",
"failure scenarios", "scalability", "cost", "implementation steps",
"compliance touchpoints",
];
string[] bannedPhrases = ["is compliant", "fully compliant", "guarantees compliance", "meets all requirements"];
const int minWords = 40;
if (args.Length != 1 || !File.Exists(args[0]))
{
Console.Error.WriteLine("Usage: dotnet run ArchLint.cs -- <architecture.md>");
return 2;
}
var text = File.ReadAllText(args[0]);
// Split into sections at level-2 headings: "## 3. Non-functional requirements"
var headingPattern = new Regex(@"^##\s+(?:\d+[.)]?\s*)?(?<title>.+?)\s*$", RegexOptions.Multiline);
var matches = headingPattern.Matches(text);
var sections = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
for (var i = 0; i < matches.Count; i++)
{
var start = matches[i].Index + matches[i].Length;
var end = i + 1 < matches.Count ? matches[i + 1].Index : text.Length;
var body = text[start..end];
var words = Regex.Matches(body, @"\b[\w'-]+\b").Count;
sections[matches[i].Groups["title"].Value.Trim()] = words;
}
var problems = 0;
foreach (var name in required)
{
var found = sections.Keys.FirstOrDefault(k => k.Contains(name, StringComparison.OrdinalIgnoreCase));
if (found is null)
{
Console.WriteLine($"MISSING {name}");
problems++;
}
else if (sections[found] < minWords)
{
Console.WriteLine($"THIN {name} ({sections[found]} words; write 'not applicable because...' or add detail)");
problems++;
}
}
foreach (var phrase in bannedPhrases)
{
if (text.Contains(phrase, StringComparison.OrdinalIgnoreCase))
{
Console.WriteLine($"CLAIM contains '{phrase}': say 'requires review by <team>' instead");
problems++;
}
}
if (!text.Contains("rejected", StringComparison.OrdinalIgnoreCase))
{
Console.WriteLine("HINT no 'rejected' alternatives mentioned: section 5 should name at least one per service");
}
Console.WriteLine(problems == 0 ? "OK: all 15 sections present." : $"{problems} problem(s) found.");
return problems == 0 ? 0 : 1;Code explained line by line
- The
requiredarray holds the lower-case section names. Matching is by "contains", so## 5. AWS service selection and rejected alternativesstill matchesservice selection. bannedPhrasesencodes the course rule that an architecture document never asserts compliance. A regex or a code-review bot can enforce it in a pull request.File.ReadAllText(args[0])loads the whole document. Documents are small, so there is no need to stream.- The
headingPatternregex matches level-2 Markdown headings and strips an optional leading number such as3.or3).RegexOptions.Multilinemakes^match at each line start. - The loop slices the text between one heading and the next (
text[start..end]is a C# range on a string) and counts words with a second regex. - A section under 40 words is reported as
THIN. The point is not the number; it is forcing an explicit "not applicable, because..." instead of an empty heading. - The exit code is 0 only when nothing is wrong, so you can run the tool in a CI step (see Module 9) and fail a pull request that touches the architecture folder.
Security considerations
⚠ Learning shortcut — not for production
The linter checks structure, not truth. A document can contain all 15 sections and still be wrong. In production, pair automated structure checks with a human review by the design authority, and generate evidence (IaC scans, test reports, Security Hub findings) rather than trusting the prose.
- Do not put secrets or real identifiers in architecture documents. Use placeholders such as
ACC-0000000001and fictional account IDs. - Classify the document. A network diagram showing partner connectivity is useful to an attacker. Store it where access is limited to staff.
- Threat model the design, not just the code. Section 7 should reference the STRIDE threats you found, and each should map to a control. See threat modelling.
- Treat "approved" as a version. Pin the approved document to a Git tag so later edits cannot silently change what the board saw.
Banking use case
Harbourline Bank wants a new faster-payments initiation service. The product owner's request: "customers should be able to send money instantly, safely."
Run the template:
- Section 1 turns "instantly" into a target: scheme acceptance within seconds for 99% of payments, with clear status for the other 1%.
- Section 3 turns "safely" into: duplicate-free under client retry (idempotency), fail-closed when screening is unavailable, and tamper-evident audit records.
- Section 5 forces a choice between Step Functions orchestration and in-service orchestration, recorded as an ADR with the alternative rejected.
- Section 11 is where the sanctions provider outage is discussed in daylight, rather than discovered at 02:00.
- Section 15 lists payments-scheme rules, sanctions obligations, data-protection impact assessment, operational resilience and third-party risk, each with a named reviewing team.
Later lessons do exactly this for payment processing, customer onboarding and others.
An ADR template and an example
# 0002. Fail closed when sanctions screening is unavailable
Status: Accepted (2026-11-18)
Deciders: Payments architect, Financial-crime compliance lead, Head of operations
## Context
Payments are screened by an external provider. The provider has had two
short outages in the past year (fictional figure). During an outage we must
either release payments unscreened or hold them.
## Decision
Hold the payment (status PendingReview) after three bounded retries.
Never release a payment because screening could not complete.
## Alternatives considered
1. Fail open (release if provider is down): rejected. Unacceptable risk of
unscreened payments; regulator and sponsor-bank consequences need review.
2. Second provider as hot standby: deferred. Adds cost and a second
third-party risk assessment. Revisit if PendingReview volume exceeds the
agreed threshold.
## Consequences
+ No unscreened payment can leave the bank.
- During an outage customers see "pending" instead of "sent".
- Operations needs a review queue and an SLA to clear it.
## Compliance touchpoints
Financial-crime compliance must confirm the retry window and hold policy. ⚠ VERIFYReading someone else's architecture
When you review a design, ask these in order. They map to the sections.
- Section 3: which number would make this design wrong? If none, the targets are not measurable.
- Section 4: can I trace one payment from the customer to the ledger along numbered arrows?
- Section 5: for each service, what was rejected and why?
- Section 6 and 7: where are the trust boundaries, and what authenticates each crossing?
- Section 9: who owns each fact? Is any fact written by two services?
- Section 11: what does the system do when each dependency is slow, not just when it is down?
- Section 13: what is the cost per transaction, and what doubles it?
- Section 15: who has actually reviewed the regulatory points, or is it still an aspiration?
Common mistakes
- Starting with the diagram. The picture then drives the requirements, instead of the other way round. Write sections 1 to 3 first.
- Service lists with no alternatives. Reviewers cannot tell whether you chose or defaulted. Always record what you rejected.
- "Highly available" without arithmetic. State the percentage and compute the allowed downtime. 99.9% is about 43 minutes in a 30-day month; 99.99% is about 4 minutes.
- Happy-path-only documents. The failure section is where the real design lives.
- Claiming compliance. Replace with "requires review by". The linter above flags the common phrases.
- Editing accepted ADRs. History becomes untrustworthy. Supersede instead.
- One giant diagram. Use context, containers, then flows. A diagram that needs a magnifying glass communicates nothing.
Troubleshooting
| Symptom | Likely cause | Fix |
|---|---|---|
Linter reports MISSING for a section that exists | Heading is level 3 (###) or the title lacks the expected words | Use ## headings and include the section name, e.g. ## 7. Security architecture |
Linter reports THIN for a short but valid section | Fewer than 40 words | Add "not applicable because..." with a reason, or expand |
dotnet run ArchLint.cs says it needs a project | Older SDK than .NET 10 | Use the .NET 10 SDK or run in the mcr.microsoft.com/dotnet/sdk:10.0 image |
| Mermaid diagram does not render in the repository viewer | Syntax error or unsupported feature | Test in the Mermaid live editor; keep diagrams simple |
aws wellarchitected create-workload returns a validation error | A required parameter is missing or a flag name changed | Run the command with help and compare ⚠ VERIFY |
| Reviewers keep asking the same question | Section is missing or buried | Add it to the section list and cross-reference from related sections |
Cost and cleanup
This lesson is free: it is a document exercise. The optional Well-Architected Tool workload is metadata only.
# Remove the optional workload record. First list to find the workload id.
aws wellarchitected list-workloads --profile learn-sandbox --region us-east-1
# Delete it (replace the id with the value from the list output).
aws wellarchitected delete-workload --workload-id <workload-id> --profile learn-sandbox --region us-east-1
# Check nothing tagged for the course remains (Resource Groups Tagging API).
aws resourcegroupstaggingapi get-resources --tag-filters Key=Project,Values=cea-lab \
--profile learn-sandbox --region us-east-1Exercises
- 🟢 Guided: take the one-paragraph request "build a service that lets customers see their statements online" and write sections 1, 2 and 3 as three small tables. Every non-functional target must have a number.
- 🟡 Challenge: write ADR 0003 deciding between DynamoDB and Aurora PostgreSQL for the idempotency store. Include two rejected alternatives and the consequences you accept. Run the linter on a document containing your ADR reference in section 5.
- 🔴 Live problem: your design authority rejected a design with the note "failure handling not credible". You have two days. Read the design in the solution below, find at least five missing failure scenarios, and write the failure table for section 11.
Assignment
Create a folder architecture/statement-portal/ in your portfolio repository with a README that contains all 15 sections for a small statement-viewing service (fictional), two Mermaid diagrams (context and container), and two ADRs. The linter must pass. Add a short "Compliance touchpoints" table with no compliance claims.
Solutions
Section 1 (business): Let retail customers download the last 24 months of statements without calling the contact centre. Success: contact-centre statement requests fall by 40% within six months (fictional). Out of scope: business accounts, statement redesign.
Section 2 (functional):
| ID | Actor | Requirement |
|---|---|---|
| F1 | Customer | Sees a list of statement periods for each of their own accounts |
| F2 | Customer | Downloads a PDF for a chosen period |
| F3 | Customer | Cannot see any other customer's statements |
| F4 | Operations | Can regenerate a statement and see an audit trail |
Section 3 (non-functional):
| Quality | Target |
|---|---|
| Availability | 99.9% monthly (about 43 minutes allowed downtime in 30 days) |
| Latency | List: p95 under 500 ms. Download start: p95 under 2 s |
| Durability | Statements are immutable once generated; 7-year retention ⚠ VERIFY |
| Security | Every download authenticated and logged with customer and account id |
| Recovery | RTO 4 hours, RPO 1 hour |
Why: each target is a number with an implied way to measure it, and F3 turns a security concern into a testable functional requirement.
Decision: DynamoDB for idempotency records; Aurora PostgreSQL for the ledger.
Rejected alternatives:
- Aurora for idempotency as well: rejected because every payment would then contend on one relational primary for a pure key lookup, and the conditional put in DynamoDB gives the needed atomic "insert if absent" with automatic expiry via TTL.
- ElastiCache for idempotency: rejected because a cache is allowed to lose data, and a lost key means a duplicate payment.
Consequences: two data stores to operate and secure; idempotency records and ledger rows are not in one transaction, so the design must tolerate "key claimed, payment never posted" by letting a retry resume. That is covered by the saga in payment processing.
Missing scenarios to look for: duplicate client retry while the first request is still running; dependency timeout where the dependency did receive the request; poison message in the queue; DynamoDB throttling on a hot key; Availability Zone loss mid-saga; expired or rotated credential or certificate for a partner; bad deployment that changes message format; clock skew affecting idempotency expiry; operator error such as redriving a dead-letter queue twice.
For each write: detection signal, automatic response, customer impact and manual step. "Credible" means a reviewer can tell what actually happens, not that nothing goes wrong.
Knowledge check
Answer: Service choices are justified against measurable targets. Without numbers (latency, availability, recovery time) you cannot show a choice is appropriate, and reviewers cannot test it. Choosing first and inventing targets afterwards produces designs that merely describe what was built.
Answer: It proves that a decision was made rather than defaulted, and it records the trade-off accepted. When circumstances change, the rejected alternatives are the first options to revisit.
Answer: Write a new ADR that supersedes the old one and update the old record's status to "Superseded by NNNN". Editing the old record would hide the history that explains why the system looks the way it does.
Answer: The second. An architecture document cannot establish compliance; qualified people assess the whole system, its processes and its contracts. The document identifies where the obligation touches the design and who must review it.
Answer: About 4 minutes (30 days is 43,200 minutes, and 0.01% of that is 4.32). If the design depends on a partner API with lower availability, the arithmetic shows the target is unreachable without a mitigation such as queueing.
Interview questions
- What do you put in an architecture document beyond a diagram? Measurable requirements, service choices with rejected alternatives, failure scenarios, cost, and a list of compliance touchpoints with owners. The diagram is one piece of evidence.
- How do you decide a design is ready for the design authority? Peers cannot find a missing section, every non-functional target has a number and a measurement method, the failure table covers dependency, duplicate, capacity and security failures, and specialist reviews are booked.
- How do you keep decisions from being lost? Architecture decision records in Git, one per decision, immutable once accepted, superseded rather than edited.
- A reviewer says "this will not scale". What do you do? Ask for the load number they believe is wrong, then show the peak model, the first bottleneck and the quota or scaling trigger from section 12. If those are missing, the criticism is fair.
- Why does multi-account design belong in every architecture? The AWS account is the strongest isolation boundary for blast radius, permissions and billing. A design that does not say which account holds each component has not made a security decision.
Certification practice
A bank's architecture board rejects a proposed workload because the document states "the system will be highly available and secure" and shows only a diagram. Which action best addresses the board's objection?
A. Add more AWS services to the diagram to show resilience. B. Replace the prose with measurable targets (availability percentage, latency percentile, RPO, RTO), map each to a design element and record rejected alternatives. C. Add a statement that the design complies with all applicable regulations. D. Ask the AWS account team to approve the design.
Answer: B. Boards need testable claims and visible trade-offs. A adds complexity without evidence. C is an unverifiable claim that a document cannot establish. D substitutes a vendor's opinion for the bank's own governance.
A payments service must tolerate the loss of one Availability Zone without losing acknowledged payments. Which statement belongs in the failure-scenarios section as the automatic response?
A. Operators restore the database from last night's backup. B. The multi-AZ database fails over to a standby and in-flight requests are retried idempotently. C. The service is redeployed manually in another Region. D. Customers are asked to resubmit payments.
Answer: B. An automatic response must need no human. A and C are manual, slow and risk data loss. D pushes the failure onto customers and risks duplicates unless idempotency is in place.
Which section of the architecture template should show where encryption keys live and who can use them?
A. Business requirements B. Cost C. Security architecture D. Implementation steps
Answer: C. The security architecture section covers identity, key hierarchy, data classification and logging. D may list the steps to create keys, but the design of key ownership and use belongs in section 7.
Completion checklist
- I can name the 15 sections and say what question each answers
- I wrote section 3 with numbers for every target
- I recorded at least one ADR with a rejected alternative
- I ran the linter and fixed what it found
- My compliance section says "requires review by", never "complies"
- I ran the cleanup steps if I created a Well-Architected Tool workload
Key takeaways
- An architecture document is an argument: measurable requirements first, then design, then failure, scale and cost.
- Every section is mandatory; "not applicable, because..." is acceptable, silence is not.
- Record decisions as immutable ADRs that name the alternatives you rejected.
- Never claim compliance in a design: say where an obligation touches it and who must review.
- Use the Well-Architected Framework and the Financial Services Industry Lens as question lists, not as approval.
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 14: Advanced Banking Architecture
Apply everything from earlier modules to real banking use cases, from customer onboarding and payments to fraud signals, reconciliation and regulatory reporting. Every architecture follows the same 15-section template so you practise the full reasoning a solutions architect presents to a design authority.
Digital banking platform: channels, BFF APIs, identity and sessions
Design the reference architecture for a retail digital banking platform on AWS: edge protection, a backend-for-frontend per channel, OIDC sign-in with step-up authentication, short-lived sessions, and the 15-section write-up a design authority expects.