Whiteboard a defensible AWS architecture
Why you care
Most candidates fail the AWS whiteboard round not from missing service knowledge, but because they draw boxes before agreeing what the system needs to do, then can't defend a choice under pressure. Interviewers watch you reason under changing constraints, not count service names. If your design looks identical before and after "now assume 10x write volume," that's the clearest tell the first answer was memorised.
Explain like I'm 5
A building inspector doesn't care how many brick types you can name; they care about load paths and exits, and whether the building stands when something unexpected happens. Structure beats inventory.
Core concept
A repeatable five-step method, in order:
- Clarify requirements: scale, latency, consistency, failure tolerance, as rough numbers, before drawing.
- Draw the topology top-down: client, edge, compute, data, async paths.
- Call out IAM boundaries: which role touches which resource, and the trust boundary.
- State the data path and consistency model: synchronous vs eventual, partial-failure behaviour.
- Name failure modes and rough cost, reusing AWS compute choice's compute table instead of re-deriving it live.
Decision rule: answer "why not Y" with the requirement Y fails, not a feature list; use the fewest parts the constraints demand.
Under the hood
Interviewers grade against a rubric: requirements gathering, trade-off articulation, failure-mode coverage, and whether the design changes when a constraint lands mid-answer. That's the sharpest signal, because a memorised answer can't fake it: a candidate who's reasoned it through names exactly which component breaks first under 10x load; one reciting a blog post redraws everything, or nothing.
Minimal example A design-review checklist flags what you skipped
REQUIRED = ["requirements", "topology", "iam_boundary", "data_consistency", "failure_mode", "cost_shape"]
def missing_sections(notes):
return [key for key in REQUIRED if not notes.get(key)]
draft = {
"requirements": "100k orders/day, p99 under 500ms, single region ok",
"topology": "ALB -> Lambda -> RDS Postgres",
"cost_shape": "pay-per-request, low idle cost",
}
print(missing_sections(draft))
print(len(REQUIRED) - len(missing_sections(draft)), "of", len(REQUIRED), "sections covered")['iam_boundary', 'data_consistency', 'failure_mode']
3 of 6 sections coveredIn production Scoring three rounds of the same whiteboard answer
A mock interview rarely stays static: the interviewer adds constraints, and a defensible design responds to each one instead of staying frozen.
from dataclasses import dataclass
REQUIRED = ["requirements", "topology", "iam_boundary", "data_consistency", "failure_mode", "cost_shape"]
@dataclass
class Round:
name: str
notes: dict
constraint_added: str = ""
def score(notes):
covered = [k for k in REQUIRED if notes.get(k)]
return len(covered), REQUIRED
rounds = [
Round("baseline", {
"requirements": "orders-api, 100k orders/day",
"topology": "ALB -> Fargate -> RDS Postgres",
}),
Round("interviewer: what if a write fails halfway?", {
"requirements": "orders-api, 100k orders/day",
"topology": "ALB -> Fargate -> RDS Postgres",
"failure_mode": "idempotent write with order_id unique key, retried from SQS",
"iam_boundary": "Fargate task role: write to orders table only, no admin",
}, constraint_added="partial-failure handling"),
Round("interviewer: now assume 10x write volume", {
"requirements": "orders-api, 1M orders/day",
"topology": "ALB -> Fargate -> SQS -> workers -> RDS Postgres (write-behind)",
"failure_mode": "idempotent write with order_id unique key, retried from SQS, DLQ after 5",
"iam_boundary": "Fargate task role: write to orders table only, no admin",
"data_consistency": "eventual: API returns 202, status polled separately",
"cost_shape": "SQS + worker fleet scales with queue depth, not request rate",
}, constraint_added="10x write volume"),
]
for r in rounds:
covered, total = score(r.notes)
print(f"{r.name}: {covered}/{len(total)} sections, added for: {r.constraint_added or 'n/a'}")baseline: 2/6 sections, added for: n/a
interviewer: what if a write fails halfway?: 4/6 sections, added for: partial-failure handling
interviewer: now assume 10x write volume: 6/6 sections, added for: 10x write volumeSee it happen A design that grows only when a constraint forces it
- Baseline answer: client to ALB to Fargate to RDS, nothing else drawn yet.
- Interviewer asks what happens if a write fails halfway: the Fargate node gets an IAM boundary label, scoped to one table.
- Failure mode added: SQS and a DLQ appear between the API and the write path, so a failed write becomes retryable instead of lost.
- 10x volume constraint: workers now pull from SQS and write behind, instead of Fargate writing directly on every request.
In your world
The situation
You get asked in a phone screen to design "a service that ingests supplier price files and serves current price lookups" on AWS.
What actually breaks
You answer "S3, Lambda, DynamoDB" in twenty seconds, no clarifying questions. The interviewer asks what happens when two files for the same SKU land in the same minute, and you have nothing.
What you'd do on Monday
Rehearse the five-step method on a timer, so a skipped section becomes visible first:
BUDGET_SECONDS = {"requirements": 120, "topology": 180, "iam_boundary": 60, "data_consistency": 120, "failure_mode": 120, "cost_shape": 60}
elapsed = {"requirements": 95, "topology": 160, "iam_boundary": 0, "data_consistency": 40, "failure_mode": 0, "cost_shape": 0}
for section, budget in BUDGET_SECONDS.items():
status = "covered" if elapsed[section] > 0 else "SKIPPED"
print(f"{section}: {elapsed[section]}s / {budget}s budget -> {status}")requirements: 95s / 120s budget -> covered
topology: 160s / 180s budget -> covered
iam_boundary: 0s / 60s budget -> SKIPPED
data_consistency: 40s / 120s budget -> covered
failure_mode: 0s / 120s budget -> SKIPPED
cost_shape: 0s / 60s budget -> SKIPPEDImagine you work at Postman
The numbers
Illustrative: 2M monitors every 5 minutes average 6,667 checks/second. Firing on the exact boundary clusters 400,000 checks into one second, ~60x the average rate.
What the Scenario-A answer does here
The checklist-driven design still works, but "schedule on the round mark" is what most candidates whiteboard, creating a thundering herd every five minutes.
What flips at this scale
A fixed, random offset per monitor spreads the same 400,000 checks evenly instead of bursting. Name this when asked how it scales to millions.
The trade-off you'd defend
I'd defend jittered scheduling over round-time scheduling, trading a tidy "exactly on the mark" for a load profile flat instead of spiky.
Illustrative numbers; not Postman-published.
Gotchas
Freezing on the first follow-up
The candidate repeats the same diagram verbatim when asked "what if X."
The design was memorised, not derived from requirements.
Practise adjusting one component at a time, naming which requirement changed.
Service-name dumping
Eight AWS services named in the first thirty seconds, before any clarifying question.
Signalling breadth instead of reasoning.
Name two or three services per layer and justify each against a requirement.
No numbers anywhere
Asked requests-per-second, the candidate has no answer, and the design doesn't change once given one.
Scale was never converted into a number during clarification.
Do the back-of-envelope math out loud, and let it drive one design choice.
Tricky questions
Yes, naming EventBridge, Step Functions, DynamoDB, ElastiCache, SQS and three Lambda functions shows breadth.
No, it signals components weren't matched to requirements. A senior answer uses the fewest parts the constraints need.
Yes, more clarification always looks more rigorous.
No, open-ended clarification reads as stalling. Ask the few questions that change the architecture and move on.
Scenario question
You're handed 20 minutes to design "a service that lets support agents search customer order history," and the interviewer says "just go." What do you do first?
Model answer
I wouldn't start drawing. I'd spend sixty seconds stating assumptions out loud: scale (read-heavy, tens of thousands of agents), consistency (a few seconds of staleness is fine), and region scope. Only after confirmation would I draw a search-optimised read path behind an API layer, and say why not a graph database or streaming pipeline: nothing asked for it. The trade-off is a dedicated search index versus an indexed Postgres replica, picked on data volume.
Interview corner
CommonWalk me through how you'd approach an AWS system design question.
TrickWhat's the biggest mistake candidates make in these rounds?
Experience checkTell me about a real architecture decision you've made, even a small one.
DesignHow would you handle the interviewer adding a 10x scale constraint mid-answer?
Memory hook
A whiteboard round is a building inspection, not a bricks inventory: the inspector cares about load paths and exits, not how many brick types you can name.
A design that doesn't change when a constraint changes was memorised, not reasoned.
Self-check
What are the five steps of the method, in order?
Clarify requirements, draw the topology, call out IAM boundaries, state the data/consistency model, name failure modes and cost shape.
What's the strongest tell of a memorised answer?
The design doesn't change when the interviewer adds a new constraint.
Why name only two or three services per layer?
Justifying each against a requirement is the skill graded; more names dilute that signal.
Pick one AWS service you've touched. Set a 10-minute timer and whiteboard "ingest daily CSVs, serve the latest row per key" using the five-step method, out loud. Then inject "10x the file size" and time how long it takes to say what changes. Paste the before/after notes and elapsed seconds.