Archived 2026-10-01. Superseded by the three-course series — SWE 101 → SWE 102 → SWE 103. Kept for the reasoning it records; it is no longer the plan.
Week by week. Each week has a topic, its sub-topics, and a link straight to the chapter in this vault. Read the link, close the laptop, write the notebook page.
Week number = notebook section number. Topic 13.4 in this file is page-marked 13.4 in the book.
Companion files: Track A — Hire · why it’s ordered this way · notebook method
How to read a week
## Week N — Title
Read: the chapters, in order
Topics: N.1, N.2 … → one notebook page each (or fewer — see the method)
DSA: the pattern for that week, back of the book
By Sunday: what must be true before the week closes
Section D (DSA) runs every single week, two sessions, from week 1. It is never a block you finish. That is the main correction to the original scheme, where DSA sat in weeks 8–12 and went untouched for forty weeks before anyone tested it.
Notebook layout: index on pages 1–4 · number every page before you start · one week = one tabbed section · Section D worked from the back of the book forward so 30 weeks of patterns don’t cut through the units · budget ≈ 160 pages.
A link with no chapter behind it is marked ⚠️ — that topic has no coverage in the vault yet, so either skip it or it’s a gap worth filling.
The 30 weeks at a glance
| Weeks | Block | Depth |
|---|---|---|
| 1 | Introduction to software engineering & the audit | Skim |
| 2–4 | Software design | Write |
| 5–8 | Architecture & system design | Write |
| 9–11 | Databases | Write |
| 12–15 | Networking & the web | Write |
| 16–17 | Security | Write |
| 18–19 | Backend consolidation | Reconstruct |
| 20–23 | AI engineering | Write |
| 24 | Testing & quality | Gap-fill |
| 25 | DevOps & delivery | Gap-fill |
| 26–29 | Concurrency & distributed systems | Write |
| 30 | Review & mock loops | — |
| 31+ | The CS spine | Ongoing |
| D | DSA — every week, weeks 1–30 | Write |
“Reconstruct” = you’ve shipped it; write from memory, then diff against your code. “Gap-fill” = read the chapter, write only what surprised you. Week 1’s audit sets these.
Contents
This doubles as the notebook index. The header says week number = notebook section number and index on pages 1–4 — this is what goes on those pages. Topic 13.4 here is page-marked 13.4 in the book.
Generated, not hand-written — run python3 learning/swe-101/scripts/generate-contents.py after editing any week. Edit a week, regenerate, never both.
Week 1 · Introduction
- 1 — Introduction to Software Engineering, and the audit · D1
1.1Programming vs engineering; where the time actually goes1.2The SDLC: requirements → design → implementation → testing → deployment → maintenance, and what breaks when each is skipped1.3The engineering roles — and the honest way to tell them apart (the failure you fear)1.4Abstraction, decomposition, trade-offs1.5The audit
Weeks 2–4 · Software design
- 2 — Design principles · D2
2.1Modularity — what a module is, and what makes a bad one2.2Coupling and cohesion2.3Abstraction and interfaces2.4Separation of concerns2.5DRY, KISS, YAGNI — and where each one is wrong2.6SOLID, one letter at a time — and when it’s over-engineering2.7Composition over inheritance
- 3 — Design patterns · D3
3.1Creational — factory, builder, and why singleton is usually a mistake3.2Structural — adapter, decorator, facade, proxy3.3Behavioural — strategy, observer, command, state3.4Dependency injection and wiring
- 4 — Structuring a codebase · D4
4.1Layers: controllers, services, repositories4.2Organising by layer vs by feature4.3Hexagonal and clean architecture4.4Modular monolith → services, and when to split
Weeks 5–8 · Architecture & system design
- 5 — How to approach system design · D5
5.1The sequence, so you never freeze5.2Functional vs non-functional requirements5.3Back-of-envelope estimation5.4Scalability and performance, vertical vs horizontal
- 6 — Availability, caching, load balancing · D6
6.1Availability, reliability, what “three nines” actually costs6.2CAP and consistency6.3Load balancing, proxies, reverse proxies6.4Caching, and cache invalidation
- 7 — Data, messaging, communication · D7
7.1Databases at scale7.2Messaging and async7.3REST, gRPC, GraphQL, WebSockets
- 8 — Architectural patterns and trade-offs · D8
8.1Monolith vs microservices vs serverless8.2Resilience: timeouts, retries, backoff, circuit breakers, bulkheads8.3Data and integration patterns8.4Microservices patterns8.5Trade-off articulation — saying “I’d choose X because Y” instead of “it depends”
Weeks 9–11 · Databases
- 9 — The relational model and SQL · D9
9.1What a database actually is9.2The relational model — tables, rows, keys, relationships9.3Normalisation, and when to denormalise on purpose9.4SQL: SELECT, JOIN, GROUP BY, aggregates, subqueries, CTEs
- 10 — Database internals · D10
10.1Storage and page layout10.2B-trees and indexes10.3LSM trees, and why new engines choose them10.4The query pipeline10.5Join algorithms and the optimiser10.6EXPLAIN ANALYZE— estimated vs actual rows as the diagnostic
- 11 — Transactions, durability, operations · D11
11.1Transactions and ACID11.2Isolation levels and MVCC11.3Durability, the WAL, recovery11.4Replication and scaling — “replication is not a backup”11.5Operating: migrations,lock_timeout, pooling, backups
Weeks 12–15 · Networking & the web
- 12 — The network and IP · D12
12.1What a network is; the layered model12.2The link layer, MAC addresses12.3IP addressing and subnetting12.4Routing
- 13 — TCP and UDP · D13
13.1UDP and ports13.2TCP connection lifecycle — handshake, teardown, states13.3Reliability and flow control13.4Congestion control13.5Sockets and the network API
- 14 — DNS, HTTP, TLS · D14
14.1DNS in depth14.2HTTP and its evolution — 1.1, 2, 314.3TLS and transport security14.4QUIC14.5Cookies, sessions, headers
- 15 — The edge, performance, debugging · D15a
15.1NAT, firewalls, middleboxes15.2Proxies, reverse proxies, CDNs15.3Latency vs bandwidth, RTT, head-of-line blocking15.4Debugging:dig,curl -v,ss,tcpdump
Weeks 16–17 · Security
- 16 — Identity: authentication and authorisation · D15b
16.1Authentication vs authorisation16.2Password hashing — bcrypt/argon2, and why not SHA-25616.3Sessions vs JWT, and when JWT is the wrong choice16.4OAuth 2.0 / OIDC16.5Least privilege
- 17 — Attacks and defences · mixed review begins — 5 problems/week, patterns drawn at random. This is what interviews actually are.
17.1Input validation and output encoding17.2Injection: SQL, command, template17.3XSS, CSRF, SSRF17.4Security headers and same-origin policy17.5Symmetric, asymmetric, signatures, PKI17.6TLS in practice17.7Secrets management17.8Prompt injection and LLM-specific risk
Weeks 18–19 · Backend consolidation
- 18 — Backend: the request path · mixed review, 5 problems
18.1What a backend is18.2HTTP servers; rate limiting at the edge18.3The request lifecycle end to end18.4Runtime and concurrency models — the Node event loop18.5REST design and resource modelling18.6⚠️ API versioning — no dedicated chapter; thin coverage only
- 19 — Backend: cross-cutting concerns · mixed review, 5 problems
19.1Validation, error handling, error contracts19.2Rate limiting19.3Structured logging and configuration19.4Databases in the backend; pooling, migrations19.5Background jobs and queues19.6Idempotency19.7Caching layers
Weeks 20–23 · AI engineering
- 20 — LLMs: the ground floor · mixed review, 5 problems
20.1What the role actually is20.2How LLMs work — enough to reason about why they fail20.3The model landscape20.4Calling models: streaming, tokens, temperature, context windows
- 21 — Prompting, structure, retrieval · mixed review, 5 problems
21.1Prompt engineering; prompts as versioned artifacts21.2Structured output21.3RAG and embeddings — chunking, hybrid search, reranking
- 22 — Tools and agents · mixed review, 5 problems
22.1Tools and MCP22.2Agents, and when not to use one22.3Multimodal
- 23 — Evals and production ⭐ · mixed review, 5 problems
23.1Evals — golden sets, scorers, regression runs in CI23.2Reliability and plumbing — retries, fallbacks, timeouts23.3Cost, caching, latency23.4Safety in production — PII, output filtering23.5Practice
Week 24 · Testing & quality
- 24 — Testing and quality · mixed review, 5 problems
24.1The pyramid: unit, integration, e2e24.2Test doubles: stub, mock, fake, spy24.3What not to test; flaky tests24.4Code review, giving and receiving24.5Observability: logs, metrics, traces
Week 25 · DevOps & delivery
- 25 — DevOps and delivery · mixed review, 5 problems
25.1Docker — layers, caching, multi-stage25.2CI/CD concepts25.3CI pipelines — what runs on every push25.4CD, deployment strategies, releases25.5Pipeline security and secrets25.6Troubleshooting workflows
Weeks 26–29 · Concurrency & distributed systems
- 26 — Concurrency · mixed review + first timed mock, 45 min, unseen medium
26.1Processes vs threads26.2Scheduling26.3Concurrency vs parallelism; the Node event loop26.4Locks, mutexes, deadlock, race conditions
- 27 — What makes distributed systems hard · mixed + timed mock
27.1What makes them hard27.2Theoretical limits27.3Time and ordering — why you can’t trust clocks27.4Consistency models
- 28 — Replication, partitioning, consensus · mixed + timed mock
28.1Replication28.2Partitioning and sharding28.3Consensus28.4Raft
- 29 — Transactions, logs, failure · mixed + timed mock
29.1Distributed transactions and saga29.2The log and event-driven architecture29.3Idempotency and retry storms29.4Failure detection29.5Testing distributed systems
Week 30 · Review
- 30 — Review and mock loops
30.1Full system-design mock: ride-sharing, then video platform30.2Two timed coding mocks30.3The project story — 2 minutes, 5 minutes, 20 minutes of depth30.4Behavioural — six STAR stories from real projects30.5Re-audit weeks 2–29; anything still don’t know it gets a fortnight
Week 31+ · The CS spine
- 31 — The CS spine (ongoing)
31.1How a program runs — compile, link, load31.2Memory: stack, heap, process layout31.3Virtual memory and the MMU31.4The memory hierarchy and caches31.5Syscalls and the kernel boundary31.6Complexity classes, P vs NP — knowing when to stop looking31.7Automata — why regexes and parsers look the way they do31.8Compilers: lexer → parser → IR → codegen31.9Garbage collection31.10Why one O(n) loop is 30× slower than another
153 topics across 31 weeks. Generated from the weeks below — regenerate rather than hand-edit.
Week 1 — Introduction to Software Engineering, and the audit
Read: Introduction to Software Engineering (01–03) · index — what you’ve already built and which domains it exercises
Topics
- 1.1 Programming vs engineering; where the time actually goes → 01
- 1.2 The SDLC: requirements → design → implementation → testing → deployment → maintenance, and what breaks when each is skipped → 02
- 1.3 The engineering roles — and the honest way to tell them apart (the failure you fear) → 03
- 1.4 Abstraction, decomposition, trade-offs → 01 · PRIMETECHIE frames the whole vault this way
- 1.5 The audit → the checklist — mark every topic in weeks 2–30 know it / half know it / don’t know it
DSA: D1 → Prefix sum
By Sunday: the audit is done, and “What is a software engineer?” is written in your own words, one page, nothing open.
This gap is now closed. Topics 1.1–1.3 had no chapter — the vault is written for practitioners and never wrote down what the profession is. foundations/software-engineering/ was written to fill exactly this week. It’s deliberately short: you’re twelve projects deep, so most of it will confirm what you already know by doing, and its real value is vocabulary. 1.5 is still the actual deliverable of the week.
Week 2 — Design principles
Read: clean code · coupling and cohesion · SOLID principles
Topics
- 2.1 Modularity — what a module is, and what makes a bad one → clean code
- 2.2 Coupling and cohesion → coupling and cohesion
- 2.3 Abstraction and interfaces → hexagonal & clean architecture
- 2.4 Separation of concerns → by layer vs by feature
- 2.5 DRY, KISS, YAGNI — and where each one is wrong → clean code
- 2.6 SOLID, one letter at a time — and when it’s over-engineering → SOLID principles
- 2.7 Composition over inheritance → structural patterns
DSA: D2 → Two pointers
By Sunday: closed-book — name three places in your own code where coupling hurt you.
Week 3 — Design patterns
Read: design patterns, all three chapters
Topics
- 3.1 Creational — factory, builder, and why singleton is usually a mistake → creational
- 3.2 Structural — adapter, decorator, facade, proxy → structural
- 3.3 Behavioural — strategy, observer, command, state → behavioural
- 3.4 Dependency injection and wiring → DI & wiring
DSA: D3 → Sliding window
By Sunday: closed-book — pick three patterns; for each, the problem it solves and what it costs you.
Week 4 — Structuring a codebase
Read: structuring a backend, all five chapters
Topics
- 4.1 Layers: controllers, services, repositories → layers
- 4.2 Organising by layer vs by feature → by layer vs feature
- 4.3 Hexagonal and clean architecture → hexagonal
- 4.4 Modular monolith → services, and when to split → modular monolith
DSA: D4 → Fast & slow pointers
By Sunday: Design a banking system. Don’t code it. Entities, relationships, responsibilities, interfaces, data, failures, security, scalability. (Your original exercise, kept — it’s the best one in the document, and “don’t code it” is what makes it work.)
Week 5 — How to approach system design
Read: system design fundamentals 01–02
Topics
- 5.1 The sequence, so you never freeze → how to approach it
- 5.2 Functional vs non-functional requirements → same chapter
- 5.3 Back-of-envelope estimation → same chapter
- 5.4 Scalability and performance, vertical vs horizontal → scalability
DSA: D5 → Linked list reversal
By Sunday: design a URL shortener on the board, 45 minutes, out loud, before reading anything. Then compare and write only the gap.
Week 6 — Availability, caching, load balancing
Read: availability · CAP · load balancing · caching
Topics
- 6.1 Availability, reliability, what “three nines” actually costs → availability
- 6.2 CAP and consistency → CAP
- 6.3 Load balancing, proxies, reverse proxies → LB & proxies
- 6.4 Caching, and cache invalidation → caching
DSA: D6 → Monotonic stack
By Sunday: design a chat application.
Week 7 — Data, messaging, communication
Read: databases at scale · messaging · communication
Topics
- 7.1 Databases at scale → at scale
- 7.2 Messaging and async → messaging
- 7.3 REST, gRPC, GraphQL, WebSockets → communication
DSA: D7 → Top-K elements
By Sunday: design a notification system. You have real RabbitMQ reps — this one should come from experience.
Week 8 — Architectural patterns and trade-offs
Read: architectural patterns 01–04 · the interview round
Topics
- 8.1 Monolith vs microservices vs serverless → the three
- 8.2 Resilience: timeouts, retries, backoff, circuit breakers, bulkheads → resilience
- 8.3 Data and integration patterns → data & integration · transactional outbox
- 8.4 Microservices patterns → microservices
- 8.5 Trade-off articulation — saying “I’d choose X because Y” instead of “it depends” → the round
DSA: D8 → Overlapping intervals
By Sunday: design a payment system. Do this one carefully — you built a payments ledger in nextvibe and a direct-debit sandbox in Java, and interviewers can hear the difference between experience and theory.
Week 9 — The relational model and SQL
Read: what a database is · the relational model · SQL reference · design reference
Topics
- 9.1 What a database actually is → 01
- 9.2 The relational model — tables, rows, keys, relationships → 02
- 9.3 Normalisation, and when to denormalise on purpose → design reference
- 9.4 SQL: SELECT, JOIN, GROUP BY, aggregates, subqueries, CTEs → SQL reference
DSA: D9 → Modified binary search
By Sunday: closed-book — draw the schema of one of your own projects from memory, then diff it against the real one.
Week 10 — Database internals
Read: storage · B-trees · LSM · query pipeline · joins & optimiser
Topics
- 10.1 Storage and page layout → 03
- 10.2 B-trees and indexes → 04
- 10.3 LSM trees, and why new engines choose them → 05
- 10.4 The query pipeline → 06
- 10.5 Join algorithms and the optimiser → 07
- 10.6
EXPLAIN ANALYZE— estimated vs actual rows as the diagnostic → 07
DSA: D10 → Binary tree traversal
By Sunday: take a genuinely slow query from a real project, EXPLAIN ANALYZE it, fix it, record before/after and why.
Week 11 — Transactions, durability, operations
Read: ACID · MVCC · durability · replication · operations
Topics
- 11.1 Transactions and ACID → 08
- 11.2 Isolation levels and MVCC → 09
- 11.3 Durability, the WAL, recovery → 10
- 11.4 Replication and scaling — “replication is not a backup” → 11
- 11.5 Operating: migrations,
lock_timeout, pooling, backups → 12
DSA: D11 → DFS
By Sunday: closed-book — why does adding an index sometimes make things slower?
Week 12 — The network and IP
Topics
- 12.1 What a network is; the layered model → 01
- 12.2 The link layer, MAC addresses → 02
- 12.3 IP addressing and subnetting → 03
- 12.4 Routing → 04
DSA: D12 → BFS
By Sunday: subnet a /24 by hand, no calculator.
Week 13 — TCP and UDP
Topics
- 13.1 UDP and ports → 05
- 13.2 TCP connection lifecycle — handshake, teardown, states → 06
- 13.3 Reliability and flow control → 07
- 13.4 Congestion control → 08
- 13.5 Sockets and the network API → 09
DSA: D13 → Matrix traversal
By Sunday: closed-book — draw the TCP state machine for a connection that opens, transfers, and closes.
Week 14 — DNS, HTTP, TLS
Topics
- 14.1 DNS in depth → 10
- 14.2 HTTP and its evolution — 1.1, 2, 3 → 11
- 14.3 TLS and transport security → 12
- 14.4 QUIC → 13
- 14.5 Cookies, sessions, headers → auth flows
DSA: D14 → Backtracking
By Sunday: “What actually happens when I type google.com?” — one page, from memory. This is the question that gets asked.
Week 15 — The edge, performance, debugging
Topics
- 15.1 NAT, firewalls, middleboxes → 14
- 15.2 Proxies, reverse proxies, CDNs → LB & proxies
- 15.3 Latency vs bandwidth, RTT, head-of-line blocking → 15
- 15.4 Debugging:
dig,curl -v,ss,tcpdump→ 16
DSA: D15a → Dynamic programming, part 1
By Sunday: rewrite the google.com answer and diff it against week 14’s version.
Week 16 — Identity: authentication and authorisation
Read: auth 01–03 · secure authentication
Topics
- 16.1 Authentication vs authorisation → flows · authz
- 16.2 Password hashing — bcrypt/argon2, and why not SHA-256 → hashing
- 16.3 Sessions vs JWT, and when JWT is the wrong choice → flows
- 16.4 OAuth 2.0 / OIDC → OAuth
- 16.5 Least privilege → authz
DSA: D15b → Dynamic programming, part 2
By Sunday: closed-book — draw your flagship’s full auth flow, including refresh and logout.
Week 17 — Attacks and defences
Read: web security 01–04 · cryptography 01–06
Topics
- 17.1 Input validation and output encoding → 01
- 17.2 Injection: SQL, command, template → 01
- 17.3 XSS, CSRF, SSRF → headers & SOP
- 17.4 Security headers and same-origin policy → 04
- 17.5 Symmetric, asymmetric, signatures, PKI → 02 · 04 · 05
- 17.6 TLS in practice → HTTPS & TLS
- 17.7 Secrets management → secrets
- 17.8 Prompt injection and LLM-specific risk → safety & production
DSA: mixed review begins — 5 problems/week, patterns drawn at random. This is what interviews actually are.
By Sunday: threat-model your flagship. Top five risks, and what you did about each.
Week 18 — Backend: the request path
Read: backend foundations 01–04 · APIs & REST
Depth: reconstruct. Write from memory first, then diff against your own code. The diff is the lesson.
Topics
- 18.1 What a backend is → 01
- 18.2 HTTP servers; rate limiting at the edge → 02
- 18.3 The request lifecycle end to end → 03
- 18.4 Runtime and concurrency models — the Node event loop → 04
- 18.5 REST design and resource modelling → APIs & REST
- 18.6 ⚠️ API versioning — no dedicated chapter; thin coverage only
DSA: mixed review, 5 problems
By Sunday: closed-book — draw the complete path of one request through your flagship, including every failure point.
Week 19 — Backend: cross-cutting concerns
Read: best practices · testing a backend · persistence
Topics
- 19.1 Validation, error handling, error contracts → practices
- 19.2 Rate limiting → practices
- 19.3 Structured logging and configuration → practices
- 19.4 Databases in the backend; pooling, migrations → persistence
- 19.5 Background jobs and queues → messaging & async
- 19.6 Idempotency → APIs, auth & practices
- 19.7 Caching layers → caching
DSA: mixed review, 5 problems
By Sunday: write your flagship’s API documentation from memory, then check it and note every gap.
⚠️
backend/06-cross-cutting/is a README with no chapters. Several topics here are covered from07-practicesandarchitecture/instead. That’s the thinnest corner of the vault this course leans on.
Week 20 — LLMs: the ground floor
Read: the AI engineer track 01–04
Topics
- 20.1 What the role actually is → 01
- 20.2 How LLMs work — enough to reason about why they fail → 02
- 20.3 The model landscape → 03
- 20.4 Calling models: streaming, tokens, temperature, context windows → 04
DSA: mixed review, 5 problems
By Sunday: closed-book — why does a model hallucinate, mechanically?
Week 21 — Prompting, structure, retrieval
Topics
- 21.1 Prompt engineering; prompts as versioned artifacts → 05
- 21.2 Structured output → 11
- 21.3 RAG and embeddings — chunking, hybrid search, reranking → 06
DSA: mixed review, 5 problems
By Sunday: closed-book — your RAG returns the wrong chunk. List the six things that could be causing it.
Week 22 — Tools and agents
Topics
DSA: mixed review, 5 problems
By Sunday: closed-book — when is an agent the wrong architecture?
Week 23 — Evals and production ⭐
Read: 12 — evals · 13 · 14 · 10
Topics
- 23.1 Evals — golden sets, scorers, regression runs in CI → 12
- 23.2 Reliability and plumbing — retries, fallbacks, timeouts → 13
- 23.3 Cost, caching, latency → 14
- 23.4 Safety in production — PII, output filtering → 10
- 23.5 Practice → exercises · solutions
DSA: mixed review, 5 problems
By Sunday: the evals harness for your flagship is running in CI, with numbers you can quote.
23.1 is the highest-leverage topic in this entire scheme. Twelve projects, two incidental mentions of evals. It’s what separates “built a chatbot” from “AI engineer”, and it’s half your job target.
Week 24 — Testing and quality
Read: testing fundamentals · testing a backend · PR structure · observability
Depth: gap-fill. Read, write only what surprised you.
Topics
- 24.1 The pyramid: unit, integration, e2e → fundamentals
- 24.2 Test doubles: stub, mock, fake, spy → fundamentals
- 24.3 What not to test; flaky tests → testing a backend
- 24.4 Code review, giving and receiving → PR structure
- 24.5 Observability: logs, metrics, traces → observability · the stack
DSA: mixed review, 5 problems
By Sunday: flagship’s critical path (money, auth, or data-loss) is covered.
Week 25 — DevOps and delivery
Read: docker · CI/CD 01, 08, 09 · secrets
Depth: gap-fill.
Topics
- 25.1 Docker — layers, caching, multi-stage → docker · multi-stage
- 25.2 CI/CD concepts → concepts
- 25.3 CI pipelines — what runs on every push → CI pipelines
- 25.4 CD, deployment strategies, releases → CD & deployment
- 25.5 Pipeline security and secrets → pipeline security · secrets
- 25.6 Troubleshooting workflows → troubleshooting
DSA: mixed review, 5 problems
By Sunday: flagship deploys on merge to main with no manual step.
Week 26 — Concurrency
Read: processes & threads · scheduling · primitives · runtime models
Topics
- 26.1 Processes vs threads → 02
- 26.2 Scheduling → 03
- 26.3 Concurrency vs parallelism; the Node event loop → runtime models
- 26.4 Locks, mutexes, deadlock, race conditions → primitives
DSA: mixed review + first timed mock, 45 min, unseen medium
By Sunday: closed-book — what blocks the event loop, and how would you find out that it’s blocked?
Week 27 — What makes distributed systems hard
Read: distributed systems 01–04
Topics
- 27.1 What makes them hard → 01
- 27.2 Theoretical limits → 02
- 27.3 Time and ordering — why you can’t trust clocks → 03
- 27.4 Consistency models → 04
DSA: mixed + timed mock
By Sunday: closed-book — why can’t you tell a slow node from a dead one?
Week 28 — Replication, partitioning, consensus
Topics
DSA: mixed + timed mock
By Sunday: closed-book — explain Raft leader election to someone who has never heard of it.
Week 29 — Transactions, logs, failure
Topics
- 29.1 Distributed transactions and saga → 10
- 29.2 The log and event-driven architecture → 12
- 29.3 Idempotency and retry storms → 14
- 29.4 Failure detection → 14
- 29.5 Testing distributed systems → 15
DSA: mixed + timed mock
By Sunday: closed-book — why can’t you have exactly-once delivery, and what do you do instead?
Week 30 — Review and mock loops
Read: the interview index — the banks for every domain above
Topics
- 30.1 Full system-design mock: ride-sharing, then video platform
- 30.2 Two timed coding mocks
- 30.3 The project story — 2 minutes, 5 minutes, 20 minutes of depth → story bank
- 30.4 Behavioural — six STAR stories from real projects
- 30.5 Re-audit weeks 2–29; anything still don’t know it gets a fortnight
By Sunday: the audit is redone and the gaps are scheduled.
Week 31+ — The CS spine (ongoing)
Read: OS · architecture · theory · compilers
No deadline, no interviewer asking. This is the unit that answers your actual objective — “understand why software is built the way it is.”
- 31.1 How a program runs — compile, link, load → compilers 01
- 31.2 Memory: stack, heap, process layout → allocation
- 31.3 Virtual memory and the MMU → virtual memory
- 31.4 The memory hierarchy and caches → hierarchy · caches
- 31.5 Syscalls and the kernel boundary → syscalls
- 31.6 Complexity classes, P vs NP — knowing when to stop looking → complexity
- 31.7 Automata — why regexes and parsers look the way they do → automata
- 31.8 Compilers: lexer → parser → IR → codegen → lexing · parsing
- 31.9 Garbage collection → GC
- 31.10 Why one O(n) loop is 30× slower than another → performance
Exercise: perf stat on your own code; explain the IPC.
Section D — DSA, every week
Read: DSA course → the 15 patterns · the coding round
Back of the notebook, worked forward. One page per pattern — format in the method.
| Week | Pattern |
|---|---|
| 1 | Prefix sum |
| 2 | Two pointers |
| 3 | Sliding window |
| 4 | Fast & slow pointers |
| 5 | Linked list reversal |
| 6 | Monotonic stack |
| 7 | Top-K elements |
| 8 | Overlapping intervals |
| 9 | Modified binary search |
| 10 | Binary tree traversal |
| 11 | DFS |
| 12 | BFS |
| 13 | Matrix traversal |
| 14 | Backtracking |
| 15–16 | Dynamic programming |
| 17–30 | Mixed review, patterns drawn at random, 5/week + timed mocks from week 26 |
Weeks 17–30 are the important half. Solving a sliding-window problem in sliding-window week is recognition. Solving one when you don’t know what kind it is, is the actual skill — and that’s what an interview measures.
Complexity, recursion and Big-O are learned through these, not as a block beforehand — that’s why the original Phases 2–3 were folded in here.
Target: 150 problems, ~60% medium, logged with pattern / cold? / time / what I missed.
Where this ends
Weeks 1–30 plus 150 problems plus a shipped flagship with evals is a hirable full-stack / AI engineer. Week 31+ is what makes you a good one, and it doesn’t stop.
The progression you named, and it still holds:
Programming → Computer Science → Software Engineering → Systems Thinking → Architecture.
Software engineering
Infrastructure & security
Computer science
Hardware & engineering