How much SQL & Databases do you already have?
Be honest — nobody is watching. This only decides which chapters come first; every chapter stays open to you either way.
“I can query and shape real data.”
Start with tables, rows and keys, then SELECT, JOIN and the basic shape of a schema.
- You've copied SQL queries before without fully trusting them
- You haven't designed a schema from scratch
- You want SELECT, JOIN and basic schema design once, in order
“I can design and tune a real database.”
You can query. Now learn what makes it fast and safe: indexes, transactions, query plans, and when to reach for an ORM or NoSQL instead.
- Comfortable with SELECT/JOIN/GROUP BY and basic schema design
- You've had a query go from instant to slow as data grew, and guessed why
- You want to design a schema and read a query plan with confidence
“I can reason about the storage engine.”
MVCC, sharding, the CAP theorem, and the case-study thinking behind designing a schema for a system that has to scale.
- You can already tune indexes and read a query plan
- You debug replication lag and lock contention, not just slow queries
- You want the why under MVCC, sharding and distributed transactions
Not sure? Start at Beginner — every path opens at the section people usually skip.
Full syllabus
Everything each level eventually covers — ticked sections are written, the rest are still on the desk.
Beginner0 / 8 sections written
- The relational modelcoming soon
Tables, rows, columns, keys
- SELECT fundamentalscoming soon
Filtering, sorting, limiting
- Joinscoming soon
Inner/left/right/full, when to use each
- Aggregationscoming soon
GROUP BY, HAVING, common aggregate functions
- Inserting, updating, deletingcoming soon
Writing data safely
- Data types & constraintscoming soon
NOT NULL, UNIQUE, CHECK, defaults
- Basic schema designcoming soon
Primary/foreign keys, normalization (intro)
- Using a database clientcoming soon
psql/mysql CLI or a GUI client, the basics
✅ Checkpoint: you can design a small normalized schema and write the SELECT/JOIN/aggregate queries to answer real questions against it.
Intermediate0 / 9 sections written
- Normalization in depthcoming soon
1NF/2NF/3NF, when to denormalize on purpose
- Indexescoming soon
How they work (B-trees), when they help or hurt
- Transactionscoming soon
ACID, isolation levels, locking
- Subqueries & CTEscoming soon
Recursive CTEs, window functions
- Query performancecoming soon
EXPLAIN/EXPLAIN ANALYZE, reading a query plan
- NoSQL fundamentalscoming soon
Document/key-value/column stores, when to choose NoSQL
- ORMscoming soon
Prisma/TypeORM/Mongoose mental models, the N+1 problem
- Migrationscoming soon
Schema versioning, safe migrations on live data
- Backups & replication basicscoming soon
Backup strategy, basic replication concepts
✅ Checkpoint: you can add the right index to fix a slow query, explain a transaction's isolation level, and choose SQL vs NoSQL for a given problem with reasons.
Advanced0 / 8 sections written
- Database internalscoming soon
Storage engines, MVCC, how a B-tree index actually works
- Scaling readscoming soon
Replication, read replicas, connection pooling at scale
- Scaling writescoming soon
Sharding strategies, partitioning
- Advanced transactionscoming soon
Distributed transactions, the CAP theorem
- Caching layers in front of a databasecoming soon
Redis, materialized views
- Database security in depthcoming soon
Least privilege, SQL injection prevention in depth
- Time-series & analytical databasescoming soon
Surface level — when OLTP isn't the right tool
- Designing a schema for a real systemcoming soon
Case-study thinking, end to end
✅ Checkpoint: you can design a sharding strategy for a growing table, explain MVCC's role in your database's isolation guarantees, and defend a schema for a real case study.
- Indexes and EXPLAIN plans sit in intermediate, not advanced — reading a query plan is an everyday skill, not a rare one, for anyone shipping real queries.
- NoSQL gets one honest intermediate chapter on when to choose it, not a whole separate track — the goal is a working mental model, not a second curriculum.
- Sharding, consensus and distributed transactions are the deepest, rarest layer — most working backend engineers never operate at that scale, but the advanced tier doesn't skip it.