ZERO → HERO · THE COMPLETE DISCIPLINE
Software Engineering
Mastery
From how Python actually runs to designing systems for a 10,000-robot fleet — taught through TraceLab, a real project you build, break, and scale across all six stages. Mechanisms over incantations; failure modes before happy paths.
6Stages
56Lessons
56Widgets
TraceLabthread
1
Foundations: What Actually Happens When Code Runs
9 lessons
Strip away every layer of magic. The learner writes Python daily but has never looked underneath — and you cannot debug an abstraction you believe is magic. Execution, memory, the OS, the shell, data representation, cost models, and the network. No best practices, no tooling incantations — mechanism first, because frameworks rot in five years and mechanisms are good for fifty.
TraceLab milestone: v0 — a single deliberately scruffy Python script that appends run metrics to a CSV file; define the product, trace one line through every layer from source text to syscall, and feel v0's limits.
✓LESSON 1.1
From Source to Execution
What actually happens between typing python train.py and silicon doing work — and why 'Python is slow' is…
✓LESSON 1.2
Memory: The Machine Beneath the Variables
Why b = a copies nothing, why your training script eats 60 GB by epoch 40, and why 'pointer bugs' exist…
✓LESSON 1.3
The Operating System Contract
Your program is a tenant, not an owner — processes, threads, syscalls, signals, and exit codes are the…
✓LESSON 1.4
The Shell Is a Programming Language
Pipes, redirection, exit codes, and the twenty Unix commands that do eighty percent of ops work — the…
✓LESSON 1.5
How Data Is Actually Represented
Bits, bytes, two's complement, IEEE 754, and UTF-8 — why 0.1 + 0.2 != 0.3 and why your loss curves…
✓LESSON 1.6
Big-O as a Budget, Not a Hazing Ritual
Complexity as 'what happens when n grows 10×' — and when the clever O(n) loses to the cache-friendly…
✓LESSON 1.7
The Data Structures You'll Actually Reach For
Arrays, hashmaps, trees, queues, and sets as cost profiles, not implementations — choosing the structure…
✓LESSON 1.8
The Network from First Principles
DNS, TCP, TLS, and the speed of light — what actually happens when you curl a URL, and why latency is…
✓LESSON 1.9
TraceLab v0: The Project Brief and the Wrong Solution
Define the product, scope it honestly, then deliberately build the wrong version — a single script whose…
2
The Craft: From Script to Software
10 lessons
The difference between code that runs and software that survives contact with time, change, and other people. Code is read 10× more than it's written. Git taught from the object model up, because the DAG is the course's first serious abstract data model. Testing as confidence engineering with its lies exposed. The stage ends where this learner's next decade lives: reviewing code — human and AI-generated — without rubber-stamping.
TraceLab milestone: v1 — the v0 script restructured into a real package: a typed, tested CLI/SDK with proper src layout, locked dependencies, designed error handling, a clean git history with a recovered 'disaster' in the reflog, and one AI-generated pull request caught and fixed.
✓LESSON 2.1
Code Is Read 10× More Than It's Written
Naming, function shape, and the named refactoring moves — why the best code looks boring, and why…
✓LESSON 2.2
Git, Actually: The Object Model
Blobs, trees, commits, and refs — git as a content-addressed DAG with movable pointers, not a save…
✓LESSON 2.3
Branching, Merging, and Unscrewing Yourself
Merge vs rebase honestly (including when rebase is vandalism), conflict anatomy, and reflog as the undo…
✓LESSON 2.4
Errors Are Part of the API
The failure path is a feature you design, not an accident you apologize for — exceptions, result values…
✓LESSON 2.5
Types and Invariants: Making Illegal States Unrepresentable
Type hints as machine-checked documentation, parsing over validating, and modeling states so the wrong…
✓LESSON 2.6
Testing I: What Tests Are Actually For
Tests as executable specification and regression armor — and the uncomfortable proof that 100% coverage…
✓LESSON 2.7
Testing II: Doubles, Integration, and the Shape of a Suite
Mocks, stubs, fakes, integration tests, and property-based testing — and the mock-rot spiral where the…
✓LESSON 2.8
Debugging as a Science
Reproduce, hypothesize, bisect, instrument — debugging is experiment design under pressure, not staring.
✓LESSON 2.9
Dependencies, Packaging, and the Supply Chain
Every dependency is a hire you can't interview — virtualenvs, lockfiles, semver's promises and lies, and…
✓LESSON 2.10
Code Review: Humans, Egos, and AI-Generated Diffs
Review is the bottleneck skill of the AI era — knowledge transfer first, bug-catching second, rubber…
3
Systems: Networks, Data, and Concurrency
10 lessons
TraceLab leaves the single machine. HTTP → API design → server internals → relational thinking → queries → transactions → threads → async. Transactions come immediately before threads because interleaving anomalies are the gentlest on-ramp to race conditions. Every layer taught as a mechanism the learner can dissect, because the systems that page you at 2 a.m. are exactly the ones you treated as magic.
TraceLab milestone: v2 — a working client–server system: HTTP API + Postgres + token auth, with the CLI reborn as a client and concurrent telemetry writers exposing a genuine lost-update race that the learner reproduces and fixes with transaction isolation and idempotency.
✓LESSON 3.1
HTTP: The Lingua Franca
Methods, status codes, headers, and statelessness — reading raw HTTP fluently is a superpower for…
✓LESSON 3.2
Designing an API Worth Using
An API is a promise you can't take back — resources, pagination, idempotency keys, and versioning for…
✓LESSON 3.3
Inside the Server: The Request Lifecycle
What FastAPI actually does between the socket and your function — sockets, routing, middleware, workers…
✓LESSON 3.4
Databases I: Relational Thinking
Your dict-of-dicts wants to be tables — schemas, keys, and normalization as anomaly prevention, not…
✓LESSON 3.5
Databases II: Queries, Indexes, and the Planner
B-trees pay for everything — joins, EXPLAIN, and why TraceLab's 'metrics by run' query goes from 4…
✓LESSON 3.6
Databases III: Transactions and Isolation
ACID honestly, and the lies databases tell — dirty reads, lost updates, write skew, and why serializable…
✓LESSON 3.7
Concurrency I: Threads, Processes, and the GIL
Shared mutable state is the original sin — races, locks, deadlocks, and what the GIL actually does to…
✓LESSON 3.8
Concurrency II: Async and the Event Loop
What await actually yields to — cooperative scheduling, I/O-bound concurrency without threads, and the…
✓LESSON 3.9
AuthN and AuthZ: Who Are You, and What May You Do
Sessions, JWTs, OAuth, and API keys for robots — and the iron rule: never roll your own crypto, almost…
✓LESSON 3.10
TraceLab v2: Client–Server, and the First Race
The script becomes a system — API, Postgres, auth, a CLI client, and a genuine race condition you must…
4
Architecture: Design Under Constraint
9 lessons
TraceLab v2 works but is becoming hard to change — on purpose. This stage is where the learner stops adding code and starts making decisions: boundaries, caching, queues, distribution, failure math, security, and migrations. Every distributed component is added only after the monolith demonstrably hurts, because distribution is a cost, not a promotion.
TraceLab milestone: v3 — architected: the God module carved into clean boundaries, an ingest queue with idempotent consumers, a cache in front of the dashboard, the v0 CSV debt finally paid off with a zero-downtime expand-contract migration, the system hardened against an injection attack — and a real design doc defended against a simulated three-persona review.
✓LESSON 4.1
Modules, Boundaries, and Coupling
The only architecture question that matters is what knows about what — carving TraceLab's God module…
✓LESSON 4.2
Monolith, Services, Serverless: An Honest Accounting
Microservices solve an organizational problem you don't have — architecture styles priced in latency, ops…
✓LESSON 4.3
Caching: The Two Hard Problems, Live
The fastest code is code that doesn't run — TTLs, invalidation, stampedes, and the staleness bargain…
✓LESSON 4.4
Queues and Async Work: Decoupling in Time
The ingest path must never block on the slow work — backpressure, at-least-once delivery, idempotent…
✓LESSON 4.5
Distributed Systems Reality
Partial failure is qualitatively different, not just bigger — timeouts, retries that amplify outages,…
✓LESSON 4.6
The Mathematics of Failure
Five 99.9% dependencies cap you below 99.5% — availability arithmetic, Little's Law, and the numbers…
✓LESSON 4.7
Security Is a Design Property
Injection, XSS, broken authz, and leaked secrets — thinking like an attacker, because someone already is.
✓LESSON 4.8
Migrations: Changing the Plane Mid-Flight
Schema changes on live data are the highest-stakes deploys you'll ever do — expand-contract, backfills…
✓LESSON 4.9
TraceLab v3: The Architecture Review
Redesign TraceLab with everything this stage taught, write the design doc, and defend it against three…
5
Shipping & Running: Production Is the Real Exam
10 lessons
Code on a laptop is a rumor; software exists when it runs for someone else — and production is not the finish line, it's the starting line. Artifacts, containers, CI/CD, cloud economics, infrastructure as code, observability, SLOs, and incidents. The stage's final exam is not a quiz — it's a scripted outage the learner must command.
TraceLab milestone: v4 — shipped and survived: containerized with layer discipline, built by a CI pipeline, canary-deployed via declared infrastructure, instrumented with logs/metrics/traces and real SLOs — then deliberately broken in a scripted ingestion outage that the learner commands, mitigates, and writes the blameless postmortem for.
✓LESSON 5.1
Environments, Configuration, and Secrets
Dev, staging, prod, and the eternal mystery of 'works on my machine' — dissected into its actual causes…
✓LESSON 5.2
Containers: What Docker Actually Is
Namespaces, cgroups, and layered filesystems — three Linux features in a trench coat, not a VM and not…
✓LESSON 5.3
CI: Trust Through Automation
You don't deploy code, you deploy a frozen artifact of it — reproducible builds, pipelines that gate…
✓LESSON 5.4
CD: Releasing Without Fear
Blue-green, rolling, canary, and feature flags — deploy frequency is a safety mechanism, and big-bang…
✓LESSON 5.5
Cloud Primitives and the Bill
Compute, storage, IAM, and egress fees — what you're actually buying, what you're still on the hook for…
✓LESSON 5.6
Infrastructure as Code
Clicking in a cloud console is unversioned mutation of production — desired state, plan/apply, and the…
✓LESSON 5.7
Observability: Logs, Metrics, Traces
Instrumenting so that 2 a.m.-you can answer questions current-you hasn't thought of — and dogfooding the…
✓LESSON 5.8
SLOs, Error Budgets, and Alerts That Don't Cry Wolf
100% is the wrong target — what to promise, what to wake up for, and the error budget as the truce…
✓LESSON 5.9
Orchestration: Kubernetes and Why TraceLab Says No
What the scheduler/reconciler model genuinely solves, what it costs, and the honest decision tree that…
✓LESSON 5.10
TraceLab v4: The Outage You've Been Training For
A scripted ingestion outage hits the freshly shipped system — command it, mitigate first, diagnose later…
6
Scale, Judgment, and the Long Game
8 lessons
Everything before this was knowledge; this is taste. The fleet grows to 10,000 robots and TraceLab meets scale, durability, debt, deadlines, and the AI-era question of what the human is actually for. The hardest skills in the discipline live here: scaling restraint, restore-tested durability, paying down your own debt, estimating honestly, and delegating to AI agents without abdicating ownership.
TraceLab milestone: v5 — operated and outgrown: scaled on paper to a 10,000-robot fleet with bottlenecks found in order, replication and restore drills passed, the oldest module strangler-fig migrated, and a capstone blank-page redesign defended through a principal-level design review and a 40-item production-readiness review whose every item links back to the lesson that taught it.
✓LESSON 6.1
Scaling Stories: What Breaks at Each Order of Magnitude
1 → 10 → 100 → 10,000 robots: at every step something different breaks first — scaling is serial…
✓LESSON 6.2
Capacity Planning and the Tail at Scale
Little's Law, the utilization hockey stick at ~80%, and why p99 dominates user experience when requests…
✓LESSON 6.3
Reliability Patterns: Retries, Circuit Breakers, and Load Shedding
Every retry is load you chose to add — taming metastable failure with backoff, jitter, breakers…
✓LESSON 6.4
Data at Scale: Replication, Backups, and Durability
A backup that has never been restore-tested is a prayer — sync vs async replication, failover, and the…
✓LESSON 6.5
Technical Debt and Legacy: The Systems That Outlive Their Authors
Debt is a financial instrument — deliberate vs reckless borrowing, the strangler fig, and why the big…
✓LESSON 6.6
Estimation, Scope, and Saying No
Estimates are distributions, not dates — why software is late, what slicing fixes, and how to communicate…
✓LESSON 6.7
Engineering in the Age of AI
Agents collapse typing and inflate verification — the engineer who can specify, verify, and operate is…
✓LESSON 6.8
Capstone: The Blank-Page Redesign and the Hero's Bar
Design TraceLab from scratch at fleet scale, pass the production-readiness review, and see the whole…
🎓
Certificate
Finish all 56 lessons to unlock
Complete every lesson across all six stages — from source execution to fleet-scale architecture — and claim your personalized certificate of completion. TraceLab's journey, your credentials.
📚
Sources & Further Reading
Canonical works behind this course
These are the real, canonical works behind this course — go deeper here.
Foundations & Computer Science Internals
- Bryant & O'Hallaron, Computer Systems: A Programmer's Perspective (2015, Pearson) — execution pipeline, memory, OS, caching from first principles.
- Aho, Lam, Sethi & Ullman, Compilers: Principles, Techniques, and Tools (2006, Pearson) — tokenizing, parsing, and the journey from source to bytecode.
- Cormen, Leiserson, Rivest & Stein, Introduction to Algorithms, 4th ed. (2022, MIT Press) — canonical reference for complexity, data structures, and algorithm analysis.
- Tanenbaum & Bos, Modern Operating Systems, 4th ed. (2014, Pearson) — processes, scheduling, memory management, and the OS contract.
Craft: Code Quality, Testing & Tooling
- Martin, Clean Code: A Handbook of Agile Software Craftsmanship (2008, Prentice Hall) — naming, function shape, and refactoring discipline.
- Fowler, Refactoring: Improving the Design of Existing Code, 2nd ed. (2018, Addison-Wesley) — catalog of named refactoring moves applied safely.
- Beck, Test-Driven Development: By Example (2002, Addison-Wesley) — TDD as design technique; the foundational TDD text.
- Chacon & Straub, Pro Git, 2nd ed. (2014, Apress) — git internals, the object model, and branching strategies.
Systems: Databases, Networking & Concurrency
- Kleppmann, Designing Data-Intensive Applications (2017, O'Reilly) — transactions, replication, consistency, and distributed data — the single best systems book of the last decade.
- Date, An Introduction to Database Systems, 8th ed. (2003, Addison-Wesley) — relational model, normalization, and query semantics.
- Goetz et al., Java Concurrency in Practice (2006, Addison-Wesley) — the authoritative text on threads, locks, and concurrent correctness (patterns apply beyond Java).
- Fielding, Architectural Styles and the Design of Network-based Software Architectures (2000, UC Irvine doctoral dissertation) — REST as originally defined.
Architecture & Distributed Systems
- Newman, Building Microservices, 2nd ed. (2021, O'Reilly) — service decomposition, coupling, and the organizational cost of distribution.
- Hohpe & Woolf, Enterprise Integration Patterns (2003, Addison-Wesley) — canonical patterns for queues, messaging, and async integration.
- Brewer, Towards Robust Distributed Systems (PODC 2000 keynote) — CAP theorem, the original presentation.
- OWASP, OWASP Top Ten (regularly updated) — the ten most critical web application security risks; authoritative industry baseline.
Shipping, Operations & Scale
- Beyer, Jones, Petoff & Murphy (eds.), Site Reliability Engineering (2016, O'Reilly) — SLOs, error budgets, toil, and the engineering of reliability at scale.
- Forsgren, Humble & Kim, Accelerate: The Science of Lean Software and DevOps (2018, IT Revolution) — empirical evidence linking CI/CD and deployment frequency to organizational outcomes.
- Wiggins, The Twelve-Factor App (2011, Heroku) — config, environments, and portable service design; the canonical 12-factor methodology.