Tracks
Seven tracks, one per capability the loop tests. Each has a concept inventory, a drill set, build artifacts, a failure-mode catalog, and a self-assessment rubric.
No topic is named without a file that teaches it and a drill that tests it. If you find one, that is a bug — log it in
../STATE.md.
Table of Contents
- The Seven Tracks
- How a Track Is Structured
- Track E: Take-Home and Deep Dive
- Completion Rules
- References
The Seven Tracks
| Track | Directory | Tests which round | Baseline share of 570h |
|---|---|---|---|
| A — Coding under time pressure | coding/ | Technical screen A; onsite Coding 1 & 2 | 25% |
| B — Python internals | python-internals/ | Onsite Coding 2's follow-ups | 12% |
| C — Distributed systems design | systems-design/ | Technical screen B | 15% |
| D — ML & inference infrastructure | ml-infra/ | Onsite system design ("design ChatGPT") | 20% |
| E — Take-home and deep dive | this file + ../projects/ | The 48-hour build and the line-by-line defense | 12% |
| F — Behavioral at staff altitude | behavioral/ | Recruiter screen; onsite behavioral | 10% |
| G — Agentic coding | agentic/ | The beta fifth round | 6% |
Shares are the baseline. They are re-derived from your diagnostic levels per
../diagnostics/RUBRIC.md and
rebalanced at every monthly re-test.
How a Track Is Structured
Every track README has the same five sections, so you always know where to look:
- Concept inventory — everything the track covers, with the file that teaches each item.
- Drill set — what you actually do. Timed, scored, repeatable.
- Build artifacts — the things that exist when the track is done. Code, not notes.
- Failure modes — how people lose this round, and the specific symptom of each.
- Self-assessment rubric — the L0–L3 bands, plus the hire-bar translation.
Track E: Take-Home and Deep Dive
Track E has no directory of its own because its artifacts are real projects. It lives here
plus ../projects/.
The reported shape (rows 9–15 of ../research/source-report.md):
a 48-hour window to "build something real" — the given example being a distributed webhook
delivery system with retry logic and dead-letter queues — followed by a round in which the
interviewer walks your code line by line, from a question list he wrote after reading it.
The insight that should reorganize how you build
The take-home and the deep dive are one round, not two. The take-home's real function is to generate a personalized interrogation surface. So:
Every decision you make in the 48 hours is a question you will be asked in week three.
Which inverts the optimization target. It is not "best code." It is "code every line of which I can defend, plus a written record of the alternatives I rejected." A slightly simpler system you can defend completely beats a sophisticated one containing three choices you made on autopilot at hour 31 and cannot now reconstruct.
This is inference I1 in ../research/findings.md
— labelled as inference, not sourced. But it follows directly from the reported fact that the
interviewer writes the question list after reading your code.
The 48-Hour Playbook
Reported grading criteria converge tightly across sources: code quality, test coverage, a written design doc explaining tradeoffs, and how you handled the deliberately under-specified parts. One source puts it bluntly — a working solution with a thoughtful README beats a clever solution with no docs.
The 48 hours include sleep. Budget them:
| Hours | Phase | Output |
|---|---|---|
| 0–2 | Read and interrogate the brief | A written list of every ambiguity, and the decision you are making about each. This list becomes a README section |
| 2–4 | Design doc v1 | Architecture, data model, the two hard parts, what is explicitly out of scope |
| 4–8 | Walking skeleton | End-to-end path working with the simplest possible everything. Committed and green |
| 8–28 | Implementation with tests as you go | Not tests at the end. Tests at the end is how you run out of time and ship untested code |
| 28–34 | Sleep. Non-negotiable | — |
| 34–40 | The hard part | Whatever you deferred: the failure handling, the concurrency, the benchmark |
| 40–44 | One thoughtful benchmark | A measured number with the methodology written down |
| 44–47 | README, design doc v2, commit history cleanup | — |
| 47–48 | Buffer | Something will be broken. It always is |
Never missing, regardless of what you cut:
- Tests that actually run, with a one-line command to run them
- A README with run instructions that work on a clean machine
- A design doc with a tradeoffs section
- Clean commit history that tells the story of the build
- Error handling on every external boundary
- One benchmark with a number and a stated methodology
- An explicit "what I would do with two more days" section
"Beyond the ask" means — and this is a narrow definition, deliberately: not more features. It means one of (a) a measured benchmark with an honest methodology, (b) a failure-injection test that proves a recovery path actually works, (c) an operational concern nobody asked for but every reviewer notices — structured logs, a health endpoint, a runbook for the DLQ. Anything else is scope creep and it reads as poor judgement.
The Decision Log
Start it at hour zero. Append as you go. It is the single highest-leverage artifact in the whole track, and it costs about ninety seconds per entry.
## D-007 — Retry backoff: full jitter
- **Decision:** exponential backoff with full jitter, base 200ms, cap 30s, 6 attempts
- **Alternatives:** no jitter (rejected: synchronized retry storms after a
downstream recovery — this is the actual failure mode AWS documented);
equal jitter (rejected: marginal benefit over full at our concurrency);
decorrelated (rejected: harder to reason about a worst-case bound)
- **Assumes:** downstream recovery is correlated across our consumers
- **Would revisit if:** we ever have a single-tenant destination where
ordering matters more than throughput
- **Not tested:** behavior when the clock jumps backwards
At the deep dive you will be asked "why 200ms?" and "why six attempts?" Ninety seconds at hour 12 buys you a complete answer at week 3. Without the log, you will reconstruct a rationalization, and the interviewer will hear it as one.
The Deep-Dive Interrogation Harness
After each project ships, I read your actual diff and generate the question list an interviewer would write. Project-specific, not generic — that is the whole point of row 15.
Question classes, all of which will be asked:
| Class | Examples |
|---|---|
| Choice | Why this data structure? Why this library and not the stdlib? Why this concurrency model? |
| Magic numbers | Why 30 seconds? Why 6 retries? Why a batch of 100? Where did that come from? |
| Scale | What happens at 100x? Which component fails first? What is the first thing that pages? |
| Data loss | Where can this lose a message? Which crash points are unsafe? What is your durability boundary? |
| Omission | What did you not test? What is the least-tested path? What is the riskiest line in the diff? |
| Regret | What would you do with two more days? What would you rip out? |
| Hostile | This function does four things. Why? · This test asserts nothing meaningful. · You catch a bare Exception here. · This is O(n²) and you know it |
Then it runs as a live drill: 45 minutes, no notes, recorded, scored on the same hire-bar scale as everything else.
Run it twice, on two different projects. Row 15 is about generalization: if you only ever defend the webhook system, you have memorized answers rather than built the skill.
Track E Rubric
| Level | Standard |
|---|---|
| L0 | Ships something working; no design doc; tests written at the end or not at all |
| L1 | Ships with tests and a README; cannot defend specific constants under questioning |
| L2 | Ships with tests, design doc, decision log; defends most choices; some "I'd have to look" |
| L3 | Defends every line including omissions; names the alternatives rejected and what would flip each; volunteers the weakest part of the design before being asked |
L3's tell: volunteering your own design's weakest point before the interviewer finds it. It is the single most credibility-generating move available in this round, and almost nobody does it, because it feels like arguing against yourself. It is the opposite — it demonstrates you have a model of your own system's risk, which is exactly what they are testing.
Completion Rules
These apply to every track, without exception:
- Reading something never completes anything. Completion requires a passed drill, a working artifact, or a scored mock.
- Anything you got wrong enters
../review/at the 1-day interval and resurfaces at 1, 3, 7, and 21 days. - Every performance claim in these notes has a script that demonstrates it. If you find one that does not, it is a bug.
- Every week ends with a scored mock and a
../STATE.mdupdate.
References
../research/source-report.md— which rows each track covers../diagnostics/RUBRIC.md— level bands and hour allocation../mocks/README.md— the weekly scored mock protocol../projects/README.md— Track E's build artifacts- Brooker, M. Exponential Backoff and Jitter. AWS Architecture Blog. https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/
- Kleppmann, M. Designing Data-Intensive Applications, 2nd ed.