Full syllabus

An app is the front of a restaurant; the system is the whole restaurant behind it: kitchen, pantry, staff and the plan for the Friday rush.

1. What system design is (no jargon) · 12 minExplain in plain words what a system is, why an app that works for a few people can break for millions, and what a system designer decides.
2. Software from the inside: client, server, database and API · 12 minName the four pieces behind any app (client, server, database and API) and explain what each one does, using a food delivery order.
3. How to learn here · 12 minUse the method and the sections of this platform to build a short daily routine that makes what you learn stick.

Ordering a pizza by phone: look up the number (DNS), get through the switchboard (load balancer), the kitchen makes it (server), the pantry has ingredients (database).

1. What happens when you type a URL · 12 minTrace a request from browser to database and name each hop.
2. From one server to many · 13 minExplain vertical vs horizontal scaling and why statelessness matters.
3. Latency vs throughput · 10 minDistinguish latency and throughput and read p50/p99 at a basic level.
4. The design loop (how every design session runs) · 12 minRun the 4 steps: scope, high-level design, deep dive, wrap-up.

Your desk (CPU cache), your backpack (RAM) and the school library (disk): the farther away, the slower to grab.

1. The memory hierarchy · 12 minRank CPU cache, RAM, SSD and network by speed and explain why distance matters.
2. Processes, threads and concurrency · 12 minExplain processes vs threads and concurrency vs parallelism.
3. Async I/O and the event loop · 12 minExplain why non-blocking I/O lets one thread serve many connections.
4. Durability: when is data really saved? · 12 minExplain page cache, fsync and why write() is not durability.

TCP is registered mail (confirmed, in order); UDP is flyers under doors (fast, some get lost).

1. TCP vs UDP · 12 minCompare reliability, ordering and latency of TCP and UDP.
2. TLS: how HTTPS gets secure in one round trip · 12 minWalk through the TLS 1.3 handshake and where TLS terminates.
3. HTTP/1.1 to HTTP/2 to HTTP/3 · 13 minExplain multiplexing, head-of-line blocking and why QUIC runs on UDP.
4. Counting round trips (a latency budget) · 10 minAdd up DNS, TCP, TLS and request round trips for a first page load.

REST is a restaurant menu; GraphQL is a buffet where you pick exactly what you want; WebSockets is keeping the phone line open.

1. REST basics: resources, verbs, status codes · 12 minModel resources and pick correct HTTP methods and status codes.
2. Pagination, versioning and errors · 12 minDesign cursor pagination, a versioning strategy and a consistent error format.
3. Idempotency keys · 12 minMake a POST safe to retry with an idempotency key.
4. gRPC: fast typed calls between services · 12 minExplain Protobuf, HTTP/2 streaming and when gRPC beats REST.
5. GraphQL: flexible queries and their cost · 12 minExplain GraphQL's benefits and its caching and N+1 problems.
6. Real-time: polling, SSE, WebSockets, webhooks · 13 minChoose a push or pull mechanism for a real-time feature.

DNS is the phone's contact list for the internet; a CDN is a convenience store near your house stocking copies of the big warehouse's items.

1. How DNS resolution works · 12 minTrace resolver, root, TLD and authoritative lookups with caching.
2. TTLs, GeoDNS and failover · 10 minExplain TTL trade-offs and why DNS failover isn't instant.
3. CDNs and edge caching · 12 minExplain pull vs push CDNs, cache keys and invalidation.
4. Anycast and edge compute · 10 minExplain how anycast routes users to the nearest edge and what runs there.

The host at a busy restaurant seating guests so no single waiter gets swamped.

1. Load balancing algorithms · 12 minCompare round robin, least connections and hashing, with health checks.
2. L4 vs L7 load balancing · 12 minChoose L4 or L7 based on routing needs, TLS and cost.
3. Reverse proxy vs API gateway vs service mesh · 13 minPlace each component and name what it adds.
4. Sticky sessions and stateless services · 10 minExplain why stickiness hurts balancing and how to move state out.

Estimating how many pizzas a party needs: guests × slices ÷ slices per pizza. Close enough is the goal.

1. Latency numbers that matter in 2026 · 12 minRecall orders of magnitude from memory reads to cross-region round trips.
2. From DAU to QPS · 12 minConvert users and actions into average and peak requests per second.
3. Storage and bandwidth estimates · 12 minEstimate yearly storage and bandwidth with powers of two.
4. Estimation drills (mixed practice) · 15 minSolve 4 timed estimates and use the result to make a design decision.

Before building a treehouse you ask: how many kids, how high, how much weight, what's the budget?

1. Functional vs non-functional requirements · 12 minList functional requirements and the NFRs that change the design.
2. Core entities and API first · 12 minDerive entities and an API from requirements before drawing.
3. High-level design, then deep dives · 13 minBuild a working design quickly and pick the right deep dives.
4. Talking trade-offs and managing time · 10 minNarrate decisions as trade-offs and budget 45 minutes.

A spreadsheet with strict columns (SQL) vs a folder of flexible notes (documents); an index is the index at the back of a textbook.

1. Relational vs document vs key-value vs graph · 15 minMatch a data model to access patterns.
2. Normalization vs denormalization · 12 minDecide when to duplicate data for read speed.
3. How indexes work (B-trees) · 13 minExplain B-tree lookups, composite and covering indexes.
4. LSM-trees: built for writes · 13 minExplain memtables, SSTables, compaction and write vs read amplification.
5. OLTP vs OLAP and column stores · 12 minExplain why analytics uses column-oriented storage.
6. Choosing a database (decision practice) · 15 minPick and justify a store for 5 scenarios.

Photocopies of the class notes: if one gets lost you still have others, but copies made at lunch miss what was written after lunch (replication lag).

1. Leaders and followers · 12 minExplain single-leader replication, sync vs async and failover.
2. Replication lag anomalies · 12 minDiagnose read-your-writes and monotonic-read violations and fix them.
3. Multi-leader replication and conflicts · 12 minExplain when multi-leader helps and how conflicts get resolved.
4. Leaderless replication and quorums · 13 minUse W + R > N and explain sloppy quorums and read repair.

Splitting the school yearbook into volumes A-F, G-M, N-Z; if everyone is named Garcia, one volume gets huge (hot partition).

1. Why and when to shard · 12 minDecide when sharding is needed after replication and caching.
2. Range vs hash partitioning · 12 minChoose a partition key and predict hotspots.
3. Consistent hashing · 12 minExplain the hash ring, virtual nodes and minimal data movement.
4. Hot keys, secondary indexes and rebalancing · 13 minMitigate hot partitions and compare local vs global indexes.

Two people booking the last concert seat at the same time: transactions decide who gets it so the seat isn't sold twice.

1. ACID for real · 12 minExplain what each ACID letter guarantees and what it doesn't.
2. Isolation levels and anomalies · 14 minMatch dirty reads, lost updates and write skew to isolation levels.
3. MVCC and snapshot isolation · 12 minExplain how versioned rows let readers and writers not block each other.
4. Locks vs optimistic concurrency · 12 minChoose pessimistic locks or version checks for a booking system.
5. Two-phase commit and why services avoid it · 11 minExplain 2PC and its blocking/availability cost.

Two friends sharing a notebook by text message: if texts stop arriving, do you keep writing (available) or wait until you're in sync (consistent)?

1. Consistency models: from strong to eventual · 13 minOrder linearizable, causal and eventual consistency by strength and cost.
2. CAP without the myths · 12 minState what CAP really says (choice during a partition).
3. PACELC: latency vs consistency every day · 11 minClassify real databases as PA/EL or PC/EC.
4. Choosing consistency per feature · 12 minPick consistency per feature in one product (likes vs payments).

Keeping your favorite snacks in your backpack instead of walking to the store every time you're hungry.

1. What a cache is, and the cache-aside pattern · 12 minExplain cache-aside reads and writes and its main risk.
2. Hit ratio and sizing a cache · 13 minCompute database load from hit ratio and size a cache by working set.
3. Write strategies: through, back, around · 12 minCompare write-through, write-back and write-around by staleness and durability.
4. Invalidation and TTLs · 12 minDesign invalidation for a write path and choose TTLs.
5. Stampedes, hot keys and eviction · 13 minPrevent thundering herds and handle hot keys; pick LRU vs LFU.
6. Where caches live: client, CDN, app, database · 10 minPlace caches in layers and reason about Redis as a platform.

Object storage is a giant coat check (hand over a coat, get a ticket); a search index is a librarian's card catalog listing every book that mentions a word.

1. Object storage: buckets, objects, durability · 12 minExplain object vs block vs file storage and storage classes.
2. Uploads at scale: multipart and presigned URLs · 12 minDesign direct-to-storage uploads that bypass app servers.
3. How search engines index text · 13 minBuild an inverted index by hand and explain BM25 ranking.
4. Search clusters and keeping the index fresh · 12 minShard a search index and sync it from the primary database.

Batch is doing all the laundry on Sunday; streaming is washing each shirt as soon as it's dirty.

1. Batch vs stream · 11 minChoose batch or streaming from latency and cost needs.
2. The log: Kafka's mental model · 13 minExplain topics, partitions, offsets and consumer groups.
3. Ordering, partition keys and consumer scaling · 12 minChoose partition keys that keep needed order and allow parallelism.
4. Delivery semantics and exactly-once · 12 minExplain at-most, at-least and effectively-once processing.
5. Change data capture · 12 minStream database changes to other systems without dual writes.
6. Windows, watermarks and the lakehouse · 12 minExplain event-time windows, late data and where analytics lands.

A group chat deciding where to eat: you need most of the group to agree, and one person to announce the decision.

1. Why clocks lie · 12 minExplain clock skew and why wall-clock ordering fails.
2. Logical clocks · 12 minOrder events with Lamport and vector clocks.
3. Why consensus is hard · 12 minExplain agreement under failures and majority quorums.
4. Raft: leader election and log replication · 15 minWalk through a Raft election and a committed log entry.
5. Locks, leases and fencing tokens · 12 minUse leases with fencing tokens and know when a Redis lock is unsafe.

Pressing the elevator button 10 times doesn't call 10 elevators (idempotency); a bouncer lets in only so many people per minute (rate limiting).

1. Timeouts: picking the number · 11 minSet timeouts from latency percentiles.
2. Retries with backoff and jitter · 12 minDesign retries that don't cause retry storms.
3. Idempotency in depth · 12 minImplement idempotency keys with storage, TTL and response replay.
4. Rate limiting algorithms · 13 minCompare token bucket, leaky bucket, fixed and sliding windows.
5. Circuit breakers, load shedding and backpressure · 13 minStop cascading failures when a dependency is slow.

A restaurant ticket rail: waiters pin orders, cooks take them when ready, nobody waits at the stove.

1. Why queues · 12 minUse a queue to decouple and absorb spikes.
2. Pub/sub and fan-out · 12 minChoose queue vs pub/sub vs log for a fan-out need.
3. Delivery guarantees, DLQs and poison messages · 12 minDesign consumers with visibility timeouts, DLQs and idempotency.
4. Events, schemas and choreography · 13 minDistinguish event notification, state transfer and versioned schemas.

Booking a trip (flight, hotel, car): if the car fails you cancel the hotel and flight instead of pretending it all happened at once.

1. Sagas: transactions across services · 13 minDesign a saga with compensations, orchestrated vs choreographed.
2. The transactional outbox · 11 minSolve the dual-write problem with an outbox and CDC.
3. CQRS: separate read and write models · 12 minDecide when CQRS is worth its complexity.
4. Event sourcing and workflow engines · 12 minExplain event sourcing and when a workflow engine (Temporal, Step Functions) helps.

One big food truck vs a food court: the court scales stalls separately but needs more coordination.

1. Monolith first · 11 minExplain when a modular monolith beats microservices.
2. Service boundaries and Conway's law · 12 minDraw boundaries around domains and teams.
3. Migrating with the strangler fig · 11 minPlan an incremental migration off a legacy system.
4. Serverless trade-offs · 11 minEvaluate serverless for cost, cold starts and lock-in.

A chain of 5 bike parts that each work 99% of the time: the bike works only ~95% of the time.

1. Counting nines · 12 minCompute serial and parallel availability and yearly downtime.
2. SLIs, SLOs and SLAs · 12 minWrite an SLI and SLO for a user journey.
3. Error budgets and burn-rate alerts · 11 minUse an error budget to balance reliability and velocity.
4. Tail latency · 12 minExplain why p99 matters and how fan-out amplifies it.

A car dashboard (metrics), a trip diary (logs) and a GPS trace of the whole route (traces).

1. Metrics, logs and traces · 12 minMatch each telemetry signal to the question it answers.
2. Golden signals, RED and USE · 11 minChoose dashboards for services and resources.
3. Distributed tracing and OpenTelemetry · 12 minExplain spans, context propagation and sampling.
4. Observing LLM apps · 11 minTrace prompts, tokens, cost and latency per LLM call.

A spare tire (backup), a second car at a friend's house (warm standby), or two cars always driving side by side (active-active).

1. Failure domains and redundancy · 12 minPlace redundancy across instances, AZs and regions.
2. RTO, RPO and the four DR strategies · 13 minChoose backup/restore, pilot light, warm standby or active-active from RTO/RPO and cost.
3. Multi-region trade-offs · 12 minDecide if multi-region is justified and how data replicates.
4. Bulkheads, cells and shuffle sharding · 12 minLimit blast radius with cells and shuffle sharding.
5. Cascading failures and chaos engineering · 12 minExplain cascading failures and how chaos experiments find them.

A school: ID badges (authentication), which rooms your badge opens (authorization), and checking badges at every door, not just the entrance (zero trust).

1. Authentication vs authorization, sessions vs tokens · 11 minDistinguish authN/authZ and sessions vs JWTs.
2. OAuth 2.0 and OpenID Connect · 13 minWalk through the authorization-code flow and what OIDC adds.
3. Zero trust, secrets and encryption · 12 minApply least privilege, secret management and envelope encryption.
4. Multi-tenant isolation · 12 minChoose silo, pool or bridge tenancy and propagate tenant context.
5. Threat modeling a design · 11 minFind trust boundaries and top threats in a diagram.

Choosing between renting a car per day, a monthly lease or owning one depends on how much you drive.

1. The six Well-Architected pillars · 12 minUse the pillars as a review checklist.
2. Cost modeling a design · 13 minEstimate monthly cost including egress and pick pricing models.
3. Mapping boxes to AWS, GCP and Azure · 12 minTranslate a generic design into managed services on each cloud.

You already know how to plan a house; this is the hardware store's catalogue. Same rooms, but now you pick the exact door, lock and pipe by name, and the exam asks which one fits.

1. VPC anatomy: subnets, routes, NAT and two firewalls · 13 minLay out a two-zone VPC with public and private subnets, route tables and NAT gateways, and choose between security groups and network ACLs for a rule.
2. Connecting privately: endpoints, peering, Transit Gateway, VPN and Direct Connect · 13 minChoose gateway or interface endpoints, VPC peering or Transit Gateway, and Site-to-Site VPN or Direct Connect from a scenario's scale, cost and latency needs.
3. IAM and multi-account guardrails · 13 minEvaluate an IAM request (explicit deny, allow, implicit deny), and choose roles, resource policies, SCPs and IAM Identity Center for a multi-account design.
4. AWS security services: which one answers which threat · 12 minMatch GuardDuty, Inspector, Macie, Security Hub, Detective, Config, CloudTrail, Cognito, WAF, Shield and Network Firewall to the threat or question each one addresses.
5. Protecting data: KMS, S3 controls, certificates and backups · 13 minChoose SSE-S3, SSE-KMS, SSE-C or client-side encryption, write the key and bucket controls that stop a leak, use ACM for TLS, and design backups that survive a compromised account.
6. Choosing AWS storage: block, file, object and hybrid · 13 minPick EBS volume types, instance store, EFS, FSx, S3 storage classes with lifecycle rules, and hybrid transfer services from access pattern, sharing and cost.
7. Elastic compute and paying less for it · 13 minConfigure EC2 Auto Scaling policies, choose On-Demand, Savings Plans, Reserved Instances and Spot, plus Lambda, Fargate or EC2, for a workload's shape, and hibernate an instance that must keep its memory.
8. Managed databases: failover, read scaling and capacity · 13 minDistinguish RDS Multi-AZ from read replicas, and choose Aurora features, RDS Proxy, DynamoDB capacity modes, DAX and global tables for availability, performance and cost.
9. Decoupling on AWS: SQS, SNS, EventBridge and Step Functions · 12 minChoose SQS standard or FIFO, set visibility timeouts and dead-letter queues, and pick SNS fan-out, EventBridge or Step Functions for a loosely coupled design.
10. Service quotas: sizing the standby Region before you need it · 13 minConfigure service quotas for a standby environment so failover can reach production size, tell a quota from capacity and from throttling, and choose how to monitor quotas across accounts.
11. Migrating legacy applications: the 7 Rs and rehosting with MGN · 13 minPick a migration strategy (retire, retain, rehost, relocate, repurchase, replatform, refactor) from a scenario's constraints, rehost servers with AWS Application Migration Service, and make a legacy app more reliable without changing its code.
12. Migrating databases and bulk data: DMS, schema conversion and CDC · 13 minPlan a database migration with AWS DMS (full load, full load plus CDC, homogeneous or heterogeneous with schema conversion first), and choose DataSync, Transfer Family, Storage Gateway or an offline path for the files, knowing which options are closed to new customers.
13. Ingesting and analysing data: Kinesis, Glue, Athena and the lake · 20 minChoose Kinesis Data Streams or Data Firehose, and Glue, Athena, Lake Formation, EMR, Redshift and Amazon Quick for a data pipeline, cut its scan cost with format and partitioning, and rehearse the ten decisions behind the official SAA-C03 sample questions.
14. Containers and APIs on AWS · 13 minChoose ECS or EKS, on Fargate or EC2 capacity, or Lambda for a workload moving into containers, and pick an API Gateway REST, HTTP or WebSocket API with the throttling layers that protect the backend.

A super-powered autocomplete that reads your whole message first (prefill), then types its answer one word at a time (decode).

1. What an LLM does, mechanically · 12 minExplain next-token prediction, tokens and embeddings.
2. Transformers for architects · 15 minExplain attention and context windows at the level architects need.
3. Latency and cost of a model call · 12 minExplain prefill vs decode, TTFT vs TPOT and token pricing.
4. Prompting vs RAG vs fine-tuning · 12 minChoose the right adaptation technique for a use case.

An open-book exam: instead of memorizing everything, the model looks up the right pages first, then answers.

1. Why RAG · 11 minExplain what RAG solves and what it doesn't.
2. Embeddings and vector search · 12 minExplain embeddings, similarity and ANN search.
3. HNSW and index trade-offs · 12 minCompare HNSW, IVF-PQ and DiskANN on recall, latency and memory.
4. Ingestion and chunking · 13 minDesign parsing, chunking and re-embedding for fresh documents.
5. Hybrid search, reranking and query rewriting · 13 minCombine BM25 + vectors and add a reranker.
6. Permission-aware RAG · 12 minPropagate document ACLs into the index and filter at query time.

A kitchen with one giant oven: the trick is fitting as many dishes in at once without burning any (batching), and not wasting shelf space (KV cache paging).

1. Why decode is memory-bound · 12 minEstimate tokens/s from memory bandwidth and model size.
2. The KV cache and PagedAttention · 13 minCompute KV cache size and explain paging.
3. Batching: throughput vs latency · 12 minExplain continuous batching and its latency trade-off.
4. Quantization, speculative decoding, prefix caching · 13 minChoose optimizations and know their quality risks.
5. Sizing a GPU fleet; self-host vs API · 14 minSize GPUs for a target load and compare with API cost (and a local Mac).

A school front office that routes every call to the right teacher, keeps a list of FAQ answers, and makes sure nobody runs up the phone bill.

1. Why an LLM gateway · 11 minList what a gateway centralizes: keys, routing, limits, logging.
2. Prompt caching as architecture · 12 minStructure prompts with a stable prefix to reuse cached computation.
3. Semantic caching · 11 minDecide when caching by meaning is safe.
4. Routing, fallbacks and budgets · 12 minDesign model cascades, provider fallback and per-tenant token budgets.

A new intern with a phone and a list of approved apps: they figure out steps, call the tools, check results, and ask before doing anything risky.

1. Workflows vs agents · 12 minChoose between a fixed workflow and an autonomous agent.
2. The agent loop (ReAct) · 12 minTrace reason, act, observe and its cost/error propagation.
3. Designing tools · 12 minWrite tool interfaces an agent can use reliably.
4. MCP in practice · 13 minExplain MCP clients, servers, tools and resources.
5. Safe side effects: idempotency and approvals · 12 minMake an agent's actions safe with idempotency, allow-lists and human approval.

Before a new driver goes on the highway: a written test, a driving test, and bumpers on the car.

1. How do you know it works? Error analysis first · 12 minStart evals from real failures, not generic metrics.
2. LLM-as-judge done right · 12 minBuild and validate a judge against human labels.
3. RAG metrics and regression evals in CI · 12 minMeasure faithfulness and retrieval quality and catch regressions.
4. Prompt injection · 12 minExplain direct and indirect injection and why it's hard to fix.
5. Layered guardrails · 11 minDesign input/output filtering and permissions outside the model.

Lending your diary to a tutor: you want rules on who reads it, where it's kept, and that it's never photocopied.

1. Data flows and trust boundaries for AI · 12 minMap where enterprise data goes in an AI system.
2. PII, retention and residency · 12 minDesign PII redaction, zero-retention and regional processing.
3. Governance frameworks · 12 minUse NIST AI RMF and EU AI Act basics as checklists.

You learned how to cook; this is a fully equipped professional kitchen. Amazon Bedrock hands you the ovens (models), the pantry system (knowledge bases), the safety inspector (guardrails) and the tasting panel (evaluations), and you still decide the menu.

1. Amazon Bedrock as the model layer · 13 minChoose models and Bedrock inference options (on-demand, cross-Region inference, batch, Provisioned Throughput) and design a resilient, switchable model call.
2. RAG on AWS: Knowledge Bases and vector stores · 13 minDesign a Bedrock knowledge base: data sources, chunking, embeddings, vector store, metadata filters, reranking and keeping the index current.
3. Agents on AWS: Bedrock Agents, AgentCore and Step Functions · 13 minChoose between Amazon Bedrock AgentCore with an agent framework and Step Functions, read Bedrock Agents Classic designs (closed to new customers), and bound an agent with tools, IAM, stopping conditions and human approval.
4. Bedrock Guardrails and data protection · 13 minConfigure Bedrock Guardrails policies, place them in a defence-in-depth design with ApplyGuardrail, and protect the data path with IAM, PrivateLink, KMS and PII detection.
5. Evaluating, monitoring and troubleshooting on Bedrock · 13 minSet up Bedrock evaluations (programmatic, LLM-as-a-judge, human, RAG), invocation logging and CloudWatch metrics, and diagnose the common generative AI failures from the evidence.
6. Multimodal inputs: documents, images, audio and video for foundation models · 13 minTurn documents, images, audio and video into model-ready input with Bedrock Data Automation, Amazon Transcribe, Amazon Textract or a multimodal embedding model, and choose how a knowledge base parses them.
7. Validating and formatting data for foundation models · 13 minStop bad data before it reaches a model with AWS Glue Data Quality, enrich it with Amazon Comprehend, and format Converse requests with typed content blocks inside their limits.
8. Prompt engineering on Bedrock: techniques, structured outputs and Prompt Management · 13 minApply Bedrock's prompt design techniques, enforce output format with structured outputs instead of retries, and govern prompts as versioned Prompt Management resources called by ARN.
9. Bedrock Flows, prompt optimization and prompt regression testing · 13 minBuild a multi-step prompt chain with Amazon Bedrock Flows (the exam's “Prompt Flows”) and release it through versions and aliases, choose simple or advanced prompt optimization, and gate every prompt change on a regression test.
10. Assistants for builders and employees: Amazon Q Developer, Q Business, Kiro and Amazon Quick · 13 minTell Amazon Q Developer from Amazon Q Business as the exam frames them, state their 2026 status and successors (Kiro, AWS Transform, Amazon Quick) with dates, and map the rest of task 2.5's development tools.
11. Bias and drift for predictive models: Clarify, Model Monitor and what replaced them · 13 minMeasure bias before and after training, monitor a deployed model for data, quality, bias and attribution drift the way the exam expects (SageMaker Clarify and Model Monitor), and rebuild the same monitoring with AWS's named replacements now that both are closed to new customers.
12. Fairness and drift in foundation model apps: evaluations, guardrails, logs and A/B tests · 13 minMeasure stereotyping and harm in a foundation model application with evaluation jobs, keep guardrails (runtime control) and evaluations (measurement) in their separate roles, detect drift from invocation logs and scheduled evaluations, and compare prompt or flow versions with controlled A/B tests.
13. Customizing a model on Bedrock, and serving it · 13 minChoose between prompt engineering, fine-tuning, continued pre-training, distillation, reinforcement fine-tuning and Custom Model Import on Bedrock, and decide how the resulting model is served: on-demand deployment, an imported model on demand, or Provisioned Throughput.
14. Cost, performance and governance for generative AI on AWS · 13 minCut token cost and latency with model choice, prompt caching, routing, batch and streaming, and set up prompt governance, model cards and audit trails.

Your first builds: small, well-known machines where every part has a clear job.

1. URL shortener (walkthrough) · 15 minDesign ID generation, redirect path caching and async analytics.
2. URL shortener (your attempt) · 20 minSolve the case on the canvas at your fading rung.
3. Rate limiter (walkthrough) · 15 minDesign a distributed rate limiter with Redis.
4. Unique ID generator · 12 minCompare UUIDs, ticket servers and Snowflake IDs.
5. Key-value store · 15 minDesign a Dynamo-style KV store.
6. Notification system · 15 minDesign multi-channel notifications with retries and dedup.

Bigger builds where millions of people use the machine at the same time.

1. Chat app · 15 minDesign WebSocket fan-out, message ordering and offline delivery.
2. News feed · 15 minChoose fan-out on write vs read and handle celebrities.
3. Web crawler · 15 minDesign the frontier, politeness and dedup.
4. Ride sharing · 15 minDesign geospatial indexing and driver matching.
5. File storage (Dropbox) · 15 minDesign chunked uploads, sync and metadata.
6. Video platform (YouTube) · 15 minDesign transcoding, adaptive bitrate and CDN delivery.
7. Payment system · 15 minDesign idempotent payments, a ledger and reconciliation.
8. Ticketmaster · 15 minDesign seat holds under contention and a waiting room.

Same building skills, but one of the machines is a very smart, very expensive, sometimes-wrong assistant.

1. ChatGPT-like service · 15 minDesign streaming chat, conversation storage and a GPU/gateway layer.
2. Enterprise RAG assistant · 15 minDesign multi-tenant RAG with ACLs, freshness, citations and evals.
3. Agent platform · 15 minDesign an agent runtime with sandboxed tools, MCP and approvals.
4. Recommendation system · 15 minDesign candidate generation + ranking with a feature store.
5. Real-time voice agent · 15 minBudget latency across speech-to-text, LLM and text-to-speech.
6. Document processing pipeline · 15 minDesign OCR/extraction with queues, retries and human review.

Instead of building a brand-new house, you're renovating one with people still living in it, a strict budget and a landlord with rules.

1. What FDEs and Solutions Architects actually do · 12 minDescribe the role, its interview loop and what gets evaluated.
2. Decomposition framework · 13 minTurn a vague brief into mission, stakeholders, data, constraints and V1.
3. Discovery questions · 12 minRun discovery on users, data, identity, change windows and success metrics.
4. Brownfield integration patterns · 13 minIntegrate with SSO, legacy APIs and messy data; plan rollback.
5. Scenario: support agent on a legacy CRM · 20 minSolve an FDE scenario end to end.
6. Scenario: traffic spike under a cost cap · 20 minHold latency and cost when traffic jumps 10x.

Scrimmage games before the real match, and one project you can show anyone.

1. Mock protocol and self-review · 12 minRun a timed mock and review it with the rubric.
2. Writing a design doc · 13 minWrite a design doc and ADRs for a real project.
3. Capstone: design your own AI system · 30 minProduce a full design doc + diagram for a real AI/enterprise project and defend it in a mock.