HomeGroundworkSQL & Databases

0 of 25 chapters written · 3 levels planned

SQL & Databases

Schemas, queries, and scale

Not written yet

The relational model, indexes and query plans, transactions, and the scaling decisions behind a database that holds up. Beginner through advanced, laid out the same way as the rest of the shelf.

Browse written topics

The plan

chapters planned
25
levels
3
chapters written
0

The plan25 chapters

What is planned, level by level

Every stop below is an outline for now. Open one to see what it will cover.

Beginner

“I can query and shape real data.”

8 sections

  1. The relational model
    soon
  2. SELECT fundamentals
    soon
  3. Joins
    soon
  4. Aggregations
    soon
  5. Inserting, updating, deleting
    soon
  6. Data types & constraints
    soon
  7. Basic schema design
    soon
  8. Using a database client
    soon

Intermediate

“I can design and tune a real database.”

9 sections

  1. Normalization in depth
    soon
  2. Indexes
    soon
  3. Transactions
    soon
  4. Subqueries & CTEs
    soon
  5. Query performance
    soon
  6. NoSQL fundamentals
    soon
  7. ORMs
    soon
  8. Migrations
    soon
  9. Backups & replication basics
    soon

Advanced

“I can reason about the storage engine.”

8 sections

  1. Database internals
    soon
  2. Scaling reads
    soon
  3. Scaling writes
    soon
  4. Advanced transactions
    soon
  5. Caching layers in front of a database
    soon
  6. Database security in depth
    soon
  7. Time-series & analytical databases
    soon
  8. Designing a schema for a real system
    soon

Read this first

Meanwhile

Nothing here is written yet, but these are.

Straight talk

Three honest notes

  • 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.