engineering-practice
Engineering Practice
The habits that separate a hobby project from a professional team — testing well, shipping changes safely, and keeping a service healthy in production.
Start track →Start from zero
Before the senior material: what engineering practice even is, and the handful of words the rest of the track assumes you already know.TDD and property-based testing
Test-first is design pressure, not a coverage ritual: red-green-refactor surfaces bad interfaces early, the boundary rule tames test doubles, property tests find edge cases you'd never enumerate, and mutation testing is the honest metric for whether your suite would notice a bug.Contract testing
End-to-end integration testing collapses at scale; consumer-driven contracts make the consumer state the truth, the provider verifies it through a broker, and can-i-deploy turns the verification matrix into a deployment-safety gate — replacing most cross-service e2e for known internal consumers.Code review
Review exists to catch design and intent, not style — automate the mechanical; PR size sets both latency and detection, severity-tagged actionable feedback beats verdicts, and at scale you route ownership, time-box pickup, and sometimes move review continuous or post-commit.Trunk-based development
Why integration frequency is the lever behind elite delivery: merge to trunk daily, hide unfinished work behind flags, gate every merge on green CI, and delete branches and flags as fast as you create them.Feature flags
Feature flags: decoupling deploy from release without drowning in flag debt
Flags ship code dark and release by toggle, buying gradual rollout and instant kill-switch. The senior cost: every flag…
Postmortems
Blameless postmortems: turning outages into systems you fix, not people you blame
Blame makes people hide incidents, so you lose the learning. A blameless postmortem treats failure as data: timeline,…
On call
On-call and incident response: every page must be actionable
On-call lives or dies on one rule: every alert is actionable or it is deleted. Symptom-based, SLO-driven pages catch…
Debugger mastery
A debugger is a controlled-execution microscope; breakpoints, watchpoints, core dumps and live tracing turn an unreproducible bug into an observable one.Putting it together
Putting it together: practices are one feedback loop, not a checklist
TDD, contract tests, review, trunk-based dev, flags, on-call, and postmortems are not independent rituals — they form…
Build with this track
Guided projects that exercise what you learn here.
At-least-once job queue
Build a durable job queue on Postgres with visibility timeouts and idempotent consumers, so a crashed worker never drops a job.
Bloom filter
Build a space-efficient probabilistic set that answers membership queries in O(1) with a tunable false-positive rate — and understand exactly why it can never produce false negatives.
Cache stampede lab
Reproduce a thundering-herd cache miss under load, then kill it with single-flight and early-expiry recomputation.
Circuit breaker
Build a circuit breaker that stops hammering a failing dependency, probes it safely with a half-open state, and resets automatically — the exact pattern that keeps microservice cascades from turning one bad node into a full outage.
Consistent hashing ring
Build a virtual-node hash ring that remaps only the minimum set of keys when a node joins or leaves — the foundational primitive behind Dynamo, Cassandra, and every sharded cache that must survive node churn without a full reshuffle.
Feature-flag service
Build a small flag service with targeting rules, percentage rollouts, and a typed SDK that evaluates flags client-side from a cached ruleset.
Huffman coding
Build a lossless compressor from scratch: construct the optimal prefix-free code tree bottom-up, derive the bit strings, and prove the round-trip is exact and the output is shorter than fixed-width encoding.
Offline PWA sync
Offline-first notes PWA: a local write queue (IndexedDB) that syncs on reconnect with last-writer-wins conflict resolution, a service worker for asset caching, and background sync for missed flushes.
Presigned upload flow
Direct-to-storage uploads via presigned URLs with size/content-type limits and a completion webhook that verifies the object actually arrived — so your API server never touches file bytes.
Query plan visualizer
Paste an EXPLAIN (ANALYZE, FORMAT JSON) and render the plan tree with per-node timing and row-estimate error, so a bad join jumps out visually.
Distributed rate limiter
Build a token-bucket limiter that holds across many app instances by keeping the counter in Redis, not in process memory.
Regex engine
Build a regular expression engine from scratch using Thompson NFA construction and subset simulation — the same technique that makes grep and re2 immune to catastrophic backtracking.
Skip list
Build a probabilistic ordered data structure that delivers O(log n) search, insert, and delete without the rotation bookkeeping of balanced trees — just layered express lanes through a sorted linked list.
Text diff — Myers algorithm
Implement the Myers diff algorithm from scratch: compute the longest common subsequence, backtrack an edit script, prove minimality, and apply patches so any round-trip is byte-perfect.
Topological build scheduler
Build a DAG-based task scheduler — like Make or a CI pipeline — that orders jobs by dependency, detects cycles before they deadlock, and identifies which tasks can run in parallel.
Union-Find (Disjoint Set Union)
Build a disjoint-set structure from a naive parent array up to near-constant amortized time — then use it to drive Kruskal's MST algorithm on a weighted graph.
URL shortener at scale
Build a URL shortener that survives real traffic — then run it: deploy it, watch it, and work the incident when one hot link melts your cache.
SQL & PostgreSQL, deep
The SQL language and Postgres internals for senior engineers — joins, windows, CTEs, transactions, the planner.