ProjekinAja. Software Engineering Mastery 0 / 56 done
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
0 of 56 lessons complete
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.

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.

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.

🎓

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

Craft: Code Quality, Testing & Tooling

Systems: Databases, Networking & Concurrency

Architecture & Distributed Systems

Shipping, Operations & Scale