From your first SELECT to a defensible data platform
A 23-module course that takes you from the fundamentals of SQL to production-grade data platforms. Lessons are 15 minutes each, marked per role (BA, BI, DA, AE, DE, DBA, BE, MLE, PE) so the same course adapts whether you are a Business Analyst learning SQL for the first time or a Data Engineer preparing for a senior interview.
SQL is not just a query language — it is the interface to systems that store, process and deliver data. This module sets up the mental model you'll need for the rest of the course and gets your local stack running.
The fundamentals every role needs: tables and keys, NULL semantics, the SELECT pipeline, and how the same logical query can run in many physical ways. By the end of this module you can read and write the SQL that 80% of analytics work consists of, and you understand why it sometimes runs slowly.
Joining tables is where most production SQL bugs live. This module makes the cardinality of every join explicit, names the physical algorithms an optimizer picks between, and rehearses the mistakes that turn '12 rows' into '12 million rows'. Set operations (UNION/INTERSECT/EXCEPT) get their own treatment in a later module.
Most analytical work is one of: GROUP BY, a window function, or a clever combination. By the end of this module you can write retention cohorts, running totals, ranking, and the gap-and-island patterns that appear in every job interview without leaving SQL.
A table is a contract with everyone who reads it. This module is about choosing types, keys and constraints that survive the next ten migrations — plus the playbook for adding a NOT NULL column to a 200M-row table without taking the site down.
Pick indexes for real query patterns instead of indexing every column you can think of. Every index makes reads faster and writes slower; the trick is knowing which trade you're making.
Diagnose performance problems with EXPLAIN ANALYZE instead of guessing. Learn the three most useful flags, the four nodes that explain 80% of slow queries, and the rule that makes optimizations actually stick.
Why correct SQL can break under concurrent load, and how isolation levels save (or trap) you. The lesson where SELECT statements suddenly need to know about other transactions.
Build a star schema and an SCD2 dimension that survive a year of dashboards. The lesson where 'why is this dashboard slow?' becomes a modeling question, not an indexing one.
Move from ad-hoc queries in a notebook to a tested, version-controlled, code-reviewed pipeline. dbt is the framework that turned analytics from craft to engineering — this module is the practical pivot of the course.
Define what 'good data' means before someone asks why the dashboard is wrong. The six dimensions, the contract pattern that catches schema drift in CI, and the quarantine table that saves your pipeline from a single bad row.
Schedule, retry and backfill data jobs with predictable behavior. Airflow is the framework most analytics teams converge on; this module is the smallest set of patterns that make it not bite you.
Same dataset, three engines. See storage layout, latency and use-case fit side by side — and learn the question to ask before picking one for production.
Managed warehouses still need engineering — partitioning, clustering and cost control. The difference between a $300/month bill and a $30,000/month bill is usually one missing partition filter.
Distributed SQL: when one node is not enough, and how the lakehouse stays consistent. Plus the three reasons a Spark job is slow and how to read the UI to know which one bit you.
Open table formats and federated SQL across many sources. Iceberg gives you ACID, schema evolution and time travel on Parquet files; Trino lets you JOIN Postgres to S3 to BigQuery in one query.
How to ingest semi-structured and search-oriented data into a relational world without losing your sanity. The lesson where JSON drift becomes a tracked event, not a 3 AM page.
How to keep your warehouse in sync without reloading the world every night. The watermark + overlap pattern, the SCD2-from-CDC stream, and the reconciliation that catches what watermarks miss.
Know what is happening to your data in production before someone in Slack tells you. The three alert classes, the ownership rule that ends 'who's on call', and column-level lineage as impact-analysis-as-code.
Make 'least privilege' the default, not an afterthought. The masked-view pattern, the row-level security trick, and the rule that keeps PII out of accidental places.
Code that survives years instead of weeks. The smells, the conventions, and the checklist that catches the bugs your tests don't.
Connect the developer's choices to CPU, memory, IO, network and cost. The ranked list of where speed actually comes from — and the discipline that turns guesses into measurements.
Bring everything together into one project you can defend in an interview. The 14 questions you must answer in the final review — and the rule that makes the project actually represent your skill.