Interview card (SDS + EM)

General system design from System Design School, plus engineering-manager questions. Jot this on paper. Use company language only if they put it on the board.

System design (SDS method)

Clock

Requirements 8–10 · APIs 3–5 · High-level 15 · Deep dives 15 · EM close 3–5

Open

Don’t start with Kafka. Restate the problem. Ask. Write NFRs before boxes.

Decompose

Verbs → use cases (what “correct” means)
Nouns → entities, who may write
Adjectives → constraints; each adjective earns a component

Ask every time

Actors? Read vs write? Peak? Worse: stale / wrong / down / leaked? Retention? One region?

Big four (they conflict — pick from the business)

Availability · scalability · latency · consistency

Stronger consistency costs latency and availability. Use the weakest the feature can tolerate.

CAP in English

Split happens: CP = correct, maybe down. AP = up, maybe stale. Don’t apply one choice to the whole system.

Four pains → techniques (add only when a number forces it)

Too many users → replicate compute (LB) and/or data
Too much data → partition (key matches access; consistent hashing ~1/N remap)
Must feel fast → cache reads; async writes if the user can wait
Stale/inconsistent → the bill for the above

Core boxes

Stateless services + LB · DB replicas + cache · partition · queue

Five facts

One box at a time, each forced
Hash-mod-N remaps almost everything on resize; consistent hashing ~1/N
AP answers stale; CP refuses
Optimistic lock: version column, loser retries
Queues are at-least-once → workers idempotent

Template (then amend)

Write → queue → workers update DB/cache → read from cache

If lying is expensive: cache is a performance layer, not truth. Show freshness. Timeout = in-doubt, don’t guess.

Deep-dive menu (pick 2)

Idempotent retry · poison/DLQ · hot key · backfill · authz on every read · saga if two systems can’t share a txn

Don’t

Cookie-cutter Redis+Kafka. CDN / object storage if time dies. Framework wars.

EM overlay (end of every board)

Team: who owns which box (platform vs product). Conway.
v1 vs later: what you cut; what you refuse to cut.
Done: tests on the trust boundary, not “we’ll add e2e later.”
KPIs: lag, error budget, escaped defects — not story points.
Ops: page workers, not heroes; on-call is a staffing issue.
Exec: two hows + risk in English. Date vs fidelity, in the open.

Stakeholder spine

Outcome → constraint → two hows → risk → who/what we stop → ask for a decision.

Never “engineering says no.” Never “we’ll hardcode it.”

EM questions they may ask (~90s each)

Delivery / design

Product wants it “like Excel by Friday.” What do you do?
How do you say no without blocking the outcome?
Design and a plan: who owns it, what’s v1, what you measure.
How do you work with architects / PMs / other EMs (matrix)?
How do you set technical direction without being the bottleneck?

Quality / ops

How do you measure engineering (KPIs)?
Incident: stabilize, evidence, comms, fix includes detection.
Quality is behind: where do you put tests first?
On-call / well-being / bus factor.

People

How do you mentor / give feedback / do performance if you inherit no framework?
Underperformance.
Disagreement with a peer (approach, not identity).
Feedback that changed you (IC hero → multiplier).
Why manager vs staying a senior IC? Have you managed before? (honest, then pivot)

You should ask them (pick 2)

What’s the weakest part of delivery right now? When product wants a shortcut, who has last call? How do you want this EM to show progress?

Name one product per box

Whiteboard first as roles (load balancer, queue, cache). If they ask “what would you use?”, pick one. SDS default is AWS. If they say Azure, swap the Azure column. Don’t list three vendors.

Box you draw	What it’s for	AWS (say this)	Azure	Also fine
DNS / CDN	Name → edge; static/cache near user	Route 53 + CloudFront	Azure DNS + Front Door / CDN	Cloudflare
Load balancer	Spread HTTP/TCP across stateless apps	ALB (HTTP) / NLB (TCP) / “ELB”	Azure Load Balancer / App Gateway	nginx, Envoy
API gateway	Auth, rate limit, routing, TLS terminate	API Gateway	API Management	Kong, NGINX
App / compute	Stateless request handlers	ECS, EKS, or Lambda	App Service, AKS, Functions	Kubernetes
Cache	Hot reads, sessions, rate-limit counters	ElastiCache Redis	Azure Cache for Redis	Memcached
SQL / OLTP	Strong consistency, relations, money	RDS Postgres / Aurora	Azure SQL / Postgres Flexible	MySQL
NoSQL / KV	High-scale key lookup, flexible docs	DynamoDB	Cosmos DB	Cassandra, Mongo
Object store	Blobs, files, backups, images	S3	Blob Storage	GCS
Queue (tasks)	Buffer writes; at-least-once workers	SQS	Storage Queue / Service Bus	RabbitMQ
Log / stream	Ordered partitions, replay, many consumers	Kafka on MSK / Kinesis	Event Hubs	Kafka
Pub/sub	Fan-out notify (email, webhooks)	SNS	Event Grid	—
Search	Full-text, filters	OpenSearch	Cognitive Search	Elasticsearch
Identity	Who is this user/service	Cognito / IAM	Entra ID	Auth0, Okta
Secrets	Keys, DB passwords	Secrets Manager	Key Vault	Vault
Workflow / saga	Multi-step, compensate	Step Functions	Durable Functions / Logic Apps	Temporal
Observability	Metrics, traces, logs, errors	CloudWatch + X-Ray	Azure Monitor	Datadog, Prometheus, Sentry

One-liners so you don’t freeze

LB: “ALB in front of stateless app tasks.”
Writes that can wait: “SQS, workers, idempotent on message id.”
Replay / many consumer groups: “Kafka (or Event Hubs).”
Positions / money: “Postgres, not Redis as source of truth.”
Hot read: “Redis cache-aside, key includes version or as_of.”
Authz: “Gateway authenticates; service still checks entitlements on every read.”
Failures: “DLQ + Datadog on queue depth and worker errors.”

If they already have a stack, match it. Don’t start an AWS vs Azure fight.

What to draw (UML-ish, keep it ugly and labeled)

System design is not a class diagram. Use a tiny set of symbols. Label every arrow.

Symbol	Draw	Means
Actor	Stick figure	User, agent ops, lender, external bank
System / service	Rectangle, name inside	`API Gateway`, `Vote Service`
Database	Cylinder	Postgres, Redis (write `cache` on Redis)
Queue / topic	Stacked rectangles or a long horizontal bar	SQS, Kafka
Object store	Cylinder or parallelogram labeled `S3`	Blobs
Boundary	Big dashed box around a group	`Read path` vs `Write path`; `region`
Note	Dog-ear rectangle	“at-least-once”, “idempotent key”

Arrows

Solid, one arrowhead: sync request/response (HTTPS, SQL)
Dashed: async (publish, enqueue)
Open arrow / “push”: stream or fan-out
Write the protocol or verb on the line: POST /votes, INCR, consume

Sequence (if they want a walkthrough)
Vertical lifelines = services. Horizontal arrows = calls. Time goes down. One happy path, then one failure (retry / timeout).

Don’t draw
Class diagrams, inheritance, every pod, “microservice mesh” unless asked.

Minimal board (copy this shape)

  [User] --> [API Gateway / ALB] --> [App service]
                                      |          \
                                      v           v
                                   [Queue]     [Postgres]
                                      |
                                      v
                                   [Worker] --> [Postgres]
                                            --> [Redis cache]

Then add only what an adjective forced: authz box, DLQ, second DB, CDN.

10-minute drill

Write verbs/nouns/adjectives, the four NFRs, at-least-once → idempotent, EM close list, Excel-by-Friday spine. Name one product per box (ALB, API Gateway, SQS, RDS, Redis, S3, Datadog). Draw the six-box sketch above once. Say the open once out loud.

System design (SDS method)​

EM overlay (end of every board)​

EM questions they may ask (~90s each)​

Name one product per box​

What to draw (UML-ish, keep it ugly and labeled)​

10-minute drill​