The Curriculum Map

The learning ladder

The whole curriculum is built on one idea: foundations before craft, craft before tooling, tooling before building. You can't model data well until you understand how a database stores and reads it. You can't use dbt sensibly until you understand the ELT pattern it automates. You can't operate a platform until you've built one. So the courses are not a menu — they're a staircase, and each step is cut to land on the one below it.

Here is the path. Courses 1 through 7 run in sequence; Course 8 (the glossary) sits alongside the whole journey as a reference you keep open the entire time.

The eight courses

Here's the whole curriculum in one table — what each course teaches, why it's placed where it is, and the concrete capability you walk away with. The detailed breakdown of Courses 2–8 follows below.

Course 2 — Orientation & Setup

The bridge from "I read about it" to "I ran it." This course gives you the mental model of a data platform — sources, ingestion, storage, transformation, serving — and then builds the environment you'll use for everything after: the command line, git, Docker, a modern Python toolchain (Python 3.12 + uv), and a local Postgres and DuckDB. You finish by writing your first pipeline: pull data from a source, land it, transform it, query the result. It's placed second because every later course assumes a working machine and a basic feel for moving data; getting that solid now removes a whole class of "why won't it run" pain later. After it: you can set up a project, version it in git, run services in Docker, and move data from A to B on your own laptop.

Course 3 — Foundations

The degree core, taught for this job and nothing extra. This is the longest, densest course, and the one that makes everything after it click. It covers: serialization & data representation (how data becomes bytes — CSV, JSON, Parquet, encoding); inside a database (storage layout, B-tree indexes, how a query actually executes, ACID, isolation levels); SQL in depth (window functions, query plans, why a query is slow); Python for DE (testing, packaging, the patterns real pipelines use); algorithms & complexity for data (Big-O where it bites — joins, sorts, hashing); distributed systems (partitioning, replication, CAP, consistency models, a feel for consensus, delivery semantics, idempotency); and the OS layer (memory, disk, networking — why things are fast or slow). It's placed third because it's the bedrock: skip it and Course 4 becomes rote. After it: you can explain why a system behaves the way it does and predict how it'll behave under load.

Course 4 — The DE Craft

The heart of the job. With foundations under you, this course teaches the actual practice of building data systems: data modeling (entity-relationship → normalization → dimensional models → slowly-changing dimensions → the medallion architecture); ingestion & CDC (getting data in, including change data capture); ELT/ETL patterns; dbt for transformation-as-code; the lakehouse (Parquet, DuckDB, Apache Iceberg); streaming (Redpanda/Kafka, event-time vs processing-time, windows); orchestration (Dagster — scheduling and dependencies between jobs); and data quality & testing. It's placed fourth because each topic here is a concrete application of a Course 3 concept. After it: you can design a schema, build batch and streaming pipelines, transform with dbt, and test what you ship.

Course 5 — Tooling & the Modern Stack

The professional toolbox, taught as the glue between the pieces you can now build. It covers the git/GitHub workflow (branches, PRs, review), Docker & Compose in depth, wiring the local mini-platform together, cloud fundamentals (object storage, warehouses, IAM/permissions), CI/CD for data (automated tests and deploys), infrastructure-as-code basics, and observability tooling (knowing your platform is healthy). It's placed fifth because tooling is most useful once you know what it's tooling for — a CI pipeline is meaningless until you have tests to run in it. After it: you can connect tools into one automated system and reason about its cloud equivalents.

Course 6 — Capstone Labs

Where it all becomes one thing you can point to. Lab by lab, you build mini-GridDP: a small but complete, runnable local data platform. Each lab maps to a chapter of the senior Data Platform Systems Design guide, so you're building a miniature of the real thing. It's placed sixth because a capstone is, by definition, the integration of everything — you can only build the whole once you have all the parts. After it: you have a working platform you built and operated yourself, and the deep understanding that only comes from building.

Course 7 — Career & Getting the Job

Turning the build into a job. This course takes the capstone and makes it a portfolio; builds your resume around it; drills interview prep across the four things data interviews test (SQL, coding, system design, behavioral); and prepares you for the first 90 days in the role. It's placed seventh because you can't credibly present work you haven't done — the portfolio is the capstone. After it: you can apply, interview, and start with confidence.

Course 8 — Glossary & Cheat Sheets

Not a course you "finish" — a reference you keep open from day one. Definitions for every term, plus quick-reference cheat sheets for SQL, git, Docker, dbt, and the rest. It sits alongside the ladder rather than on it: whenever a word in any course is fuzzy, this is where you look it up. Use it: the entire way through.

Why the order matters

It's tempting to treat eight courses as eight independent things you could shuffle. They're not. Each one unlocks the next by giving you a concept the next course assumes you already have. Here's the dependency logic as a graph — read an arrow as "you need the left before the right will make sense."

This table makes the "unlocks" explicit — what each course hands the next.

The teaching stack

You'll learn on one free, local stack — every tool runs on a normal laptop via Docker Compose, no cloud bill, no sign-ups. We made that choice deliberately. The goal is not to make you an expert in any single product; it's to teach you the concepts each product represents so deeply that you can pick up the cloud equivalent in a week. A warehouse is a warehouse whether it's DuckDB on your laptop or Snowflake in the cloud; the concepts — columnar storage, query planning, partition pruning — transfer completely. Learning on one coherent free stack means you spend your energy on ideas, not on juggling accounts and credits.

The companion repo

From Course 2 onward, you build one git repository — call it mini-griddp — and you grow it across the entire curriculum. It is not throwaway practice; it's a real artifact. Course 2 initializes it. Course 3's exercises live in it. Course 4 fills it with models and pipelines. Course 5 adds Docker Compose, CI, and infrastructure config. Course 6's capstone labs assemble it into a running platform. By the time you reach Course 7, that single repo — with its commit history showing months of steady work — is your portfolio.

mini-griddp/
├── README.md            # grows into your portfolio front page (C2→C7)
├── docker-compose.yml   # the local platform: Postgres, DuckDB, MinIO… (C5)
├── ingest/              # ingestion & CDC pipelines              (C4)
├── dbt/                 # models, tests, lineage                 (C4)
├── orchestration/       # Dagster assets & schedules            (C4→C6)
├── streaming/           # Redpanda producers/consumers          (C4)
├── .github/workflows/   # CI/CD                                  (C5)
└── infra/               # IaC basics                             (C5)

This is why the learning contract (Course 1, ch. 00) insists on keeping one repo: a clean, well-committed mini-griddp at the end is worth more in a job search than any certificate. Hiring managers can see it run.

How this ladders into the senior guide

This curriculum has a destination beyond itself: the senior-level Data Platform Systems Design guide. That guide is written for working engineers designing a real platform — it assumes the vocabulary and the systems intuition this curriculum builds. It's the "senior reading" you graduate into after Courses 6 and 7.

The connection is concrete, not vague: each lab in Course 6's capstone is mapped to a chapter of that guide. As you build mini-GridDP, you're constructing a miniature of the system the senior guide designs at full scale. So when you finish and open that guide, you don't read it as a stranger — you read it as someone who built a small version of exactly what it describes. The jargon that bounced off you on day one (CDC, idempotency, lakehouse, consistency models) now names things you've actually wired up with your own hands.

✓ Check yourself

Before moving on, make sure you can answer "yes" to these:

• Can you name all eight courses and say in one sentence what each teaches?
• Can you explain why Course 3 (Foundations) comes before Course 4 (the Craft)?
• Do you understand why we use one free local stack instead of cloud products?
• Do you know what mini-griddp is and why you keep one repo the whole way?
• Can you say how this curriculum connects to the senior systems-design guide?

Next

You have the map; now let's put it on a calendar — a realistic, paced plan to climb all eight courses. → The Six-Month Schedule