Architecture whiteboard practice
Practise timed architecture design sessions on six banking scenarios from Module 14, with a session format, must-hit checklists, common traps, strong-answer outlines and a scoring rubric you can run alone, with a colleague or with the AI assistant.
Assumes: .NET 10 LTS · AWS CLI v2 · Region us-east-1. Verified against official sources on 2026-11-18.
Learning objectives
By the end of this lesson you can:
- Run a 45-minute whiteboard session with a fixed timetable, alone or with a partner, and know what to do in each block.
- Produce, for six banking scenarios, a sketch that states requirements, numbers, data flow, failure behaviour, security controls and cost drivers.
- Hit the must-have points for each scenario and avoid its common traps.
- Score a session honestly against a rubric and choose one thing to improve next time.
- Handle interruptions ("what if it fails?", "why not X?", "halve the budget") without losing the thread.
- Turn a good whiteboard sketch into a short written design using the 15-section template.
Prerequisites
- Interview preparation: solutions architect for the seven-step framework, decision pairs and ADR template
- How to read and write a banking architecture
- Module 14 scenario lessons used below: Payment processing, Customer onboarding, Fraud-detection integration, Reconciliation, Customer notification systems and Disaster-recovery architecture
- Tools: a whiteboard or paper, a visible timer, and optionally the .NET 10 SDK (or Docker) for the scoring tool
Why this matters in banking
A design that exists only in your head cannot be reviewed, challenged or approved. In a bank, designs are defended in front of people who will ask the awkward question: "what happens to the customer's money if this fails halfway?" Whiteboard practice trains that reflex under time pressure. You learn to put the numbers, the data flow and the failure behaviour on the board before anyone has to ask.
It is also how you find your own weak spots cheaply. Most people discover in a practice session, not in a design review, that they never mention cost, or that they treat security as a final slide. The cost of that discovery is twenty minutes, not a project.
The idea in plain language
A whiteboard session is a timed rehearsal of the design conversation. You are not trying to produce the perfect architecture; you are practising a sequence: clarify, quantify, sketch, probe failures, decide, secure and cost, record. Each block has a time limit, and the discipline is to stop when the time is up and move on, because real discussions do not wait.
Analogy: It is like a pilot's simulator session. The scenarios are chosen to put you under pressure at the points where real flights go wrong (an engine failing at take-off). You repeat the drills until the checklist is automatic, so that in the real thing your attention is free for the unusual part.
The 45-minute timetable
| Minutes | Block | What you do | What to say aloud |
|---|---|---|---|
| 0 to 5 | Clarify | Ask ten questions; write the answers on the left of the board | "Let me confirm the requirements and what failure looks like." |
| 5 to 10 | Quantify | Rate, peak, size, retention, latency, RTO and RPO | "I am assuming… and I would validate…" |
| 10 to 20 | Sketch | Boxes, arrows, data flow, trust boundaries | "The simplest design that meets these numbers is…" |
| 20 to 30 | Probe failures | Table: component, failure, customer impact, detection, mitigation | "If this is slow, the customer sees…" |
| 30 to 35 | Decide | Two rejected alternatives per major choice | "I rejected X because… and I would switch if…" |
| 35 to 42 | Secure and cost | Identity, network, data, logging; three cost drivers; one saving | "The compliance touchpoints needing review are…" |
| 42 to 45 | Record | Assumptions, risks, the first thing to validate | "If I had a week I would first test…" |
For a shorter 30-minute session, drop the Record block and merge Secure and cost into Decide.
What problem the practice solves
It turns design reasoning from something you do when inspiration strikes into a routine you can run on demand. Honest limits:
- A 45-minute session produces a sketch, not a design. It cannot replace the 15-section document, load testing or a design review.
- Practising alone builds structure but not resilience to interruption. Do some sessions with another person.
- Model answers can mislead. The "strong-answer outlines" below show the shape and the points to hit, not the only correct design. If your design differs, check whether it meets the numbers and handles the failures.
Microsoft / Azure comparison
If you have run Azure architecture reviews, you already know the shape. The vocabulary shifts, the discipline is the same.
| You know (Microsoft/Azure) | AWS equivalent | What to practise saying |
|---|---|---|
| Architecture Decision Records and design authority | The same, with AWS service names | "Decision, alternatives, consequences, compliance touchpoints" |
| Azure Well-Architected pillars | AWS Well-Architected pillars (six, including sustainability) | Use the pillars as a failure and cost checklist |
| Azure landing zone and management groups | AWS Organizations, accounts, SCPs | "One account per workload and environment, guardrails at the organisation" |
| Azure Service Bus, Event Grid | SQS/SNS, EventBridge | Choose by pattern, state duplicates and ordering behaviour |
| Azure Front Door and WAF | CloudFront and AWS WAF | Edge protection, caching and what you would not cache |
| Azure paired regions | You choose the second Region | State the Region choice and the residency reason |
Architecture
How a session flows, and where the loops are
Sample solution 1: payment initiation with sanctions screening
Sample solution 2: reconciliation of ledger and partner file
Step-by-step implementation
Set up the room
Pick a scenario card from the next section. Start the timer, write the prompt at the top of the board, and divide the board into four zones: requirements and numbers (left), sketch (centre), failure table (right), decisions and risks (bottom). Sit or stand where you can see the clock.
Run the clarify and quantify blocks out loud
Say each question and write the answer. If you are practising alone, answer it yourself from the scenario card and mark any answer you had to invent as an assumption. Compute the numbers on the board, not in your head.
Sketch the simplest design
Draw the data flow first (who sends what to whom), then add trust boundaries and the data stores. Resist adding boxes: each box must have a reason you can say in one sentence.
Fill the failure table
For each component ask "slow, down, wrong, duplicated?" and write the customer impact, how you detect it and the mitigation. Aim for at least six rows. This block is where most of the score is.
Decide, secure, cost, record
Name two rejected alternatives for the two biggest decisions. Walk the security checklist, name three cost drivers, then state assumptions, risks and the first thing to validate.
Score and debrief
Score yourself (or have your partner score you) using the rubric tool. Write one sentence: "Next time I will…". Do not fix everything; fix one thing, then repeat with a different scenario.
The six scenario cards
Each card gives the prompt, the facts you may use, a must-hit list, the traps and a strong-answer outline. Numbers are fictional.
Scenario 1: payment initiation with sanctions screening (45 minutes)
Prompt: "Design the service that accepts a customer's outbound payment from the mobile app, screens it against a sanctions provider, sends it to the core banking system and tells the customer the result."
Facts: 2 million payments a day, peak ten times the average, 4 KB per payment, 7-year retention. The sanctions provider is an external HTTPS API with a 2-second typical response and occasional outages. Core banking is on premises behind private connectivity and handles at most 150 requests per second. The customer must see a status within 3 seconds of submitting.
Must hit:
- Idempotency key on submission, with a conditional write, so a retry cannot create a second payment.
- A decision on what happens when screening times out: hold for review, never release.
- Core banking rate limit respected with a queue and controlled concurrency (peak is about 230 per second, higher than the 150 limit, so buffering is not optional).
- Status model (received, screening, held, sent, completed, failed) and where the customer reads it.
- Saga or equivalent with compensation, and what "completed" means.
- Audit trail for every state change with a correlation ID.
Traps: releasing on screening timeout; synchronous end-to-end call chain with no buffer; using the queue message ID as the idempotency key; forgetting that core banking cannot take the peak.
Strong-answer outline: edge (CloudFront and WAF) to API Gateway with a Cognito authoriser; API on Fargate writes the payment and idempotency key with one conditional write and returns received; a state machine screens, then queues for core banking at a controlled rate; screening failures after bounded retries move the payment to held and alert operations; events go to EventBridge for notifications and an append-only audit store. Failure table rows: screening slow, screening down, core banking slow, duplicate submit, duplicate event, queue backlog, AZ loss. Cost drivers: Fargate tasks, Step Functions state transitions, DynamoDB writes and data transfer. See Payment processing for the full treatment.
Scenario 2: customer onboarding with identity verification (45 minutes)
Prompt: "Design digital onboarding: a new customer uploads an ID document and a selfie, an external KYC provider verifies them, and an account is opened if checks pass."
Facts: 20,000 applications a day, peak five times average. Documents up to 8 MB. Consent and retention rules apply (data protection team to confirm periods). The provider returns results asynchronously by webhook within minutes.
Must hit:
- Secure upload with pre-signed URLs, size and type limits and malware scanning before use.
- Encryption with a dedicated KMS key, private storage and short, explicit retention.
- Webhook handling: signature verification, idempotency, replay protection.
- A human review path for unclear results; consent capture recorded with a timestamp and version.
- Data minimisation: what is stored, for how long, who can read it.
Traps: passing documents through the API tier; storing documents in a public or shared bucket; trusting the webhook without signature checks; no deletion plan.
Strong-answer outline: pre-signed upload to a quarantine bucket, scan, then move to a restricted bucket; a state machine tracks the application; the provider webhook enters through API Gateway with HMAC verification and an idempotent handler; decisions and manual review go through a queue and a DynamoDB case table; audit events for each access; lifecycle rules enforce retention. Cost drivers: storage, scanning, the provider's per-check fee (outside AWS), data transfer.
Scenario 3: real-time fraud decision (30 minutes)
Prompt: "Add a fraud check to card authorisations. The decision must return in under 150 milliseconds. Some transactions need human review."
Facts: 1,500 authorisations a second at peak. Rules plus an optional ML score. The review team handles 3,000 cases a day.
Must hit:
- A latency budget broken down across hops, with a timeout and safe fallback for the score (rules only, with stricter thresholds, or a configured default per risk tier).
- Velocity counters held in a fast store with a clear window definition.
- A feedback loop for confirmed fraud and false positives.
- A review queue with SLAs, four-eyes for overrides and an audit record of every decision and its inputs.
- Generative AI, if mentioned, never makes the decision; at most it summarises for analysts.
Traps: a synchronous call to a slow model with no timeout; no fallback; storing full card numbers; treating model output as final; ignoring the services closed to new customers (do not design on Amazon Fraud Detector, SageMaker Clarify, Model Monitor or A2I).
Strong-answer outline: authorisation service calls a decision service in the same Region; rules and counters in memory-backed storage (ElastiCache or DynamoDB with a stated trade-off); optional SageMaker endpoint with a 40 ms timeout; decisions streamed through Kinesis for counters and for the review queue (SQS plus a case table); results logged with hashed identifiers. See Fraud-detection integration.
Scenario 4: daily reconciliation with a partner file (45 minutes)
Prompt: "Each morning a partner sends a file of yesterday's settled payments. Reconcile it with our ledger and report differences to operations."
Facts: 3 million rows a day, delivered by SFTP between 02:00 and 04:00, report needed by 07:00, differences expected in about 0.1 percent of rows.
Must hit:
- Landing zone with immutable raw storage, a checksum and a manifest.
- Validation with a quarantine for malformed rows, rather than failing the whole file.
- A deterministic matching key and rules for amount, date and currency tolerances.
- A breaks table with ageing, owner and four-eyes approval for adjustments.
- Re-runnable and idempotent: the same file processed twice gives the same result.
- A signed-off report and an audit trail.
Traps: matching in the ledger database during business hours; no handling for late or duplicate files; adjustments with no approval; losing the original file.
Strong-answer outline: Transfer Family into S3 with Object Lock; a state machine validates, converts to Parquet and runs match queries in Athena or Glue; breaks written to a table and a review queue; a report built into a restricted bucket; alarms on the 06:00 deadline. See Reconciliation architecture.
Scenario 5: customer notifications (30 minutes)
Prompt: "Design notifications for payments: push, email and SMS, with customer preferences, no duplicates and proof of delivery attempts."
Facts: 5 million notifications a day, bursts at month end. Customers choose channels. Some notifications are mandatory (security alerts) and cannot be switched off.
Must hit:
- Event-driven fan-out from payment events, with a preference lookup.
- Duplicate suppression with an idempotency key per event and channel.
- Retries with backoff, a DLQ, and provider sandbox, quota and reputation limits (separate transactional and marketing traffic).
- Mandatory versus optional notification rules.
- No sensitive data in the message body (use "log in to view").
Traps: one big synchronous loop; sending the full account balance by SMS; no handling of bounces and complaints; relying on Amazon Pinpoint, which has reached end of support (use SES, SNS or AWS End User Messaging; ⚠ VERIFY the dates).
Strong-answer outline: EventBridge routes events to an SQS queue per channel; a notification service checks preferences and writes a dedupe key before sending; SES for email, SNS or End User Messaging for SMS and push; delivery events return through EventBridge into a delivery log. See Customer notification systems.
Scenario 6: disaster recovery for payments (45 minutes)
Prompt: "The payments service has an impact tolerance of 60 minutes. Choose a DR strategy with an RTO of 30 minutes and an RPO of 5 minutes, and say how you would prove it works."
Facts: one primary Region, a second Region available, a relational ledger and a DynamoDB status table, budget is limited.
Must hit:
- The chain: important business service, impact tolerance, RTO and RPO, strategy.
- A strategy matched to the numbers (for example warm standby with cross-Region replication) and rejected alternatives (backup and restore too slow, active-active too costly for this tolerance).
- What is replicated, what is rebuilt from code, and the non-zero RPO of asynchronous replication covered by reconciliation.
- A failover decision process (who decides, how) and failback.
- Testing: game days, evidence, and what a failed test triggers.
Traps: claiming zero data loss; failover that nobody has rehearsed; forgetting DNS, secrets, KMS keys and certificates in the second Region; ignoring data residency.
Strong-answer outline: second Region built from the same IaC at reduced scale; Aurora global database or cross-Region replica for the ledger with measured lag; DynamoDB global tables for status ⚠ VERIFY suitability; KMS multi-Region keys where needed; Route 53 health checks with a manual or approved failover step; quarterly rehearsal with timed evidence. See Disaster-recovery architecture.
Handling interruptions
Interviewers and design reviewers interrupt on purpose. Practise these responses.
| Interruption | Response pattern |
|---|---|
| "What if this component fails?" | Name the failure, the customer impact, how you detect it, and the mitigation. Add the row to the table. |
| "Why not use X?" | Say what X is good at, why your constraint favours your choice, and the condition under which you would switch. |
| "Halve the budget." | Name what you cut first (over-provisioned redundancy, premium tiers), what you would not cut (logging, backups, security controls) and the risk you accept. |
| "Double the load." | Say which part saturates first, what you would measure, and the scaling lever. |
| "The regulator asks how you know it works." | Name the evidence: tests, game-day records, audit logs and reconciliation, and who reviews them. |
| "You have five minutes left." | Skip to security, cost and assumptions; say what you would do with more time. |
AWS Console instructions
Not applicable: whiteboard practice uses no console. To check a cost assumption while preparing, open Console → AWS Pricing Calculator and build a rough estimate; it bills nothing.
AWS CLI
Not applicable. If you want to check an assumption about your sandbox (for example, which Regions have your resources), a read-only command is enough.
# See which Regions your sandbox account has enabled (useful when you discuss Region choice).
aws account list-regions --region-opt-status-contains ENABLED ENABLED_BY_DEFAULT --profile learn-sandboxInfrastructure as Code
Not applicable: no infrastructure is deployed in this lesson. For each design, say that every component would be defined as code and deployed through a reviewed pipeline, so the whiteboard sketch maps to a repository.
Complete code
A whiteboard rubric scorer. After each session, enter seven scores from 0 to 4 (missing, weak, adequate, strong, excellent). It prints a weighted total out of 100 and names your two weakest areas by how much they could still add. The weights reflect what bank design authorities care about most: a design that fits the numbers, with failure analysis and security. It needs no AWS account.
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net10.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>enable</ImplicitUsings>
</PropertyGroup>
</Project>// Whiteboard self-scoring tool.
// Usage: dotnet run -- <requirements> <numbers> <design> <failures> <security> <cost> <communication>
// Each score is 0 to 4: 0 missing, 1 weak, 2 adequate, 3 strong, 4 excellent.
var categories = new (string Name, int Weight)[]
{
("Requirements and clarifying questions", 15),
("Quantification (rate, peak, size, RTO/RPO)", 10),
("Design fits the numbers", 20),
("Failure analysis", 20),
("Security and compliance touchpoints", 15),
("Cost reasoning", 10),
("Communication and time control", 10),
};
if (args.Length != categories.Length || !args.All(a => int.TryParse(a, out var s) && s is >= 0 and <= 4))
{
Console.Error.WriteLine($"usage: Rubric {string.Join(" ", categories.Select((c, i) => $"<score{i + 1}>"))} (each 0 to 4)");
for (int i = 0; i < categories.Length; i++)
Console.Error.WriteLine($" score{i + 1} = {categories[i].Name} (weight {categories[i].Weight})");
return 2;
}
var scores = args.Select(int.Parse).ToArray();
double total = 0;
for (int i = 0; i < categories.Length; i++)
{
double pct = scores[i] / 4.0 * categories[i].Weight;
total += pct;
Console.WriteLine($"{categories[i].Name,-45} {scores[i]}/4 {pct,5:F1} of {categories[i].Weight}");
}
Console.WriteLine($"{"TOTAL",-45} {total,5:F1} of 100");
// The two weakest categories, weighted by how much they could still add: that is your next practice focus.
var focus = Enumerable.Range(0, categories.Length)
.OrderByDescending(i => (4 - scores[i]) / 4.0 * categories[i].Weight)
.Take(2)
.Select(i => categories[i].Name);
Console.WriteLine("Practise next: " + string.Join(" and ", focus));
return 0;Run it after a session (this example scores a session that was good on requirements and communication but thin on failures and cost):
dotnet run -- 3 2 3 1 2 1 3Expected output:
Requirements and clarifying questions 3/4 11.2 of 15
Quantification (rate, peak, size, RTO/RPO) 2/4 5.0 of 10
Design fits the numbers 3/4 15.0 of 20
Failure analysis 1/4 5.0 of 20
Security and compliance touchpoints 2/4 7.5 of 15
Cost reasoning 1/4 2.5 of 10
Communication and time control 3/4 7.5 of 10
TOTAL 53.8 of 100
Practise next: Failure analysis and Security and compliance touchpointsCode explained line by line
categoriesis a tuple array of names and weights. Weights add to 100, so each category score converts directly to points.- Argument validation. The tool requires exactly seven integers from 0 to 4. A wrong input prints the usage and the meaning of each position and exits with code 2, so you never score the wrong column by accident.
- Scoring loop.
scores[i] / 4.0 * weightconverts a 0 to 4 score into points. Printing both lets you see which categories lose the most. - Total. A simple weighted sum. The number matters less than the trend across sessions.
- Focus. It sorts categories by the points still available:
(4 - score) / 4 * weight. That means a 1 out of 4 on a 20-point category (15 points available) ranks above a 0 out of 4 on a 10-point category (10 available). It points you to where practice pays most, not just where you are lowest. - Return code.
0on success so you can chain it in a script that appends results to a log of sessions.
Security considerations
⚠ Learning shortcut — not for production
A whiteboard sketch leaves out almost everything that makes a design safe: detailed IAM policies, network rules, key policies, logging configuration and data-classification decisions. Treat sketches as a conversation tool. Before building from a sketch, write the 15-section document and have security, compliance and operations review it.
- Use fictional or generic examples. Never describe a current or past employer's real architecture, vendors, incidents or data volumes in a practice session or a public portfolio.
- Say the controls, not just the boxes. For every scenario you should name identity, encryption, logging and the compliance touchpoints needing review.
- Do not claim compliance. State which controls the design supports and who must confirm them (compliance, legal, a qualified assessor for PCI).
- Design the unhappy path for security. Replay attacks on webhooks, stolen tokens, an insider with direct data access, and what you log to detect them.
- Do not paste real customer or card data into practice tools, including AI assistants. Use test data and official test card ranges only.
Banking use case
Priya, a fictional candidate, is practising scenario 1 with a colleague playing the interviewer. In the clarify block she asks who owns the status the customer sees, whether the sanctions provider has a rate limit, and what the bank wants when screening is down. The colleague answers: "Hold for review". Priya writes it on the board as a requirement, not an assumption.
In the quantify block she computes 23 payments a second on average and about 230 at peak, notices that core banking handles 150, and writes "buffer and control concurrency" in red. In the failure block she lists screening slow, screening down, duplicate submit, queue backlog and core banking slow, and tells the interviewer what the customer sees in each case. The colleague interrupts: "Halve the budget." Priya says she would drop the second Fargate task size and use on-demand DynamoDB, keep the audit log, the idempotency key and the hold-on-failure rule, and accept slower status updates at peak.
Scored afterwards she gets 3 for requirements, 3 for numbers, 3 for design, 3 for failures, 2 for security (she forgot webhook signing for the partner callback), 2 for cost and 3 for communication. The rubric tool says to practise security and cost next. She chooses scenario 2 for the next session because it has more security content.
Common mistakes
- Skipping clarification. Why: the sketch feels like progress. Avoid: do not touch the centre of the board until the left side has numbers.
- Over-drawing. Why: more boxes feel more thorough. Avoid: if you cannot justify a box in one sentence, remove it.
- Failing to stop on time. Why: perfectionism. Avoid: obey the timer; a rough answer to every block beats a perfect answer to the first.
- No numbers. Why: arithmetic feels slow. Avoid: compute average, peak and storage on the board every time.
- Happy-path only. Why: failure analysis is uncomfortable. Avoid: fill the failure table before deciding services.
- Practising only your strongest scenario. Why: it feels good. Avoid: rotate through all six and repeat the lowest-scoring one.
- Marking yourself generously. Why: bias. Avoid: have a partner score, or record yourself and score from the recording.
Troubleshooting
| Symptom | Likely cause | Fix |
|---|---|---|
| You run out of time in the sketch block | Too many components | Draw only the data path first and add boxes only to meet a stated need |
| The failure table is thin | You think in components, not failure types | Use the four prompts for each component: slow, down, wrong, duplicated |
| You cannot decide between two services | Missing criteria | Write the three criteria that matter (consistency, cost, operations) and score each |
| Your numbers look wrong | Unit mix-ups or missing peak factor | Redo with units written on the board: per second, per day, KB, GB |
| Your partner finds your answers vague | Missing specifics | Replace "scalable" and "secure" with a mechanism and a number |
| Practice feels the same each time | No progression | Add an interruption, reduce the time, or change a constraint (halve the budget) |
| Your score plateaus | You fix many things at once | Choose one improvement per session and track it |
| You rely on services closed to new customers | Out-of-date knowledge | Check the service availability notes in the module overview and the research findings before you design |
Cost and cleanup
Cost: free. Whiteboard practice uses no AWS resources. If you prototype any part of a design in the sandbox, use the cheapest option, tag it and delete it the same day.
# Clean up local build output for the rubric tool.
rm -rf bin obj
# If you prototyped anything in the sandbox, list what is tagged for practice and delete it.
aws resourcegroupstaggingapi get-resources --tag-filters Key=Project,Values=whiteboard-practice \
--profile learn-sandboxExercises
- 🟢 Guided: Do scenario 1 alone in 45 minutes using the timetable. Photograph the board, score yourself with the rubric tool, and write one sentence: "Next time I will…".
- 🟡 Challenge: Do scenario 4 (reconciliation) with a partner who interrupts at least three times, including "halve the budget". Compare your own score with theirs and explain any gap of more than one point.
- 🔴 Live problem: A product owner says: "We want to launch instant payments between customers next quarter." Without a scenario card, run the whole seven-step session: what do you ask, what do you assume, what is your sketch, what fails, what do you refuse to promise, and what is the first thing you would prototype?
Assignment
Create a whiteboard portfolio: for three of the six scenarios, a photographed or redrawn sketch, the failure table, two ADRs for the main decisions, the rubric scores for the first and last attempt and a paragraph on what changed. Add a short note on how you would turn each sketch into the 15-section document. Use fictional data only.
Solutions
A strong scenario 1 board has: requirements on the left (idempotency, hold on screening failure, 3-second status, audit trail), numbers (23 per second average, about 230 at peak, 150 per second at core banking so a buffer is needed, 4 KB and 7 years), a data-flow sketch (edge, API, idempotency write, state machine, screening, queue to core, events), a failure table with at least seven rows and a decisions list (DynamoDB for payment state and idempotency keys with the relational ledger left in core banking; SQS or Step Functions for buffering; Fargate over Lambda for steady API traffic) with a rejected alternative for each. Common gaps: forgetting that peak exceeds the core banking limit, and leaving "what does the customer see?" out of the failure table. If your board lacks either, that is your next-time sentence.
Gaps between self-score and partner score usually come from the same causes: you gave yourself credit for something you thought but did not say, or you counted a mention as analysis. The rubric rewards what is on the board and spoken. If your partner scores failures lower than you, check whether each failure row had all five columns (component, failure, impact, detection, mitigation). On "halve the budget", a strong response names what is cut (idle capacity, premium tiers, over-retention of logs beyond policy), what is protected (the audit trail, idempotency, backups, security controls) and the accepted risk. The point of the exercise is learning to hold your structure while someone changes the problem.
Clarify: is "instant" a scheme requirement (an external payment scheme with its own rules) or an internal target, what limits apply, what are the fraud and screening requirements, what is the availability target and what happens when the receiving side is unavailable? Quantify: expected volume, peak, latency budget and RTO and RPO. Sketch: reuse the payment saga but with tighter timeouts, synchronous screening within a budget and a fast path to the scheme connection. Failure: scheme unavailable, timeouts after a payment was sent (the dangerous case), duplicates and reversals. Refuse to promise: "instant" with no data on the external scheme's availability, and zero data loss. First prototype: the timeout-after-send case, because the design must make it recoverable (idempotency, reconciliation and a status lookup). Compliance touchpoints go to the payments compliance team for review. The reason this works is that unclear prompts are resolved by questions and numbers, not by guessing a design.
Knowledge check
Answer: Probing failures, together with the design fitting the numbers. The rubric gives failure analysis 20 points because bank design reviews turn on what happens when things break, and because it is the block most candidates rush or skip.
Answer: A client retry creates a new message, so the message ID changes while the payment is the same. The key must be the business key supplied at submission, so duplicates from clients, queues and consumers are all recognised.
Answer: Retry within a short bounded budget, then hold the payment for review and tell the customer it is delayed. It must never release a payment without a screening answer, and the behaviour should be agreed with compliance before an incident.
Answer: Name what you would cut and the risk you accept, name what you would protect (audit trail, backups, idempotency, security controls) and say what you would measure to confirm the cut is safe. Refusing to cut anything or cutting controls both score poorly.
Answer: Replication is asynchronous, so the most recent writes may not have reached the second Region when the primary fails. The gap is measured as replication lag, and the design covers it with reconciliation and by setting the RPO target honestly.
Interview questions
- Talk me through how you practise architecture design. Timed sessions with a fixed timetable, six rotating scenarios, a failure table every time, a rubric score and one improvement per session.
- What do you do in the first five minutes of any design discussion? Ask about users, scale, data, regulation, failure behaviour and constraints, and write the answers and assumptions where everyone can see them.
- How do you show you have thought about failure? A table of components against failure types, with customer impact, detection and mitigation, and explicit safe behaviours such as hold on screening failure.
- How do you handle being told your design is wrong? Ask for the constraint, restate the reasoning with the numbers, concede valid points and say what would change the decision.
- How would you explain this design to a non-technical stakeholder? Start from what the customer sees, then the main risks and costs in plain terms, and keep the diagram at one level of detail.
Certification practice
A service receives work faster than a downstream system can process it, which supports 150 requests per second while peak input is 230 per second. Which approach best protects the downstream system?
A. Increase the downstream system's timeout. B. Place a queue between them and control consumer concurrency. C. Retry every failed request immediately without delay. D. Reject all requests above 150 without telling the clients.
Answer: B. A queue absorbs the burst and the consumer rate is capped at what the downstream can handle. A hides the problem, C amplifies load, and D loses requests silently.
A bank needs to receive a daily partner file by SFTP, retain the original unchanged, process it repeatably and quarantine malformed rows. Which design fits best?
A. Receive the file with AWS Transfer Family into S3 with Object Lock, then validate and process in a workflow that writes bad rows to a quarantine location. B. Receive the file on an EC2 instance and edit it in place. C. Email the file to operations and process it manually. D. Load the file directly into the production ledger database.
Answer: A. It preserves the original, supports repeatable processing and isolates bad rows. B alters the original, C is manual and untracked, and D risks corrupting the ledger.
A payments service requires an RTO of 30 minutes and an RPO of 5 minutes with a limited budget. Which strategy is the best starting point?
A. Backup and restore from daily snapshots. B. Warm standby in a second Region with continuous replication and a rehearsed failover. C. Multi-Region active-active with synchronous writes everywhere. D. A single large instance in one Availability Zone.
Answer: B. Warm standby with replication can meet a 30-minute RTO and 5-minute RPO at moderate cost if it is rehearsed. Daily snapshots (A) cannot meet the RPO, active-active (C) exceeds the requirement and cost, and a single instance (D) offers no resilience.
Completion checklist
- I can recite the 45-minute timetable and what to do in each block
- I completed at least three of the six scenarios and scored them
- I filled a failure table with at least six rows for each completed scenario
- I practised with at least one interruption of each type
- I can name the next improvement from my last score
- I ran the cleanup steps and confirmed no practice resources remain
Key takeaways
- A whiteboard session is a timed routine: clarify, quantify, sketch, probe failures, decide, secure and cost, record.
- Numbers and failure analysis carry the most weight; put them on the board before services.
- Each scenario has a must-hit list; use it to check, not to memorise a single design.
- Practise interruptions, because real reviews are interactive.
- Score honestly, fix one thing per session and rotate scenarios.
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.
Interview preparation: solutions architect
Prepare for a solutions architect interview: elicit requirements, size a system on the back of an envelope, justify service choices against rejected alternatives, reason about security, resilience and cost, and record decisions the way a bank's design authority expects.
Portfolio guide: presenting your seven capstones
Turn the seven capstone projects into a portfolio a hiring manager can assess in ten minutes: a landing page, a README, diagram, ADR, cost and teardown standard for each capstone, a three-minute demo script, a blameless incident report and a hygiene checker for secrets and compliance claims.