Cheatsheet & Revision Plan Structure

The cheatsheet is not a course summary. It is optimized for someone re-reading at 11pm the night before an interview, who already learned this material once.

1. Design rules for the cheatsheet

Rule	Why
No prose paragraphs. Tables, lists, one-line definitions.	You are scanning, not reading
Every comparison is a table, never a discussion	Comparisons are what get asked
Numbers are present, because "it depends" is useless at 11pm	Limits, defaults, rough prices
Each section is independently readable in under 3 minutes	You revise what's weak, not linearly
Traps are flagged inline with ⚠️	The wrong answer is the expensive one
Nothing appears that wasn't taught	The cheatsheet is recall, not new material

2. Cheatsheet structure — `AWS INTERVIEW NIGHT-BEFORE CHEATSHEET`

§ 1 — AWS Fundamentals (1 page)

One-line definitions: Region, AZ, edge location, account, IAM principal, policy, role, VPC, subnet, endpoint, ARN. Global vs regional vs zonal service table. The shared responsibility line.

§ 2 — Core Services, one line each (1 page)

EC2          → virtual machines you manage
ECS/Fargate  → containers, AWS manages the host
Lambda       → function per event, no host at all
ALB          → HTTP(S) routing to targets, layer 7
API Gateway  → managed API front door: auth, throttle, cache
S3           → object storage, 11 nines durability
EBS          → block storage, one instance (usually)
EFS          → shared file storage, many instances
RDS          → managed relational DB
Aurora       → RDS with a distributed storage layer
DynamoDB     → managed NoSQL, predictable latency at any scale
ElastiCache  → managed Redis/Memcached
SQS          → durable queue, pull-based, at-least-once
SNS          → pub/sub fan-out, push-based
EventBridge  → event bus with content-based routing + replay
Kinesis      → ordered, replayable stream, sharded
Step Functions → managed workflow/state machine
KMS          → key management, envelope encryption
Secrets Manager → secrets with rotation
Parameter Store → config + secrets, cheaper, less rotation
CloudWatch   → logs, metrics, alarms
X-Ray        → distributed tracing
CloudFront   → CDN
Route 53     → DNS + health-based routing
Cognito      → user identity and tokens
WAF          → layer 7 request filtering

§ 3 — Critical comparisons (2 pages)

Eight tables, each ≤ 8 rows: SQS vs SNS · SQS vs EventBridge · SQS vs Kafka/Kinesis · RDS vs DynamoDB · EC2 vs ECS vs Fargate vs Lambda · ECS vs EKS · Redis vs DynamoDB · ALB vs API Gateway · CloudFront vs S3 direct. Each table's last row is "pick the other one when…".

§ 4 — IAM (1 page)

Entity glossary · the evaluation order flow · identity vs resource policy · AssumeRole in 5 lines · the who → what → which → allow/deny chain · the three condition keys worth memorizing · ⚠️ explicit deny always wins.

§ 5 — SQS (1 page)

Lifecycle diagram · visibility timeout sizing rule · long vs short polling · DLQ + maxReceiveCount · FIFO: message group = ordering and parallelism unit · dedup window = 5 min · the idempotency recipe · the 4 metrics that matter · ⚠️ exactly-once processing is your job.

§ 6 — DynamoDB (1 page)

Key model · partition/sort key · GSI vs LSI table · hot partition symptoms and fix · RCU/WCU arithmetic · strong vs eventual read · conditional writes · transactions cost 2× · ⚠️ scan is not a query · ⚠️ design keys from access patterns, not entities.

§ 7 — Lambda (1 page)

Execution environment lifecycle · cold start anatomy and what reduces it · memory = CPU · concurrency: account/reserved/provisioned · the three invocation types and their different retry behaviour · timeout ceiling · ⚠️ async invocations retry and will duplicate side effects.

§ 8 — Architecture patterns (1 page)

API → Service → DB                    the baseline
API → Service → Cache → DB            read-heavy
API → Service → SQS → Worker          slow/unreliable downstream
API → Service → DB + Outbox → Events  atomic "save and publish"
Event → EventBridge → N consumers     fan-out with routing
Client → CloudFront → S3              static/large object delivery
Client → presigned URL → S3 → event   uploads that skip your app
API → Lambda → DynamoDB               spiky, low-ops workloads
Producer → Kinesis → N consumers      ordered, replayable, multi-reader

§ 9 — Senior principles (½ page)

Design for failure, not for the happy path
Make every consumer idempotent
Least privilege, enforced by roles not by trust
Avoid synchronous dependencies you don't control
Cache deliberately: know your TTL, your invalidation, your stampede
Measure before optimizing; name the bottleneck before moving it
An AZ will fail. Plan the user-visible behaviour.
Events will duplicate. Plan the correctness.
Retries cause outages. Backoff, jitter, budget, shed.
Backpressure is a feature, not a bug.
Cost is a design constraint, not a finance problem.

§ 10 — Top 100 questions with concise answers (6–8 pages)

Drawn from the four banks, ordered by topic, answers 2–4 lines each. Marked ⭐ for the ~25 most likely to be asked.

§ 11 — Numbers worth knowing (½ page)

A dated table of limits and defaults that come up in interviews (SQS message size and retention, Lambda timeout/memory/payload, DynamoDB item size and partition throughput, S3 object size and multipart threshold, API Gateway timeout, ALB idle timeout, VPC subnet reserved IPs). Explicitly dated and flagged as verifiable — AWS changes these.

3. The five revision plans

Each tells the learner exactly what to read, in order, with time boxes. No "review the material."

30-minute revision — "I have an interview in an hour"

Min	Read
0–5	§ 2 Core services one-liners
5–15	§ 3 Critical comparisons — all eight tables
15–22	§ 8 Architecture patterns + § 9 Senior principles
22–30	The ⭐ questions in § 10 only

1-hour revision

Min	Read
0–10	§ 2 + § 3
10–25	§ 5 SQS + § 6 DynamoDB + § 7 Lambda (the three most-asked services)
25–35	§ 4 IAM
35–50	§ 8 patterns; then sketch one system design from memory (URL shortener)
50–60	⭐ questions + the nine traps

3-hour revision

Min	Read
0–20	Whole cheatsheet, fast pass
20–60	Day 8 + Day 12 day-end revision sections (messaging + reliability — the densest senior material)
60–90	Two system designs, sketched from blank paper, then compared to the course version
90–120	Two troubleshooting scenarios, worked without reading the answer
120–150	All four YOE banks at your level — answer out loud, timed
150–180	The nine traps + the cost arithmetic in Day 12

Night-before plan (2 hours, then stop)

(20 min) Full cheatsheet pass — do not stop on anything hard.
(30 min) Your two weakest sections only, from the cheatsheet index.
(40 min) One full system design out loud, 45-minute format, timed — recording yourself is encouraged.
(20 min) The nine traps and § 9 principles.
(10 min) Write your three "clarifying questions I always ask" on one card.
Stop. No new material. Sleep is a better investment than a 12th service.

Morning-of plan (25 minutes)

Min	Do
0–8	§ 2 one-liners + § 3 comparisons
8–14	§ 9 senior principles + the five-move answer pattern
14–20	§ 8 patterns — say each one out loud as a sentence
20–25	Your one card: clarifying questions, your 3 strongest stories, and "state assumptions, name the trade-off, stress-test your own answer"

Explicitly forbidden on the morning of: learning a new service, reading AWS docs, or attempting a system design you have never done. It converts confidence into anxiety.

4. Day-end revision (inside each day file)

Each of the 14 days ends with a ~5-minute revision block, in a fixed shape:

The five sentences        the day in five lines you could say out loud
The diagram to redraw     one, from memory
The numbers               3-5 figures from today
The trap                  today's "sounds right, isn't"
Tomorrow needs            what from today gets used tomorrow

These 14 blocks concatenated form the 3-hour revision's middle section — no separate material is written.