Build your first system

From a web request to a working link service.

1. 1How a web request works
2. 2Size your first service
3. 3Code the capacity planner
4. 4Add a cache
5. 5Share the traffic
6. 6Code the read path
7. 7Connect the pieces
8. 8Keep routing through failure
9. 9Recall the read path
10. 10Speed and volume
11. 11Measure what users feel
12. 12Find the constraint
13. 13Scale with a reason
14. 14Plan for failure
15. 15Performance checkpoint
16. 16Recall under load
17. 17Give data a home
18. 18Model the relationships
19. 19Keep unique identities
20. 20Count events
21. 21Separate customer work
22. 22Make a change safely
23. 23Choose a useful index
24. 24Handle concurrent changes
25. 25Design a document
26. 26Storage checkpoint
27. 27Recall correctness
28. 28Build the batcher
29. 29Prepare to build
30. 30Build a tiny link service

Spread data across machines, make reads fast, and expose a clean API.

1. 31Copy and split the data
2. 32Find the right shard
3. 33Validate a request limit
4. 34Write fast, read later
5. 35Store rows across a ring
6. 36Design for a key-value store
7. 37Recall data placement
8. 38Data at scale checkpoint
9. 39Keep hot data in memory
10. 40Normalize an incoming event
11. 41Cache with simple keys
12. 42Search instead of scan
13. 43Inside the inverted index
14. 44Recall storage engines
15. 45Store big blobs
16. 46Serve from the edge
17. 47Return a bounded page
18. 48Fast reads checkpoint
19. 49Recall bounded reads
20. 50Design a clear API
21. 51Choose REST, RPC, or events
22. 52Let clients ask for shapes
23. 53Call services with contracts
24. 54Recall API boundaries
25. 55Keep a connection open
26. 56Speed up the wire
27. 57Service interfaces checkpoint
28. 58Recall distributed stores
29. 59Prepare the read API
30. 60Build the expiring cache

Decouple work with queues, survive failures, and make every state change safe.

1. 61Choose how services talk
2. 62Put a queue between them
3. 63Apply a fixed-window limit
4. 64Stream events in order
5. 65Route messages to workers
6. 66Recall async basics
7. 67Queue in the cloud
8. 68React to events
9. 69Refill a token bucket
10. 70Run long workflows reliably
11. 71Recall delivery guarantees
12. 72Async systems checkpoint
13. 73Put a server in front
14. 74Balance the load
15. 75Count a sliding window
16. 76Limit the traffic
17. 77Recall rate limits
18. 78Fail fast, recover safely
19. 79Coordinate concurrent work
20. 80Enforce a per-tenant budget
21. 81Break it on purpose
22. 82Recall failure handling
23. 83Resilient services checkpoint
24. 84Recognize a retried operation
25. 85Reject a stale write
26. 86Recall safe traffic
27. 87Reconcile versioned records
28. 88Recall exactly-once
29. 89Prepare the event applier
30. 90Apply events exactly once

Operate and secure a service, then design complete systems end to end.

1. 91Split the monolith carefully
2. 92Package the service
3. 93Calculate bounded retry delays
4. 94Run containers at scale
5. 95Agree on configuration
6. 96Recall packaging and retries
7. 97Measure the service
8. 98See the service
9. 99Production checkpoint
10. 100Schedule only ready jobs
11. 101Delegate access safely
12. 102Carry identity in a token
13. 103Recall operations
14. 104Run an identity provider
15. 105Keep secrets secret
16. 106Separate retries from dead letters
17. 107Defend the web layer
18. 108Recall identity
19. 109Security checkpoint
20. 110Run a design conversation
21. 111Design a URL shortener
22. 112Recall job handling
23. 113Design a chat system
24. 114Design a distributed cache
25. 115Design a payment system
26. 116Design a notification system
27. 117Design lab checkpoint
28. 118Recall defenses
29. 119Recall the design method
30. 120Build a bounded worker plan

Study four production systems, then connect everything you built.

1. 121How WhatsApp delivers messages
2. 122How Netflix streams
3. 123Compare chat designs
4. 124How GitHub collaborates
5. 125How Uber matches rides
6. 126Recall delivery pipelines
7. 127Recall money-safe state
8. 128Recall the cache, end to end
9. 129Trace the whole system
10. 130Real systems checkpoint

Understand how models predict text, shape prompts into contracts, and ground answers in retrieved evidence.

1. 131Predict one token at a time
2. 132Let tokens read each other
3. 133The bundle, not the name
4. 134Turn text into IDs
5. 135Merge the frequent pairs
6. 136Recall what fills the context
7. 137Pin the tokenizer to the model
8. 138Language models checkpoint
9. 139Write the input contract
10. 140Carry state across turns
11. 141The model proposes, code decides
12. 142Suggest while someone types
13. 143Keep the meaning intact
14. 144Recall the output boundary
15. 145Prompts and tools checkpoint
16. 146Give the model an open book
17. 147Index offline, answer online
18. 148Add a stage per failure
19. 149Store facts as typed edges
20. 150Abstain when evidence is thin
21. 151Recall two kinds of evidence
22. 152Rank, filter, then cite
23. 153Search by nearest neighbor
24. 154Retrieval checkpoint

Give tool-using systems bounded authority, then serve and adapt models under a real budget.

1. 155Make a run survive a restart
2. 156Loop until a stopping condition
3. 157Capability is not authority
4. 158Let the runtime decide
5. 159Drive a screen safely
6. 160Recall where trust is granted
7. 161Adapt without keeping everything
8. 162Agent systems checkpoint
9. 163One request, one deadline
10. 164Budget the context window
11. 165Measure before you tune
12. 166Guard the model boundary
13. 167Admit only finishable work
14. 168Recall the cost of context
15. 169Spend more only when it pays
16. 170Fit the model on the fleet
17. 171Serving models checkpoint
18. 172Decide whether to train
19. 173Train a small adapter
20. 174Practice with the open book
21. 175Model adaptation checkpoint

Generate and read images, video, and documents without losing traceable evidence.

1. 176Put words and images together
2. 177Turn a prompt into pixels
3. 178Budget the denoising steps
4. 179Ship the image as a job
5. 180Keep the subject consistent
6. 181Recall one frame to many
7. 182Vision and generation checkpoint
8. 183Say only what you see
9. 184Trace a claim to its source
10. 185Separate likely from grounded
11. 186Compress an image into tokens
12. 187Tile the page, keep order
13. 188Recall the visual token budget
14. 189Route text and image tokens
15. 190Multimodal systems checkpoint
16. 191Keep the page in the record
17. 192Gate the extracted value
18. 193Never curate on one score
19. 194Documents and data checkpoint

Measure quality with benchmarks, judges, and pipelines that survive drift.

1. 195Build a benchmark portfolio
2. 196Score with a model judge
3. 197Find the usable window
4. 198Score the whole trajectory
5. 199Automate the release gate
6. 200Recall what a score proves
7. 201Store the evidence trail
8. 202Why the score moved
9. 203Measuring behavior checkpoint
10. 204Probe everyday reasoning
11. 205Open book or closed
12. 206Grade the math answer
13. 207Run the generated code
14. 208One exam, many subjects
15. 209Recall the multiple-choice limits
16. 210Let people vote
17. 211Reasoning benchmarks checkpoint

Test for harm, monitor and govern production systems, then design one end to end.

1. 212Put limits outside the model
2. 213Test harm by slice
3. 214Attack your own product
4. 215Gate on the worst slice
5. 216Catch implicit hate
6. 217Recall the trust boundary
7. 218Compare groups fairly
8. 219Resist the popular answer
9. 220Check the attack is valid
10. 221Recall the failing slice
11. 222Safety and robustness checkpoint
12. 223Watch more than uptime
13. 224Ship behind a rollback
14. 225Keep authority outside the agent
15. 226Make the decision auditable
16. 227Recall the release loop
17. 228Operating AI checkpoint
18. 229Write the design contract
19. 230Answer an open prompt
20. 231How Gmail finishes sentences
21. 232Compare process and product
22. 233GenAI design checkpoint

Decide what to predict, build the data path that feeds it, and keep the corpus trustworthy.

1. 234Learn a rule from examples
2. 235Decide or describe the data
3. 236Decide whether ML fits
4. 237Write the system contract
5. 238Prove the model generalizes
6. 239Recall the success metric
7. 240Learning problem checkpoint
8. 241Feed training and serving alike
9. 242Make a rerun repeat
10. 243Pin a dataset manifest
11. 244Build features that survive serving
12. 245Guard the test set
13. 246Recall reproducible inputs
14. 247Split before you transform
15. 248Prototype tables in pandas
16. 249Data foundation checkpoint
17. 250Where the corpus comes from
18. 251Keep, quarantine, or review
19. 252Teach behavior with examples
20. 253Turn files into records
21. 254Name the regions on a page
22. 255Recall the decision trail
23. 256Route by document format
24. 257Training data curation checkpoint

Fit models, prove they generalize, then make them small enough to serve.

1. 258Run training as an experiment
2. 259Attribute one prediction
3. 260Predict the next token
4. 261Reward the better action
5. 262Learn from human preferences
6. 263Recall tokens as actions
7. 264Training and explanation checkpoint
8. 265Score reasoning, not fluency
9. 266Test what the model knows
10. 267Combine many test scores
11. 268Split live traffic fairly
12. 269Recall offline against live evidence
13. 270Beyond one score checkpoint
14. 271Budget the whole request
15. 272Shrink the number format
16. 273Teach a smaller student
17. 274Pick the compression that fits
18. 275Keep attention off HBM
19. 276Recall where the time goes
20. 277Efficient models checkpoint

Handle drift, keep people in the loop, and train and serve across many machines.

1. 278Notice the world moved
2. 279Watch four health planes
3. 280Learn without forgetting
4. 281Route a case to a person
5. 282Ship the model to a device
6. 283Recall drift and adaptation
7. 284Changing model checkpoint
8. 285Keep every rank in step
9. 286Route tokens to experts
10. 287Answer inside the deadline
11. 288Give every model an owner
12. 289React to bursty events
13. 290Recall sparse serving costs
14. 291Training and inference checkpoint

Build perception and language systems, meet real-world constraints, and finish at the frontier.

1. 292Turn frames into decisions
2. 293Keep text and versions together
3. 294Retrieve, rank, then shape the slate
4. 295Recall first, then reorder
5. 296Decide where modalities meet
6. 297Recall two-stage retrieval
7. 298Perception and language checkpoint
8. 299Stay inside the validated boundary
9. 300Decide with only past evidence
10. 301Close the loop safely
11. 302Learn where the physics allows
12. 303Handle late and duplicate events
13. 304Recall time-honest evidence
14. 305Fail closed on consequences
15. 306ML in the real world checkpoint
16. 307The runtime holds authority
17. 308Match the claim to evidence
18. 309Let the search pick layers
19. 310Train where the data lives
20. 311Imagine before you act
21. 312Recall the bounded plan
22. 313Give motion a safety gate
23. 314Compute only on change
24. 315Weigh a quantum claim
25. 316Recall hardware-measured claims
26. 317Advanced architectures checkpoint

Implement the request path and the release decision the last two courses described.

1. 318Budget the context window
2. 319Fuse two ranked lists
3. 320Cut a document into chunks
4. 321Assemble an evidence packet
5. 322Report precision and recall
6. 323Split without leaking
7. 324Find the biggest shift
8. 325Decide the release
9. 326Build an inference gateway