There is no best database: only data models that fit or fight your access patterns. This course dissects each major species: how it lays bytes on disk, what queries it makes cheap, what it quietly makes impossible, and the moment in a real system where you'd reach for it. Every lesson lets you operate the machinery yourself.
Create an update anomaly with your own hands, then normalize it away. Run a join. Watch an index turn a million-row scan into 20 steps. Understand why ACID made SQL the default: and what it costs.
One operation: GET(key): made absurdly fast. Operate a hash-based store, build a cache with TTLs, then hit the wall: try to query by value and watch the model shrug.
Store a blog post with its comments as one JSON tree: one read, no joins. Then pay for it: duplicate an author's name into 200 documents and try to rename them. Embed vs reference is the whole game.
Cassandra-style: the primary key is the physical layout. Route queries by partition key and watch them fly: or omit it and get rejected. Then run the LSM write path: memtable, SSTables, compaction.
Ask "friends of friends of friends" in SQL and count the exploding join rows; ask a graph store and walk pointers. Traverse a live network, find paths, and learn where graphs beat everything: and where they don't.
Three engines built by deleting general-purpose features: compress a metrics stream 10×, query text through an inverted index instead of a scan, and find "similar" items by distance in embedding space.
Every species side by side: data model, query power, scaling shape, failure modes. Then a scenario gauntlet: eight real workloads, you pick the engine, the lesson argues back. Ends with polyglot persistence done sanely.
Scope note: this course is about data models and storage engines: the shape of the data and the physics of one node. How any of these databases replicate, shard, and survive failures is the subject of the Database Replication and Distributed Systems courses; the three together form the full picture.