We've applied a PPP discount of 0% off. Use code CODE at checkout.

Build backend judgment fewer engineers have, more companies need.

Follow clear reading guides on the canonical books. Design systems, review code, refactor legacy and get instant feedback against a senior-engineer rubric.

WHAT YOU'LL WORK THROUGH
transaction isolation consistent hashing eventual consistency consensus (Raft) two-phase commit SAGAs idempotency keys exactly-once delivery backpressure error as values replication lag bounded contexts dependency injection CDC & outbox pattern + 40 more

Join members from companies like

Google MongoDB Revolut EPAM

Sound familiar?

  • You've started Designing Data-Intensive Applications twice. You're not sure you'd remember chapter 3 if asked.
  • You read technical books passively because you have no way to test whether you actually understood them.
  • You make architectural decisions by pattern-matching what you've seen at work, not by reasoning from principles you've internalized.
  • You've never had your code review skills, design instincts, or refactor judgment evaluated against a senior-engineer rubric.
  • You learn what your current job exposes you to, which is a narrow slice of what senior engineers actually need to know.
Vlad
Software Engineer at Google
"This course was exactly what I needed. It helped me stop giving up on hard technical books and finally finish them. The quizzes are excellent for checking my understanding and making sure I can actually use the theory in real tasks."
Posted in our community Discord

How the Lab works

01
Diagnose
02
Read
03
Practice
04
Discuss
STEP 01

Diagnose your gaps

Before you read a word, a diagnostic surfaces what you actually understand versus what you only think you do. The result shapes your reading map for the book.

Starting assessment — DDIA
STEP 02

Read the book with a reading map shaped around your gaps

The Lab's current book is Designing Data-Intensive Applications, which takes about three months at a sustainable weekly pace. The reading map tells you which chapters to read deeply, which to skim for context, and which to skip entirely. Each book in the curriculum runs at a similar cadence.

Reading map — DDIA Ch 7 Sharding
STEP 03

Practice what you read

Each week, you complete a handcrafted assessment built for the chapters you just finished: a code review, an HLD, a refactor, or a trade-off scenario. Within seconds, you get feedback against a senior-engineer rubric, and when the topic is dense enough that text alone won't cut it, there's a video explanation waiting.

THE ASSESSMENT
HLD question — wallet ledger
THE FEEDBACK
AI feedback against senior rubric
THE VIDEO, WHEN NEEDED
Video explanation: pick the isolation level
STEP 04

Discuss with peers working through the same book

Members share what they're noticing in the chapters, including the parts the book got wrong. Weekly threads tied to the chapters you're on, denser with each cohort.

Discord thread — DDIA Ch 2

After your first book

Four capabilities that quietly mark the difference between mid-level and senior.

You design systems end to end

You can take an ambiguous problem, choose a shape, name the tradeoffs, and produce a design doc a senior engineer engages with rather than rewrites.

You read code architecturally

Beyond style and bugs, you see the wrong abstraction, the implicit coupling, the consistency assumption that breaks at scale. Your reviews change PRs, not just polish them.

You see refactors that move the product forward

You can tell essential complexity from accidental, and you know when a rewrite earns its cost versus when it just rearranges code that already works.

You own technical decisions in front of other engineers

In design reviews, standups, and 1:1s, you make calls and defend them with reasoning grounded in principles, not pattern-matching.

Denis — Senior Backend Software Engineer
BUILT BY

Denis

Senior Backend Software Engineer

"This learning system got me to senior level at 22 y.o."
Membership
$49 $49 / month
40% off · regional pricing applied
  • Curated, sequenced book curriculum
  • Knowledge gap diagnostic before each book
  • Detailed reading maps: what to read deeply, skim, or skip
  • Handcrafted weekly assessments: code reviews, HLDs, refactoring challenges
  • Instant AI feedback on every submission, against senior-engineer rubrics
  • Video explanations on complex topics
  • Private community of serious backend engineers
Join now

Cancel anytime.

The honest answers

The Lab is built for working engineers. About 30 minutes of reading a day and one assessment a week. The cadence adapts to the book, not the other way around. Designing Data-Intensive Applications runs about three months at a sustainable pace, and if you fall behind a chapter, you pick up where you left off. This isn't a bootcamp.

Mid-level backend engineers with two to five years of experience who want to build the depth and judgment to reach senior and beyond. If you're past the basics but feel the path from where you are to senior is unstructured, this is for you.

No. The curriculum is language-agnostic and principle-driven. You'll work on code quality, architectural tradeoffs, data modeling, and engineering fundamentals that apply regardless of whether you write Go, Java, Python, or anything else.

You review real code for design flaws, write and critique high-level designs, make refactoring decisions with genuine tradeoffs, and defend your reasoning. The same kind of thinking senior and staff engineers do daily.

No. Each assessment has a handcrafted senior-engineer rubric: the correct answers, the canonical best approaches, and the trade-off frameworks for that specific scenario. The AI evaluates your submission against that rubric, in seconds. It's not generating opinions, it's applying a rubric a senior engineer wrote.

Each of those is good at something specific:

  • LeetCode is for passing interviews and grinding algorithmic problems
  • boot.dev is for learning a programming language from scratch
  • Technical books are for building deep theoretical understanding
  • CodeCrafters is for re-implementing systems to learn internals

The Lab is for the gap none of them fills: turning what you read into engineering judgment you can actually defend at work. Reading maps that cut filler, weekly assessments that require real reasoning, AI feedback against senior rubrics, peers working through the same material. The system between knowing things and using them.

Start your first book.

$49/mo. Cancel anytime.

Join now