Status: queued — starts the Monday after SWE 102’s finish line is met · Length: 11 weeks
How every week works: the four lanes, the rotation and the rules are in SWE 101. Notebook sections are numbered 103.1–103.11.
Why this course
By now the flagship is real and its AI feature is measured. What’s left is what senior-leaning interviews probe: designing a system out loud in 45 minutes, and the database, web and distributed-systems knowledge underneath it. The notes for all of it are written; the reps are not. So the Build lane becomes a design lane: one system design every other week, on the board, out loud, timed.
What moved out on purpose: link layer, subnetting, routing, congestion control, QUIC, NAT, database page layout, LSM trees, durability internals, Paxos and Raft. All good knowledge, rarely asked of a junior TypeScript or AI engineer. They’re in the CS spine below — later, not never.
Course finish line
- Four system designs done out loud and timed: URL shortener, notification system, payment system, chat
- Two full system-design mocks (45 minutes, with someone else asking if possible) and two timed coding mocks
- “What happens when I type google.com”, one page from memory
- One slow query from a real project fixed with
EXPLAIN ANALYZE, before and after recorded - The project story at three lengths: 2 minutes, 5 minutes, 20 minutes of depth
- Six behavioural stories in STAR form, from real projects
- DSA: mixed review, five a week, plus one timed mock a week
Week 1’s first job is the audit of this course’s lessons.
DSA in this course
No new patterns. Every week: five problems drawn at random from NeetCode 150 problems not yet logged, plus one timed 45-minute mock. This is what interviews actually are — the pattern isn’t announced. Draw at least one graph problem every week; that’s the gap interviews exposed.
The eleven weeks
Week 1 — How to approach a design
- Learn (core): how to approach system design · scalability and performance
- Learn (optional): the system design round
- Design: URL shortener — 45 minutes, out loud, before reading anything else. Then write only the gap.
Week 2 — Caching and load balancing
- Learn (core): caching · load balancing and proxies
- Learn (optional): availability · CAP and consistency
- By Sunday: closed-book — where would you put a cache in the URL shortener, and what goes stale?
Week 3 — Messaging and communication
- Learn (core): messaging and async · REST, gRPC, GraphQL, WebSockets
- Learn (optional): databases at scale
- Design: notification system. You have real RabbitMQ reps — this one should come from experience.
Week 4 — Architecture choices
- Learn (core): monolith, microservices, serverless · transactional outbox
- Learn (optional): data and integration patterns · microservices patterns
- By Sunday: closed-book — when would you not use microservices? — said as “I’d choose X because Y”, not “it depends”.
Week 5 — Databases I: querying well
- Learn (core): B-trees and indexes · join algorithms, the optimiser, and EXPLAIN ANALYZE
- Learn (optional): what a database is · the relational model · the query pipeline
- Design: payment system — from your nextvibe ledger and the direct-debit sandbox. Interviewers can hear experience.
- By Sunday: one slow query from a real project,
EXPLAIN ANALYZEd and fixed, before and after recorded.
Week 6 — Databases II: changing data safely
- Learn (core): transactions and ACID · isolation and MVCC
- Learn (optional): operating a database · replication and scaling
- By Sunday: closed-book — why does adding an index sometimes make things slower?
Week 7 — The web, end to end
- Learn (core): DNS · HTTP and its evolution · TLS — three this week; they’re one story.
- Learn (optional): TCP connection lifecycle
- Design: chat application.
- By Sunday: “What happens when I type google.com?” — one page, from memory.
Week 8 — The request path and the event loop
- Learn (core): the request lifecycle · runtime and concurrency models
- Learn (optional): debugging networks · locks, races and deadlock
- By Sunday: closed-book — what blocks the Node event loop, and how would you find out it’s blocked?
Week 9 — Identity
- Learn (core): sessions vs JWT · OAuth and OIDC
- Learn (optional): authorisation · password hashing · signatures and PKI
- By Sunday: draw the flagship’s full auth flow from memory, including refresh and logout.
Week 10 — Distributed systems, the essentials
- Learn (core): what makes distributed systems hard · consistency models
- Learn (optional): replication · partitioning · distributed transactions
- By Sunday: closed-book — why can’t you have exactly-once delivery, and what do you do instead?
Week 11 — Mock loops
- Two full system-design mocks: ride-sharing, then video platform.
- Two timed coding mocks.
- The project story at 2, 5 and 20 minutes → the nextvibe story bank is the model.
- Six STAR stories from real projects. Remote roles probe async communication hard.
- The interview banks: 13 domains. Cover the answer, say it out loud, then compare.
- By Sunday: every finish-line box ticked, or dated.
After the series — the CS spine
Not a course yet. When the series is done, or once employed, this becomes its own course through the usual make-a-course step:
- How a program runs: compilers · memory allocation · virtual memory · syscalls
- Hardware and performance: the memory hierarchy · caches · performance
- Theory: complexity classes · automata · lexing · parsing · garbage collection
- Moved here from the old scheme: link layer · subnetting · routing · congestion control · QUIC · NAT and firewalls · page layout · LSM trees · durability · consensus · Raft
Related
- SWE 101 — the series overview and the weekly rules
- The system design round · the interview banks
Software engineering
Infrastructure & security
Computer science
Hardware & engineering