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

WeeksBlockDepth
1Introduction to software engineering & the auditSkim
2–4Software designWrite
5–8Architecture & system designWrite
9–11DatabasesWrite
12–15Networking & the webWrite
16–17SecurityWrite
18–19Backend consolidationReconstruct
20–23AI engineeringWrite
24Testing & qualityGap-fill
25DevOps & deliveryGap-fill
26–29Concurrency & distributed systemsWrite
30Review & mock loops—
31+The CS spineOngoing
DDSA — every week, weeks 1–30Write

“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.1 Programming vs engineering; where the time actually goes
    • 1.2 The SDLC: requirements → design → implementation → testing → deployment → maintenance, and what breaks when each is skipped
    • 1.3 The engineering roles — and the honest way to tell them apart (the failure you fear)
    • 1.4 Abstraction, decomposition, trade-offs
    • 1.5 The audit

Weeks 2–4 · Software design

  • 2 — Design principles · D2
    • 2.1 Modularity — what a module is, and what makes a bad one
    • 2.2 Coupling and cohesion
    • 2.3 Abstraction and interfaces
    • 2.4 Separation of concerns
    • 2.5 DRY, KISS, YAGNI — and where each one is wrong
    • 2.6 SOLID, one letter at a time — and when it’s over-engineering
    • 2.7 Composition over inheritance
  • 3 — Design patterns · D3
    • 3.1 Creational — factory, builder, and why singleton is usually a mistake
    • 3.2 Structural — adapter, decorator, facade, proxy
    • 3.3 Behavioural — strategy, observer, command, state
    • 3.4 Dependency injection and wiring
  • 4 — Structuring a codebase · D4
    • 4.1 Layers: controllers, services, repositories
    • 4.2 Organising by layer vs by feature
    • 4.3 Hexagonal and clean architecture
    • 4.4 Modular monolith → services, and when to split

Weeks 5–8 · Architecture & system design

  • 5 — How to approach system design · D5
    • 5.1 The sequence, so you never freeze
    • 5.2 Functional vs non-functional requirements
    • 5.3 Back-of-envelope estimation
    • 5.4 Scalability and performance, vertical vs horizontal
  • 6 — Availability, caching, load balancing · D6
    • 6.1 Availability, reliability, what “three nines” actually costs
    • 6.2 CAP and consistency
    • 6.3 Load balancing, proxies, reverse proxies
    • 6.4 Caching, and cache invalidation
  • 7 — Data, messaging, communication · D7
    • 7.1 Databases at scale
    • 7.2 Messaging and async
    • 7.3 REST, gRPC, GraphQL, WebSockets
  • 8 — Architectural patterns and trade-offs · D8
    • 8.1 Monolith vs microservices vs serverless
    • 8.2 Resilience: timeouts, retries, backoff, circuit breakers, bulkheads
    • 8.3 Data and integration patterns
    • 8.4 Microservices patterns
    • 8.5 Trade-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.1 What a database actually is
    • 9.2 The relational model — tables, rows, keys, relationships
    • 9.3 Normalisation, and when to denormalise on purpose
    • 9.4 SQL: SELECT, JOIN, GROUP BY, aggregates, subqueries, CTEs
  • 10 — Database internals · D10
    • 10.1 Storage and page layout
    • 10.2 B-trees and indexes
    • 10.3 LSM trees, and why new engines choose them
    • 10.4 The query pipeline
    • 10.5 Join algorithms and the optimiser
    • 10.6 EXPLAIN ANALYZE — estimated vs actual rows as the diagnostic
  • 11 — Transactions, durability, operations · D11
    • 11.1 Transactions and ACID
    • 11.2 Isolation levels and MVCC
    • 11.3 Durability, the WAL, recovery
    • 11.4 Replication and scaling — “replication is not a backup”
    • 11.5 Operating: migrations, lock_timeout, pooling, backups

Weeks 12–15 · Networking & the web

  • 12 — The network and IP · D12
    • 12.1 What a network is; the layered model
    • 12.2 The link layer, MAC addresses
    • 12.3 IP addressing and subnetting
    • 12.4 Routing
  • 13 — TCP and UDP · D13
    • 13.1 UDP and ports
    • 13.2 TCP connection lifecycle — handshake, teardown, states
    • 13.3 Reliability and flow control
    • 13.4 Congestion control
    • 13.5 Sockets and the network API
  • 14 — DNS, HTTP, TLS · D14
    • 14.1 DNS in depth
    • 14.2 HTTP and its evolution — 1.1, 2, 3
    • 14.3 TLS and transport security
    • 14.4 QUIC
    • 14.5 Cookies, sessions, headers
  • 15 — The edge, performance, debugging · D15a
    • 15.1 NAT, firewalls, middleboxes
    • 15.2 Proxies, reverse proxies, CDNs
    • 15.3 Latency vs bandwidth, RTT, head-of-line blocking
    • 15.4 Debugging: dig, curl -v, ss, tcpdump

Weeks 16–17 · Security

  • 16 — Identity: authentication and authorisation · D15b
    • 16.1 Authentication vs authorisation
    • 16.2 Password hashing — bcrypt/argon2, and why not SHA-256
    • 16.3 Sessions vs JWT, and when JWT is the wrong choice
    • 16.4 OAuth 2.0 / OIDC
    • 16.5 Least privilege
  • 17 — Attacks and defences · mixed review begins — 5 problems/week, patterns drawn at random. This is what interviews actually are.
    • 17.1 Input validation and output encoding
    • 17.2 Injection: SQL, command, template
    • 17.3 XSS, CSRF, SSRF
    • 17.4 Security headers and same-origin policy
    • 17.5 Symmetric, asymmetric, signatures, PKI
    • 17.6 TLS in practice
    • 17.7 Secrets management
    • 17.8 Prompt injection and LLM-specific risk

Weeks 18–19 · Backend consolidation

  • 18 — Backend: the request path · mixed review, 5 problems
    • 18.1 What a backend is
    • 18.2 HTTP servers; rate limiting at the edge
    • 18.3 The request lifecycle end to end
    • 18.4 Runtime and concurrency models — the Node event loop
    • 18.5 REST design and resource modelling
    • 18.6 ⚠️ API versioning — no dedicated chapter; thin coverage only
  • 19 — Backend: cross-cutting concerns · mixed review, 5 problems
    • 19.1 Validation, error handling, error contracts
    • 19.2 Rate limiting
    • 19.3 Structured logging and configuration
    • 19.4 Databases in the backend; pooling, migrations
    • 19.5 Background jobs and queues
    • 19.6 Idempotency
    • 19.7 Caching layers

Weeks 20–23 · AI engineering

  • 20 — LLMs: the ground floor · mixed review, 5 problems
    • 20.1 What the role actually is
    • 20.2 How LLMs work — enough to reason about why they fail
    • 20.3 The model landscape
    • 20.4 Calling models: streaming, tokens, temperature, context windows
  • 21 — Prompting, structure, retrieval · mixed review, 5 problems
    • 21.1 Prompt engineering; prompts as versioned artifacts
    • 21.2 Structured output
    • 21.3 RAG and embeddings — chunking, hybrid search, reranking
  • 22 — Tools and agents · mixed review, 5 problems
    • 22.1 Tools and MCP
    • 22.2 Agents, and when not to use one
    • 22.3 Multimodal
  • 23 — Evals and production ⭐ · mixed review, 5 problems
    • 23.1 Evals — golden sets, scorers, regression runs in CI
    • 23.2 Reliability and plumbing — retries, fallbacks, timeouts
    • 23.3 Cost, caching, latency
    • 23.4 Safety in production — PII, output filtering
    • 23.5 Practice

Week 24 · Testing & quality

  • 24 — Testing and quality · mixed review, 5 problems
    • 24.1 The pyramid: unit, integration, e2e
    • 24.2 Test doubles: stub, mock, fake, spy
    • 24.3 What not to test; flaky tests
    • 24.4 Code review, giving and receiving
    • 24.5 Observability: logs, metrics, traces

Week 25 · DevOps & delivery

  • 25 — DevOps and delivery · mixed review, 5 problems
    • 25.1 Docker — layers, caching, multi-stage
    • 25.2 CI/CD concepts
    • 25.3 CI pipelines — what runs on every push
    • 25.4 CD, deployment strategies, releases
    • 25.5 Pipeline security and secrets
    • 25.6 Troubleshooting workflows

Weeks 26–29 · Concurrency & distributed systems

  • 26 — Concurrency · mixed review + first timed mock, 45 min, unseen medium
    • 26.1 Processes vs threads
    • 26.2 Scheduling
    • 26.3 Concurrency vs parallelism; the Node event loop
    • 26.4 Locks, mutexes, deadlock, race conditions
  • 27 — What makes distributed systems hard · mixed + timed mock
    • 27.1 What makes them hard
    • 27.2 Theoretical limits
    • 27.3 Time and ordering — why you can’t trust clocks
    • 27.4 Consistency models
  • 28 — Replication, partitioning, consensus · mixed + timed mock
    • 28.1 Replication
    • 28.2 Partitioning and sharding
    • 28.3 Consensus
    • 28.4 Raft
  • 29 — Transactions, logs, failure · mixed + timed mock
    • 29.1 Distributed transactions and saga
    • 29.2 The log and event-driven architecture
    • 29.3 Idempotency and retry storms
    • 29.4 Failure detection
    • 29.5 Testing distributed systems

Week 30 · Review

  • 30 — Review and mock loops
    • 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
    • 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

Week 31+ · The CS spine

  • 31 — The CS spine (ongoing)
    • 31.1 How a program runs — compile, link, load
    • 31.2 Memory: stack, heap, process layout
    • 31.3 Virtual memory and the MMU
    • 31.4 The memory hierarchy and caches
    • 31.5 Syscalls and the kernel boundary
    • 31.6 Complexity classes, P vs NP — knowing when to stop looking
    • 31.7 Automata — why regexes and parsers look the way they do
    • 31.8 Compilers: lexer → parser → IR → codegen
    • 31.9 Garbage collection
    • 31.10 Why 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

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

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

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

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

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

Read: 01 → 04

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

Read: 05 → 09

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

Read: 10 → 13

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

Read: 14 → 16

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

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 from 07-practices and architecture/ 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

Read: 05 · 11 · 06

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

Read: 07 · 08 · 09

Topics

  • 22.1 Tools and MCP → 07
  • 22.2 Agents, and when not to use one → 08
  • 22.3 Multimodal → 09

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

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

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

Read: 05 · 13 · 07 · 08

Topics

  • 28.1 Replication → 05
  • 28.2 Partitioning and sharding → 13
  • 28.3 Consensus → 07
  • 28.4 Raft → 08

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

Read: 10 · 12 · 14 · 15

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.

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.

↑ Back to SWE 101 — Archive