- Claim
- DuckDB wins this workload: vectorized execution + columnar layout.
- Evidence
EXPLAIN ANALYZE· cold vs warm cache · IO profile — 12.4s → 0.8s- Counterexample
- On a single-row point lookup, Postgres' index scan wins by 40×.
- Decision
- Embed DuckDB for the analytics feature. Do not replace the primary OLTP store.
Founding Cohort · 8 weeks live · 15 seats
AI writes the SQL
You understand the system
The Founding Cohort of Data Systems Foundations. Eight weeks, live, with a small group. You measure real systems, you build their core mechanisms yourself, and it all ends on a single-machine system you've never seen before.
This isn't a tools course, and it isn't system-design interview prep. You experiment on DuckDB, Postgres and SQLite, build toy engines from scratch, and break them on purpose. That last part is where the trade-offs stop being theory. Then you dissect a real single-machine system: call what it does before you look, then go prove it.
What you get
One seat, and the whole single-machine core.
You're buying an early seat in the single-machine core of Data Systems Foundations: phases 0–5 and the single-machine capstone, taught live over eight weeks, and it stays yours after that.
Forever access to the single-machine core
Phases 0–5 plus the single-machine capstone autopsy. It's all written, the grading already runs, and it stays yours after the cohort ends.
Eight weeks, live
One session a week where we run the loop together, doing the experiments and builds live. Nobody is lecturing at you.
Your own private labs repo
Labs live in a Git repo. Open a PR and CI grades it against hidden tests. You get the score back, not the answers.
Playgrounds, toy builds, case studies
Every phase ships an interactive playground, a toy engine you build version by version, and a case study from a real production system.
Two rounds of human feedback
Direct feedback on your mechanism write-ups and your mini-autopsy. CI will tell you a test failed, but it won't tell you when your reasoning was sloppy.
A small group going through it with you
Fifteen people hitting the same wall in the same week. Post your numbers, find out whose don't match yours, ask when you're stuck. Whatever gets written down stays searchable in your course site afterwards.
Who it's for
Who it's for. And who it isn't.
Worth being blunt up front. We built this for people who ship code and want to understand the data systems underneath. If you're after interview flashcards or videos to sit through, you'll be happier somewhere else.
This is for you if…
- You ship production code, and you'd rather know what happens under a query than guess at it.
- You're comfortable in Python and can write a multi-table SQL JOIN, but you've never built a storage engine or read a query planner.
- AI writes your queries now, and you want to know when it's wrong, and why.
- You learn by doing. Reading about a B-tree never quite sticks until you've built one yourself.
Not for you if…
- You want system-design interview prep. These eight weeks build judgment, not a stack of answers to memorize.
- You want a tools course on one database's features. We teach the mechanisms that sit under every database.
- You're here to learn programming or SQL basics. We assume you have those already — the course is about what happens inside the database.
- You want to watch videos. This is hands-on in a Git repo, graded by CI.
- You need distributed systems today. This cohort is the single-machine core (phases 0–5); distributed comes later.
How it works
It's the same loop, every single phase.
There's nothing here to memorize. You run the same six-step loop every phase until you stop having to think about it.
- 1Predict
Commit a falsifiable prediction before you run: what happens, which option wins, and what would prove you wrong.
- 2Observe
Reproduce the behavior on real systems (DuckDB, Postgres, SQLite) with query plans and benchmark numbers.
- 3Isolate
Change one variable at a time. Move two and you're left with a result you can't explain.
- 4Build
A toy version in stages, one concept at a time. The trade-offs textbooks gloss over show up in your own code.
- 5Compare
Same category, side by side: B-tree vs LSM, row vs column, Postgres vs DuckDB. Then work out why they made different calls.
- 6Transfer
Point the same approach at a system that was never on the syllabus. Every phase ends with a mini-autopsy, a scaled-down version of the capstone.
Course outline
Nine phases. Two capstones.
The whole Data Systems Foundations track, split into two tiers. The Founding Cohort is the single-machine tier: phases 0–5 and the single-machine capstone, yours to keep. The distributed tier (phases 6–8 and the distributed capstone) launches later, and founding members get 30% off it. Every phase runs the same six-step loop, and each tier ends in a full system autopsy.
Founding Cohort · single-machine tier · coming soon
-
00
Phase 0 — Measurement & Workload
Measure before you optimize.
-
01
Phase 1 — SQL, Query Plans, Execution
How a query becomes work.
-
02
Phase 2 — Data Models & Query Languages
One domain as documents, graphs, and wide-column rows.
-
03
Phase 3 — Storage Engines & Indexes
B-trees, LSM-trees, and the cost of a lookup.
-
04
Phase 4 — Transactions, Concurrency, Recovery
Isolation levels and the anomalies they stop.
-
05
Phase 5 — OLAP, Columnar, Vectorized Execution
Why analytics engines store columns.
-
Capstone · System Autopsy — Single-Machine
Take apart a system you've never seen, on your own. See it up close →
Distributed tier · founding members save 30% later
-
06
Phase 6 — Distributed Data Systems Soon
Replication, partitioning, and consensus.
-
07
Phase 7 — Streaming & Event Processing Soon
Logs, windows, and exactly-once.
-
08
Phase 8 — Lakehouse & Cloud Data Architecture Soon
Table formats over object storage.
-
Capstone · System Autopsy — Distributed Soon
Take a distributed system apart, on your own.
The capstone
It all builds to a system autopsy.
Every phase ends with autopsy questions about a real system. The capstone is the full version. You write a report: a claim up front, the experiments that back it, a counterexample you went looking for yourself, and a decision at the end you can actually defend. Here's roughly what one looks like.
Your capstone is a full autopsy of a single-machine data system you don't already know. One command boots the real engine on your machine, and five investigation modules walk you through its query layer, storage engine, concurrency model, and crash-recovery path. Every claim you make has to cite an experiment you ran.
Enroll
Founding Cohort — help us launch.
One tier, one price. This is the beta run, priced for the people willing to go first with us. You get the whole single-machine core, and your founding price never goes up.
Founding Cohort
Eight-week live cohort · forever access to the single-machine core.
- Forever access to phases 0–5 + the single-machine capstone autopsy
- 30% off the distributed cohort (phases 6–8 + distributed capstone) when it launches
- Eight weeks live, one session a week running the loop together
- Your own private labs repo with hidden-test CI grading
- Playgrounds, toy builds, and production case studies
- Two rounds of human feedback on your write-ups and mini-autopsy
- A small cohort to compare notes with, plus a private course site
- Your founding price is locked for life. Later cohorts pay more
You're not paying anything today. Get your name on the waitlist and we'll email you as soon as founding seats open.
FAQ
Straight answers, before you spend anything.
We're early. Here's what's settled and what's still moving.
Can I enroll right now?
Not yet. Enrollment isn't open, and the site isn't taking payment. Join the waitlist (your email plus two quick questions) and we'll email you the moment founding seats open, with the checkout link and how to get started. There are 15 seats, and the waitlist gets first access. Full refund any time before Phase 1, no questions asked.
What background do I need?
You write code that goes to production. The toy builds and lab tooling are in Python, so you should be comfortable reading and writing it. You know enough SQL to write a multi-table JOIN. Programming and SQL basics aren't part of the course — we assume you have them, and go straight into database internals.
How much of this exists today?
The single-machine core is done and running: phases 0–5 plus the single-machine capstone are written, graded, and in use today. That's exactly what the Founding Cohort covers, and it's yours forever. Phases 6–8, the distributed tier, aren't finished. They ship later as a separate cohort, and founding members get 30% off it.
Do I get phases 6–8, the distributed tier?
Not with the Founding Cohort. That's the single-machine tier: phases 0–5 plus the single-machine capstone, yours forever. The distributed tier (phases 6–8 plus the distributed capstone) launches later as its own cohort, and as a founding member you get 30% off it when it opens.
What do I need to run the labs?
An account on our course's GitLab (we email your invite), Docker, and an editor that speaks Dev Containers (VS Code is the smoothest path). You get your own private labs repo; open it in the preconfigured dev container and the whole toolchain is already installed, with playground ports forwarded to your browser automatically. Windows, macOS, and Linux all work, as long as you can run Docker Desktop (Windows/macOS) or Docker Engine (Linux). No GPU, no cloud account, no extra bill.
Is this videos, or hands-on?
Hands-on, in a Git repo. Each phase is written notes plus an interactive playground, experiments on real systems, a toy build that grows version by version, and a case study from production. Your work is graded by CI, with a scorecard posted on your PR. All of it is readable and searchable as a private course site too. It's not YouTube with quizzes attached.
What language is the course taught in?
The course material (written notes, labs, case studies, and the course site) is in English. The live sessions are taught in Mandarin (中文). We may run an English-taught cohort later. If you'd want one, join the waitlist and say so; that's how we'll know there's demand.
How is the course paced?
Live sessions run weekly, at a fixed time, and we really do want you at every one of them. Working through the material together, live, is most of the point. If you genuinely can't make one, every session is recorded, so you can catch up on your own schedule.
What's the refund policy?
A full refund any time before Phase 1, no questions asked. Just email support@datasystem.school and we'll take care of it.
Who can see my work and my grades?
You and the instructors, nobody else. Each student gets their own private GitLab repo; submissions are merge requests inside it, and scorecards are posted there. Course updates land on main, so git pull keeps your copy current without touching your work.
I'm not ready to enroll yet.
We'll email you when the next founding seats open. Join the waitlist →
Understand data systems from the inside out.
The Founding Cohort: 15 seats, $399 USD, full refund before Phase 1. Eight weeks live, and the single-machine core stays yours. Measure it, build it, break it, then defend what you found.
Join the waitlist