Rebuilding Apprenticeship

For students, graduates and engineers in their first two years

The work that turned juniors into seniors is disappearing. Learn what it taught, on purpose.

Employers still can't find people who can say exactly what to build, prove it's right and keep it running in production. That judgement used to take years on the job. In 24 weeks you build real systems by hand, find what's wrong in code you didn't write and run a service of your own, with a senior engineer reviewing every submission.

  • Full refund within 2 weeks
  • Python or TypeScript
  • ~12–15 hours a week
  • Runs on your laptop
client/retry.pytests pass · ready to merge?
14 def fetch_with_retry(call, attempts=3, backoff=0.2):
15 """Call `call`, retrying on timeout."""
16+ for attempt in range(attempts):
17+ try:
18+ return call()
19+ except TimeoutError:
20+ time.sleep(backoff * 2 ** attempt)
21+ return None
Senior reviewer · line 21“Every attempt times out. What does the caller get back, and how would anyone find out from the logs?”

You've been told to learn another framework. It won't get you there.

The first rung is disappearing

Companies are hiring fewer juniors, and the routine work that used to turn juniors into seniors is drying up with them. The roles that remain go to people who can be trusted with a system, not just a ticket.

Another framework won't set you apart

Frameworks change every year, and anyone can add one to a CV after a weekend course. Framework familiarity is now the cheapest skill in the market. It's what everyone applying alongside you already has.

Nobody trains judgement on the job anymore

Teams are smaller and more senior. The years of corrected work that used to teach juniors what good looks like are gone, and no course replaces a senior asking you the right question.

“Tell me about a system that went wrong in production, and what you did about it.”

That's the kind of question that separates candidates now, and no certificate answers it. You need to have built something real, broken it, found out why and fixed it, with someone experienced asking the hard questions along the way. That's what this programme is.

What you'll be able to do

Five skills, in the order they build on each other.

01

Fundamentals, by hand

AI OFF

Build a key-value store, a crash-safe write-ahead log, a worker pool, an HTTP server from raw sockets, and a Postgres-backed ledger. You'll know what generated code is supposed to do because you've done it yourself.

02

Reading

AI OFF

Explain unfamiliar code, trace a request through a codebase you've never seen, and find the bugs in agent-written code that looks right and passes its tests.

03

Verification

AI OFF → ON

Hunt planted defects of increasing subtlety. Write the test that breaks a change. Learn when a passing test is lying to you.

04

Specification

AI ON

Direct coding agents by stating what's wanted, the constraints and how success is checked. Then find out from the result what you left unsaid.

05

Ownership and incidents

AI ON

Deploy a small service, run it with dashboards and alerts, get paged, handle game-day incidents and write the postmortem.

Week
15913172124
  1. FND
  2. RDG
  3. VER
  4. SPC
  5. OWN
  6. INC
AI off: build the reference model AI on: direct and own Game days, fortnightly

Real exercises, not toy problems

Every exercise runs on your machine and checks itself.

FND-01

A key-value server with a protocol you design

50 clients at once, malformed input, clients that hang up mid-command.

FND-03

Make it durable

Your server gets killed mid-write, hundreds of times. No acknowledged write may be lost.

FND-06

Races by hand

Write four concurrency bugs on purpose, make them fail reliably, draw the interleaving, fix them.

RDG-03

An incident in 3 MB of logs

Real stack traces, clock skew between hosts, red herrings. Find what actually happened.

RDG-06

Plausible but wrong

Agent-written code with confident comments and a passing test suite. Find what's broken.

VER-03

Defect hunt

Planted bugs in a real wallet service. Prove each one with a test that fails.

How a week works

  1. Clone and build. Each track is a Git repository. The brief, the starter files and the automated checks are in it.
  2. Check yourself. The checks start your program and attack it from outside: concurrency, crashes, malformed input. Any language that can run on your laptop works.
  3. Submit a pull request. A senior engineer reviews it, with questions rather than corrections.
  4. Explain it back. A short call where you walk through your work. That conversation is where most of the learning happens.
$ make start EX=FND-03
On branch fnd-03. Brief: briefs/FND-03.md

$ make check EX=FND-03
FAILED test_crashbox_kill_loses_no_acknowledged_write
  After a SIGKILL and restart, 3 acknowledged
  keys came back missing or wrong.
  Where to look: is the write fsynced before
  you reply OK?

$ make submit EX=FND-03
Submitted FND-03 as fnd-03-submitted-1.
Open the review pull request: github.com/…

The part tutorials can't give you

A senior engineer who asks the right question.

Every submission is reviewed by a senior engineer. They won't rewrite your code. They'll ask the question that makes you find the problem yourself, because that's the habit that makes you good. At each milestone you walk them through your work on a call.

“A value contains a newline. Walk me through what your server does, byte by byte.”
“Point to the exact line after which an acknowledged write is safe from a power cut.”
“Your test passed. How confident are you that it would fail if there were a race?”

What you leave with

A portfolio of real systems

A storage engine, an HTTP server, a ledger, a deployed service, all built and tested by you.

Reviewed pull requests

Every exercise reviewed by a senior engineer, with the discussion attached.

Evidence of judgement

Ratings on six competencies, each with written evidence of what you did.

Operational experience

Dashboards, alerts, incidents, postmortems: things most juniors meet only on the job.

Founding cohort

Small, closely reviewed, and shaped by the people in it.

The first cohort is small so that every submission gets a careful review. Founding members also shape the programme: when you find a gap in an exercise, it gets fixed. If it isn't for you, ask for a full refund within the first two weeks, no questions asked.

  • →24 weeks, about 12–15 hours a week
  • →Python or TypeScript
  • →Senior review on every exercise
  • →Runs on your own laptop
  • ₹34,999 + 18% GST

    One payment for all 24 weeks; the final price including GST is shown at checkout. Full refund within two weeks, no questions asked.

  • Join the founding cohort

Questions

Who is this for?+

Final-year students, recent graduates, and developers in their first two years, including career changers. You should be comfortable writing small programs in Python or TypeScript. You don't need to know systems programming yet: that's what the first eight weeks are for.

Why are AI tools off for the first weeks?+

For the same reason you learn arithmetic before you use a calculator. You need your own model of how storage, concurrency and networks behave before you can judge what an agent gives you. From week 9, agents are your main tool. Nobody polices this: if you skip the hard part, you're only cheating yourself.

How much time does it take?+

About 12–15 hours a week for 24 weeks, plus a short call with your reviewer most weeks. It's designed to fit around college or a job.

What do I need?+

A laptop, Git, a GitHub account, and Python 3.12+ or Node 22+. Later tracks use Docker to run databases and your deployed service. Everything runs on your own machine.

How much does it cost?+

₹34,999 + 18% GST for the founding cohort, paid once for all 24 weeks. The final price including GST is shown at checkout. If it isn't for you, ask for a full refund within the first two weeks, no questions asked.

Who reviews my work?+

A senior engineer reviews every submission against the exercise's rubric, and writes the review as questions that lead you to the problem rather than fixes. At each milestone you walk a senior through your work on a call. Only a senior decides whether you've passed.

Will this get me a job?+

We don't promise placements. You'll leave with a portfolio of systems you built, reviewed pull requests, a service you deployed and operated, and written feedback from senior engineers on six competencies. That's evidence of judgement, which is increasingly what hiring looks for.

Can my employer pay for this?+

Yes. Companies can run private cohorts for their juniors and interns, with their own seniors reviewing.

See the programme for companies →