Skip to Content
Cloud Engineering Academy
17. Daily-Work Playbooks & Career

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.

advanced⏱ 2 h 🟢 FreeSAA-C03SAP-C03

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:

  • Explain what an architect interview scores: requirements thinking, trade-off reasoning, security and failure analysis, cost awareness and communication.
  • Use a repeatable seven-step framework to run a design discussion: clarify, quantify, sketch, probe failures, decide, secure and cost, record.
  • Do a back-of-envelope sizing (rate, peak, storage, retention) in two minutes and state the assumptions.
  • Defend a service choice against two rejected alternatives for common banking decisions (database, messaging, compute, resilience level, account structure).
  • Write a short architecture decision record (ADR) and explain what a bank's design authority wants in it.
  • Handle the questions architects dread: "what would you do differently with half the budget?", "why not just use X?" and "what if you are wrong?".

Prerequisites

Why this matters in banking

A solutions architect in a bank does not mainly draw boxes. The role translates a business need ("let customers see a payment's status in real time") into a design that survives audit, failure and cost review, and then persuades several groups to accept it: engineers, security, operations, compliance, finance and a design authority. Mistakes cost money in a particular way: an over-engineered design wastes budget for years, and an under-engineered one fails in front of customers or regulators.

Interviewers for these roles are looking for one thing above the rest: can you make a defensible decision with incomplete information, and show your reasoning? They will not hold you to one right answer. They will notice if you skip the requirements, never mention failure, or choose a service because it is fashionable.

Market and salary claims

This lesson makes no claims about architect hiring, titles or pay. They differ by country, bank and year. Use current job postings and your recruiter. ⚠ VERIFY anything you read elsewhere.

The idea in plain language

An architecture discussion is a structured conversation about trade-offs, not a quiz. Every design choice gives up something to gain something else. Your job is to make the trade-off visible:

You gainYou pay
Multi-AZ resilienceRoughly double the always-on capacity, plus cross-AZ data transfer
Strong consistencyLatency and sometimes throughput
Managed servicesLess control, service limits and sometimes cost at scale
Event-driven designEventual consistency, harder tracing, duplicate handling
Multi-account isolationMore setup, networking and identity complexity
Cheapest optionOperational risk, or a rebuild when requirements change

Analogy: An architect is like a structural engineer for a bank branch. The client says "I want it open plan, cheap and able to survive an earthquake". You do not say yes to all three. You ask what each is worth, what the building code requires, and where the budget goes, and then you explain what you are trading.

The seven-step framework

Use the same seven steps every time. It keeps you calm and makes the interviewer's job easy.

StepWhat you doRoughly
1. ClarifyAsk about users, scale, data, regulation, existing systems and what "done" means5 minutes
2. QuantifyTurn the scale into numbers: rate, peak, size, retention, latency, RTO, RPO5 minutes
3. SketchDraw the simplest design that meets the numbers, with the data flow10 minutes
4. Probe failuresWalk through what happens when each part fails or is slow10 minutes
5. DecideChoose services; for each name two alternatives you rejected and why5 minutes
6. Secure and costIdentity, network, encryption, logging; rough monthly cost and its biggest drivers5 minutes
7. RecordState assumptions, risks and what you would validate first2 minutes

What problem the interview solves

The employer wants to know whether you can lead a design without a checklist. The honest limits for you:

  • A 45 to 60 minute session produces a sketch, not a design. Say so, and say what you would do with more time.
  • There is usually no single right answer. A design with a clear rationale and acknowledged risks beats a polished diagram with no reasoning.
  • Interviewers sometimes push back on a good choice to see whether you hold your position with evidence or fold. Neither stubbornness nor instant agreement scores well; reason aloud.

Microsoft / Azure comparison

You can reuse the way you reason about Azure and translate the vocabulary. Your starting point is the same: requirements, constraints, trade-offs.

You know (Microsoft/Azure)AWS equivalentWhat to say in an interview
Azure Well-Architected FrameworkAWS Well-Architected Framework (six pillars: operational excellence, security, reliability, performance efficiency, cost optimization, sustainability)Same discipline; AWS adds sustainability as its own pillar. Use pillars as a checklist for failure and cost questions
Azure Landing Zones and management groupsAWS Organizations, Control Tower, SCPsAccount-per-workload and environment is the usual boundary; guardrails at organisation level
Availability Zones and paired regionsAvailability Zones within a Region; no built-in Region pairsAWS Regions are independent, so you choose the second Region for DR yourself
Azure Front Door, API ManagementCloudFront, API GatewayBoth front an API with caching, auth and protection; know the limits and cost drivers
Service Bus, Event Grid, Event HubsSQS/SNS, EventBridge, KinesisChoose by pattern: queue (work), pub/sub (fan-out), event bus (routing and schema), stream (ordered high volume)
Cosmos DB, Azure SQLDynamoDB, Aurora or RDSChoose by access pattern and consistency needs; be ready to explain the cost model
Azure Policy and Defender for CloudConfig, Security Hub, GuardDuty, SCPsPreventive guardrails plus detective findings, with a human process for response
Architecture review boardThe bank's design authorityPrepare an ADR and a 15-section document, not a slide deck

Architecture

The discussion flow

A worked sketch: payment status service

Use a sketch this size. If you cannot explain every box and arrow in two minutes, it is too big.

Step-by-step implementation

Build a clarifying-question set

Memorise ten questions you always ask: Who are the users and how many? Which data is personal, financial or card data? What are the latency, availability and recovery targets (RTO, RPO)? What must it integrate with? What are the regulatory constraints (data residency, audit, PCI)? What is the budget shape? What already exists? What is the rollout and rollback plan? Who runs it afterwards? What does failure look like to a customer?

Practise sizing in two minutes

Convert any scale statement to a rate and a storage number using the sizing sketch in the Complete code section. State the peak factor and the assumptions out loud. Interviewers care that you size to the peak and retention, not to a vague "large".

Prepare the decision pairs

For each common decision, prepare a one-minute comparison with a default and when you would switch. The comparison table in the next section is a start; extend it with your own experience.

Rehearse failure walk-throughs

For each of your standard designs, take every component and ask: what if it is slow, down, wrong or duplicated? Write the answer in a table: component, failure, customer impact, detection, mitigation. Do this aloud until it is automatic. The payment saga failures lab is good practice.

Practise recording a decision

Write three ADRs (template below). Practise explaining one in 90 seconds: context, decision, alternatives, consequences.

Do two timed whiteboard sessions

Use the exercises in Architecture whiteboard practice, and ask a colleague or the AI assistant to interrupt with "what if it fails?" at least three times.

Decision pairs worth rehearsing

Each answer begins with the default, then the reason to switch. Use "it depends" only if you follow it with what it depends on.

DecisionDefault and whySwitch when
Database for paymentsAurora PostgreSQL or RDS for relational integrity, joins and mature tooling (and, for SQL Server shops, RDS SQL Server)DynamoDB when the access pattern is key-based at very high scale with predictable queries and you accept designing around it
Database for session or idempotency keysDynamoDB: conditional writes, TTL, single-digit-millisecond accessA relational store if you need ad hoc queries across keys
MessagingSQS for work queues with retries and a DLQSNS or EventBridge for fan-out and routing; Kinesis for ordered, high-volume streams and replay
ComputeFargate for steady APIs and consumersLambda for bursty or event-driven work; EC2 only for special needs (licensing, GPU, specific OS control)
ResilienceMulti-AZ in one Region for most workloadsMulti-Region active-passive or active-active only when the impact tolerance requires it, because it is complex and expensive
Account structureOne account per workload and environment, under an organisation with guardrailsA shared account only for small, low-risk sandboxes
Integration with core bankingPrivate connectivity, a thin anti-corruption layer and asynchronous messaging where possibleSynchronous calls only where the customer journey truly needs an immediate answer
Build or buyBuy or use managed services for undifferentiated workBuild where the capability is your differentiator or regulation demands control

For every row, practise the sentence: "I would start with X because Y, and I would move to Z if A became true."

Security reasoning checklist

Run through these in order whenever you finish a sketch.

LayerQuestionTypical answer
IdentityWho and what can call this?Cognito or the bank's IdP for customers, roles for workloads, Identity Center for staff, least privilege
NetworkWhat is exposed?Public edge only through CloudFront/WAF and API Gateway; private subnets; VPC endpoints for AWS services
DataHow is it protected?Encryption at rest with KMS keys you control, TLS in transit, field-level protection for the most sensitive data
SecretsWhere do credentials live?Secrets Manager with rotation; no secrets in code or images
LoggingCan you reconstruct what happened?CloudTrail, application audit events with correlation IDs, logs in a protected archive
DetectionHow would you notice an attack?GuardDuty, Security Hub, alarms on denied calls and unusual egress
GovernanceWhat stops a mistake?SCPs, Config rules, IaC review, change control
ComplianceWhat needs review?Name the touchpoints (PCI scope, data residency, retention) and say who confirms them. Never claim "compliant"

Cost reasoning checklist

You do not need exact prices; you need the shape and the drivers.

  1. Identify the three biggest cost drivers in the design (for example compute hours, data transfer, log ingestion, database capacity).
  2. Say what scales with usage and what is fixed. Fixed costs (NAT gateways, load balancers, always-on tasks) matter for small workloads; per-request costs matter at scale.
  3. Name the cheap wins: gateway endpoints for S3 and DynamoDB, right-sized tasks, log retention, Savings Plans once usage is stable.
  4. State the price assumption and say you would check the pricing calculator. For example: "I am assuming roughly four cents per GB through a NAT gateway ⚠ VERIFY, so I would put S3 behind a gateway endpoint."
  5. Say what you would cut with half the budget and what you would never cut (logging, backups, security controls).

ADR template

adr-0007-payment-status-store.md
# ADR 0007: Store payment status in DynamoDB

- **Status:** Proposed
- **Date:** 2026-11-18
- **Deciders:** Platform architect, payments lead, security representative

## Context
Customers need to see the status of a payment within two seconds. Peak is about 230 reads per second.
Status is written by an event projector and read by the API. Data is classified as confidential.

## Decision
Use a DynamoDB table keyed by payment ID, encrypted with a customer-managed KMS key, with point-in-time recovery.

## Alternatives considered
1. Aurora PostgreSQL: familiar and relational, but status lookups are key-based and a database cluster is a larger fixed cost for this read pattern.
2. ElastiCache only: very fast but not durable enough to be the system of record.

## Consequences
- Fast, predictable lookups and no capacity management at this scale.
- Queries beyond the key need extra indexes or a separate reporting store.
- The projector must be idempotent because events can be delivered more than once.

## Compliance touchpoints (needs review, not asserted)
Retention period and deletion rules to be confirmed with the data protection team.

AWS Console instructions

Not applicable: this lesson is about reasoning and communication. If an interviewer asks you to demonstrate, be ready to open Console → AWS Pricing Calculator to build an estimate and Console → Billing and Cost Management → Cost Explorer to explain an existing cost.

AWS CLI

Not applicable for the discussion itself. If asked how you would check an existing design, say: list resources by tag to see what exists, inspect configuration for encryption and public access, and read CloudTrail and Config for change history.

# Inventory what a project owns, by tag (a safe, read-only way to start reviewing an estate).
aws resourcegroupstaggingapi get-resources --tag-filters Key=Project,Values=harbourline-payments \
  --query 'ResourceTagMappingList[].ResourceARN' --profile learn-sandbox

Infrastructure as Code

Not applicable: no infrastructure is deployed in this lesson. In a design discussion, say that every box in your sketch would be defined as code, reviewed in a pull request and deployed through a pipeline with approvals, so the design and the evidence stay in step.

Complete code

A back-of-envelope sizing tool. Use it to rehearse, then do the same arithmetic in your head. It computes average and peak rate, a DynamoDB-style write-unit estimate, data per day, retained data and a storage cost at a price you supply. The default price is an assumption, flagged as such in the output. It needs no AWS account.

CapacitySketch.csproj
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>
</Project>
Program.cs
using System.Globalization;

// Back-of-envelope capacity sketch for an architecture interview.
// Usage: dotnet run -- <daily-payments> <peak-factor> <payload-kb> <retention-years> [usd-per-gb-month]
// Every price is an ASSUMPTION you state out loud; look the real one up before you commit to a number.
if (args.Length < 4)
{
    Console.Error.WriteLine("usage: CapacitySketch <daily-payments> <peak-factor> <payload-kb> <retention-years> [usd-per-gb-month]");
    return 2;
}

var inv = CultureInfo.InvariantCulture;
var input = new Inputs(
    DailyPayments: double.Parse(args[0], inv),
    PeakFactor: double.Parse(args[1], inv),
    PayloadKb: double.Parse(args[2], inv),
    RetentionYears: double.Parse(args[3], inv),
    UsdPerGbMonth: args.Length > 4 ? double.Parse(args[4], inv) : 0.023);

var r = Sketch.Calculate(input);

Console.WriteLine($"Average rate        : {r.AverageTps,10:F1} payments/s");
Console.WriteLine($"Peak rate           : {r.PeakTps,10:F1} payments/s (x{input.PeakFactor:F0} the average)");
Console.WriteLine($"Write units at peak : {r.PeakWriteUnitsPerSecond,10:F0} per second (DynamoDB-style: 1 per KB, rounded up)");
Console.WriteLine($"Data per day        : {r.GbPerDay,10:F1} GB");
Console.WriteLine($"Data kept           : {r.TotalGb,10:F0} GB over {input.RetentionYears:F0} years");
Console.WriteLine($"Storage cost        : {r.MonthlyStorageUsd,10:F0} USD/month at the end, at {input.UsdPerGbMonth} USD per GB-month (assumption)");
Console.WriteLine("Say out loud: peak, not average, sizes the system; retention, not today's volume, sizes the storage.");
return 0;

public sealed record Inputs(double DailyPayments, double PeakFactor, double PayloadKb, double RetentionYears, double UsdPerGbMonth);

public sealed record Result(double AverageTps, double PeakTps, double PeakWriteUnitsPerSecond,
                            double GbPerDay, double TotalGb, double MonthlyStorageUsd);

public static class Sketch
{
    public static Result Calculate(Inputs i)
    {
        double avg = i.DailyPayments / 86_400d;
        double peak = avg * i.PeakFactor;
        double unitsPerWrite = Math.Ceiling(i.PayloadKb);          // 1 write unit per KB, rounded up
        double gbPerDay = i.DailyPayments * i.PayloadKb / (1024d * 1024d);
        double totalGb = gbPerDay * 365d * i.RetentionYears;
        return new Result(avg, peak, peak * unitsPerWrite, gbPerDay, totalGb, totalGb * i.UsdPerGbMonth);
    }
}

Run it for the fictional Harbourline payments service (2 million payments a day, peak ten times the average, 4 KB each, kept 7 years):

dotnet run -- 2000000 10 4 7

Expected output (values rounded as shown):

Average rate        :       23.1 payments/s
Peak rate           :      231.5 payments/s (x10 the average)
Write units at peak :        926 per second (DynamoDB-style: 1 per KB, rounded up)
Data per day        :        7.6 GB
Data kept           :      19493 GB over 7 years
Storage cost        :        448 USD/month at the end, at 0.023 USD per GB-month (assumption)
Say out loud: peak, not average, sizes the system; retention, not today's volume, sizes the storage.

Code explained line by line

  1. Arguments. Four required inputs and one optional price keep the tool honest: every number is visible and changeable. A wrong count exits with code 2.
  2. CultureInfo.InvariantCulture. Parsing numbers with the invariant culture avoids a 2,000,000 or decimal comma problem on a machine set to another locale.
  3. Average rate. Daily volume divided by 86,400 seconds in a day. About 23 per second sounds tiny, which is why sizing to the average is a classic mistake.
  4. Peak rate. Average times a peak factor. Banking traffic is bursty (salary days, end of month, market events), so a factor of 5 to 20 is realistic. State your assumption and why.
  5. Write units. For DynamoDB-style pricing, one write unit is one write of up to 1 KB, so a 4 KB item costs 4 units. The Math.Ceiling models rounding up.
  6. Data per day and retained data. Daily volume times payload size, then times 365 and the retention in years. Seven years of 7.6 GB a day is about 19.5 TB, which changes the storage design (lifecycle tiers, archive) far more than the rate does.
  7. Storage cost at an assumed price. The price is a parameter and is printed beside the result. In an interview you say "assuming roughly this price, which I would verify".
  8. Last line. It prints the lesson: peak sizes capacity and retention sizes storage. Say it while you do the arithmetic.

Security considerations

⚠ Learning shortcut — not for production

The sizing tool ignores replication, indexes, backups, encryption overhead, log volume and growth. A real estimate includes all of them and is checked in the AWS Pricing Calculator. Treat the output as a conversation aid, never as a budget or a commitment.

  • Never invent numbers in a way that sounds like facts. Label assumptions. A confident, wrong number on a whiteboard becomes a budget line in a real project.
  • Security is part of the design, not a final slide. Mention identity, network, data protection, logging and detection while you sketch, not at the end.
  • Do not claim compliance. Say which controls the design supports and who must confirm them (compliance, legal, the QSA for PCI).
  • Confidentiality. Do not describe a current or past employer's actual architecture, diagrams, vendors or incidents. Use a fictional or generic example.
  • Data residency and retention are decisions for legal and data protection teams. Raise them as questions, with the assumptions you made until answered.

Banking use case

Harbourline wants to show customers real-time payment status in the mobile app. The interviewer gives you the prompt and ten minutes of questions to answer.

A strong candidate runs the seven steps. Clarify: how many customers and payments a day, what "real time" means (two seconds?), where status originates (core banking events), the availability target (99.9 percent?), RTO and RPO, data classification and residency, and whether the app already has authentication. Quantify: 2 million payments a day, peak ten times the average gives about 230 per second, 4 KB of data each, kept 7 years, so about 19 TB retained (using the sizing tool). Sketch: the diagram above. Probe failures: the projector falls behind (the status is stale, so show "updating" and alarm on queue age), a duplicate event (idempotent projector), a DynamoDB throttle (on-demand mode or capacity headroom, retries with backoff), an AZ loss (multi-AZ by design), and a Region loss (accept a longer recovery for status, because the payment system of record is elsewhere; say so as a trade-off). Decide: DynamoDB over Aurora because the access pattern is key-based, with the alternative and the switch condition stated. Secure and cost: KMS key, private subnets and endpoints, WAF, audit events, three main cost drivers (Fargate tasks, data transfer and log ingestion, DynamoDB requests), and the cheap wins. Record: the ADR with assumptions and the first thing to validate (peak factor from production data).

Notice what is absent: a long list of services, and a claim that the design is "compliant". Notice what is present: numbers, failure handling, alternatives and honesty about what is assumed.

Common mistakes

  • Starting with services. Why: eagerness to show knowledge. Avoid: clarify and quantify first; services come after the numbers.
  • Sizing to the average. Why: it is easy to compute. Avoid: use a peak factor and say why.
  • No failure analysis. Why: the happy path is more fun. Avoid: ask "what if each box fails or is slow?" before finishing.
  • Choosing without alternatives. Why: not thinking about trade-offs. Avoid: name two rejected options and the switch condition.
  • Gold-plating. Why: multi-Region everywhere sounds safe. Avoid: tie resilience to the stated RTO and RPO and impact tolerance.
  • Ignoring cost. Why: it feels like finance's problem. Avoid: name the three biggest drivers and one saving.
  • Claiming compliance. Why: wanting to reassure. Avoid: list touchpoints needing review and who confirms them.
  • Defending a wrong choice from pride. Why: interviews feel competitive. Avoid: update when given a new constraint, and explain what changed.

Troubleshooting

Symptom (in the interview)Likely causeFix
Blank on a vague promptNo starting routineSay "Let me clarify first" and ask your ten questions
The interviewer keeps changing the requirementThey are testing adaptabilityState the change, say what it affects and adjust the design
You run out of time before securitySpent too long on the sketchTime-box: 10 minutes sketch, then walk through the checklist, even briefly
A question exposes a gapNormalState what you know, the principle, and how you would verify
You are asked "why not X?" and do not know XMissing comparisonSay what you would compare (consistency, cost, operations, fit) and ask what they would value
Diagram becomes unreadableToo many boxesRedraw at one level of detail; add a second diagram for a hard part
Numbers feel inventedNo stated assumptionsWrite each assumption as a labelled line and say you would validate it
Conversation turns adversarialPressure testStay calm; restate their concern, answer with evidence, and concede valid points

Cost and cleanup

Cost: free. The sizing tool and the discussion need no AWS resources. If you build an estimate in the AWS Pricing Calculator, nothing is billed. If you try parts of a design in the sandbox, tear down the same day.

# Remove build output from the local sizing tool.
rm -rf bin obj

# If you created sandbox resources for practice, check nothing is left (by tag).
aws resourcegroupstaggingapi get-resources --tag-filters Key=Project,Values=interview-practice \
  --profile learn-sandbox

Exercises

  • 🟢 Guided: Run the sizing tool for 500,000 payments a day, peak factor 8, 2 KB each, 7 years. Explain the average and peak rate and what retention does to the storage design.
  • 🟡 Challenge: Write an ADR for "SQS or EventBridge between core banking and the status projector?" with two alternatives, consequences and compliance touchpoints. Time yourself: 20 minutes.
  • 🔴 Live problem: The interviewer says: "The business wants the payment status service to be available in two Regions with automatic failover, by next quarter, with the same team." Respond as an architect: what do you ask, what do you quantify, what do you recommend, what do you refuse to promise and what is your phased plan?

Assignment

Create an architect interview pack for your portfolio: the ten clarifying questions, a one-page decision-pairs sheet in your own words, three ADRs, the failure walk-through table for one design and a sizing sheet for the design. Link to your capstone designs where the examples fit. Use fictional data only.

Solutions

Knowledge check

Interview questions

  • Walk me through how you would design a payment status service. Use the seven steps: clarify, quantify, sketch, probe failures, decide with alternatives, secure and cost, record with an ADR.
  • How do you decide between SQS, SNS, EventBridge and Kinesis? By pattern: work queue with retries (SQS), fan-out (SNS), routing and schema (EventBridge), ordered high-volume stream with replay (Kinesis). Often they combine.
  • How do you choose the right level of resilience? Start from the business impact and the RTO and RPO, map to a DR strategy (backup and restore, pilot light, warm standby, active-active) and choose the cheapest that meets the tolerance, then test it.
  • How do you keep a cloud design affordable? Name the cost drivers, use managed services where they reduce operations, add endpoints and lifecycle rules, tag everything, set budgets and alerts and review regularly.
  • How do you get a design approved at a bank? A clear document using the bank's template, an ADR for each significant decision, a security-boundary diagram, failure scenarios, a cost estimate and a list of compliance touchpoints reviewed with the right teams.

Certification practice

Completion checklist

  • I can state the seven steps and use them on a new prompt
  • I can size a system from daily volume in two minutes and state the assumptions
  • I can defend five service choices with two rejected alternatives each
  • I wrote three ADRs and explained one in 90 seconds
  • I can walk the security and cost checklists without notes
  • I ran the cleanup steps and confirmed no practice resources remain

Key takeaways

  • Architects are scored on reasoning under uncertainty, not on remembering services.
  • Clarify and quantify before you draw; size to the peak and to the retention.
  • Every choice needs two rejected alternatives and a condition for changing your mind.
  • Probe failures, security and cost before you finish, and record the decision in an ADR.
  • State assumptions and never claim compliance; say who confirms what.

Further reading

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

On this page