Skip to content

Volume ITechnology

7.5.2 — Wide-Column, Graph, Time-Series, and Choosing ​

A fleet of 50,000 delivery vans each reports its position every ten seconds. That is 5,000 writes a second, all day, every day, and nobody ever updates a past position. A relational database can take it for a while. Then the table reaches billions of rows, the indexes stop fitting in memory, and the one machine holding it cannot write any faster.

Each family on this page exists because one workload like that hurts a relational database. Wide-column stores handle huge write volume spread over many machines. Graph databases handle questions about chains of relationships. Time-series databases handle streams of timestamped readings. The last sections give a procedure for choosing, so the choice comes from your access pattern rather than from the last conference talk.

1. Wide-column stores ​

Cassandra, ScyllaDB and HBase descend from Google's Bigtable paper. The name is a poor description — a better one is a distributed sorted map of maps.

partition key      →  clustering key(s)  →  columns
"sensor:9"            2026-08-02T10:00      { temp: 21.4, humidity: 55 }
"sensor:9"            2026-08-02T10:01      { temp: 21.5, humidity: 55 }
"sensor:9"            2026-08-02T10:02      { temp: 21.6, humidity: 54 }

The partition key decides which machine holds the data. Everything with the same partition key lives together on the same nodes. The clustering key decides the sort order within that partition. Rows in a partition are stored physically sorted, so a range query inside a partition is a sequential read.

The whole model follows from that. You query by partition key, optionally with a range on the clustering key, and that is the fast path. There are no joins. A WHERE on any other column needs an index.

For years the standard advice was to avoid Cassandra's secondary indexes and copy the data into a second table instead, because the old indexes were slow and fragile. Cassandra 5.0, released in 2024, added Storage-Attached Indexes (SAI), which are far better: they support ranges on numbers and dates, and they cost much less space. Two things have not changed. A query that names the partition key still goes to a few machines. A query that does not still has to ask every machine in the cluster, so it slows down as the cluster grows. So SAI is good for an extra filter inside a partition, or an occasional query, and the main questions should still be answered by the table's own keys.

Model the table from the query ​

In a relational database you design tables around the things: orders, customers, products. In Cassandra you design tables around the questions, and you write the same data into one table per question. That feels wasteful, and it is the intended trade: disk is cheap, and every question becomes one fast read.

Take a shop that needs two questions answered, millions of times a day:

  1. "Show this customer's orders, newest first."
  2. "Show all orders placed in a given hour", for the warehouse.
sql
CREATE TABLE orders_by_customer (
  customer_id text,
  placed_at   timestamp,
  order_id    text,
  total_minor int,
  PRIMARY KEY ((customer_id), placed_at, order_id)          -- (1)
) WITH CLUSTERING ORDER BY (placed_at DESC, order_id ASC);

CREATE TABLE orders_by_hour (
  hour        text,                                          -- e.g. '2026-08-02T14'
  placed_at   timestamp,
  order_id    text,
  customer_id text,
  PRIMARY KEY ((hour), placed_at, order_id)                 -- (2)
);

(1) All of one customer's orders live in one partition, sorted newest first, so question 1 is one read. order_id is added to the key so that two orders in the same millisecond do not overwrite each other. (2) The warehouse question gets its own table, partitioned by the hour. An hour bounds each partition's size. Partitioning by the day would put a whole day's orders, and all of today's writes, on one set of machines.

The application writes each new order to both tables. Cassandra can group the two writes in a logged batch, which guarantees that both eventually happen even if the coordinating machine fails partway through. It does not make them happen at the same instant.

sql
-- Cassandra Query Language: looks like SQL, is not SQL
CREATE TABLE readings (
  sensor_id text,
  ts        timestamp,
  temp      double,
  PRIMARY KEY ((sensor_id), ts)          -- (1)
) WITH CLUSTERING ORDER BY (ts DESC);    -- (2)

SELECT * FROM readings
WHERE sensor_id = 'sensor:9'             -- (3)
  AND ts > '2026-08-02T09:00';

(1) The double parentheses mark the partition key; ts is the clustering key. (2) Newest first on disk, so "the latest readings" is the front of the partition. (3) The partition key is mandatory. A query without it either fails or requires ALLOW FILTERING, which scans every node and is a production hazard rather than a feature.

What you get for that discipline:

Linear write scalability. Writes go to an LSM tree (Chapter 7.3.3) on whichever node owns the partition, with no coordination. Adding nodes adds throughput close to linearly, and Cassandra genuinely handles very large write volumes on commodity machines.

No single point of failure. Every node is equal, and there is no leader. Each piece of data is copied to several nodes, a number called the replication factor, usually 3. Reads and writes use tunable consistency: on each request you choose how many of those copies must answer before it counts as done.

The arithmetic is worth doing once. With a replication factor of 3:

LevelCopies that must answerSurvives
ONE12 nodes down
QUORUM2 (a majority of 3)1 node down
ALL3none down

If a write waited for 2 copies and a read asks 2 copies, at least one of the copies the read asks must be one the write reached, because 2 + 2 is more than 3. So QUORUM writes plus QUORUM reads always see the latest write. The general rule is: reads see the latest write whenever the copies written plus the copies read add up to more than the replication factor. ONE plus ONE makes 2, which is not more than 3, so a read can miss a write that only reached one copy. In a cluster spread over several data centres, LOCAL_QUORUM takes a majority inside the local data centre only, so a request does not wait for an ocean crossing. Chapter 10.5 develops this further.

Lightweight transactions cover the rare case that needs a strict check, such as "create this username only if nobody has it": INSERT ... IF NOT EXISTS. Cassandra runs a Paxos round between the replicas to agree, so it takes four round trips instead of one. Use it for the few writes that truly need it.

Multi-datacentre replication as a first-class feature rather than a bolt-on.

The failure modes are specific and worth knowing:

A hot partition is a hot machine. Partition by date and every write for today goes to one node. Partition keys must spread — often by bucketing, sensor:9:2026-08 rather than sensor:9, which also bounds partition size.

Unbounded partitions get slow. A partition holding years of data on one node eventually costs too much to read or repair. Bucket by time.

Tombstones accumulate. A delete does not remove data at once. It writes a marker called a tombstone (Chapter 7.3.3), which is removed only when compaction runs after a waiting period, 10 days by default (the table setting gc_grace_seconds). A query that scans a range full of tombstones must read every one of them to return nothing. A queue-like table in Cassandra — insert, read, delete — is the classic anti-pattern, because it produces exactly these tombstone-heavy range scans.

The waiting period exists for a reason, and it has a trap. A node that was down during a delete never saw the tombstone. If the tombstone is cleared before that node is brought back in sync, the node still has the old data, and the next sync copies it back to everyone. The deleted row comes back from the dead. So every node must be repaired, which means compared with its peers and brought in sync, more often than every 10 days.

Choose compaction for the workload. Compaction is the background merge of an LSM tree's files (Chapter 7.3.3). For time-series data that is written once and expires by age, the time-window strategy groups files by time, so a whole day's file can be dropped at once when it expires instead of being merged row by row.

Last-write-wins resolves conflicts by timestamp, which means a clock skew between nodes can silently discard the newer write. Chapter 10.3 covers why wall clocks are not a reliable ordering.

Use it when you have very high write volume, a known key-based access pattern, and a genuine need for multi-region availability. Do not use it as a general-purpose database, and be suspicious of any design where you cannot name the partition key of every query in advance.

2. Graph databases ​

Some questions are about relationships, and relational databases answer them by joining a table to itself repeatedly. "Who are my friends' friends who work at companies my company sells to" is four self-joins, and each one multiplies the intermediate result.

A graph database stores relationships as first-class objects. A node holds a pointer to its relationships, and a relationship holds pointers to both nodes. Traversing from one node to its neighbours is following pointers — the cost does not depend on how large the graph is. Neo4j calls this index-free adjacency, and it is the actual reason graph databases are fast at what they are fast at.

cypher
// Neo4j's Cypher: friends-of-friends who are not already friends
MATCH (me:Person {id: 42})-[:FRIEND]->(f)-[:FRIEND]->(fof)   // (1)
WHERE NOT (me)-[:FRIEND]->(fof) AND fof <> me                // (2)
RETURN fof.name, count(*) AS mutual                          // (3)
ORDER BY mutual DESC LIMIT 10;

(1) The arrow notation is the query. Read it as a path: me, to a friend, to their friend. (2) Exclude people I already know and myself. (3) Count how many paths reach each person — the number of mutual friends — and rank by it.

Here is the same question in SQL, run on PostgreSQL 18 with six people, where Ana is person 1:

sql
-- Friends of Ana's friends, who are not already Ana's friends, ranked by mutual friends
SELECT p.name, count(*) AS mutual
FROM friend f1                                   -- Ana -> friend
JOIN friend f2 ON f2.a = f1.b                    -- friend -> their friend
JOIN person p  ON p.id = f2.b
WHERE f1.a = 1
  AND f2.b <> 1
  AND NOT EXISTS (SELECT 1 FROM friend x WHERE x.a = 1 AND x.b = f2.b)
GROUP BY p.name ORDER BY mutual DESC, p.name;
 name | mutual
------+--------
 Dee  |      2
 Eli  |      1

Dee is reached two ways, through Ben and through Chen, so Dee has two mutual friends. It works, and it is fine at two hops. Each hop is one more self-join on the friend table.

Where the difference becomes decisive is depth, and paths of unknown length. "Everyone within three hops of Ana" needs a recursive query, which repeats a join until it runs out of new rows (Chapter 7.2.2):

sql
WITH RECURSIVE walk(id, depth, path) AS (
  SELECT 1, 0, ARRAY[1]                          -- start at Ana
  UNION ALL
  SELECT f.b, w.depth + 1, w.path || f.b         -- take one more step
  FROM walk w JOIN friend f ON f.a = w.id
  WHERE w.depth < 3 AND NOT f.b = ANY(w.path)    -- stop at 3; never revisit
)
SELECT p.name, min(depth) AS hops FROM walk JOIN person p USING (id)
WHERE id <> 1 GROUP BY p.name ORDER BY hops, p.name;
 name | hops
------+------
 Ben  |    1
 Chen |    1
 Dee  |    2
 Eli  |    2
 Fay  |    3

The path array exists only to stop the walk going round in circles, which friendship graphs are full of. The problem is growth. Each step joins every path found so far against the whole friend table. If people average 200 friends, three hops can mean 200 × 200 × 200 = 8 million paths to build and then throw away. A graph database follows stored pointers from each person instead, and it can stop at the first route it finds. So two hops: SQL is fine. Six hops, or "is there any route at all between these two accounts": a graph database is the right tool.

Real uses that justify one: fraud rings (accounts connected by shared devices, addresses or cards), recommendation by traversal, network and infrastructure dependency mapping, identity resolution, and knowledge graphs.

The honest limits. Graph databases are usually worse at bulk aggregation across all nodes, harder to shard (a graph does not partition cleanly — that is what makes it a graph), and represent an extra system to operate. If your deepest question is two hops, a relational schema with the right indexes is the better answer, and most systems that adopted a graph database did not need one.

PostgreSQL can do a lot of this, as the two queries above show. Standards are catching up too. SQL:2023 added SQL/PGQ, a way to write graph patterns like Cypher's arrows inside an ordinary SQL query, and Oracle already ships it. PostgreSQL does not have it yet as of version 18. In April 2024 ISO published GQL, the first standard query language for graph databases, based largely on Cypher. Reach for a dedicated graph database when traversal depth and path queries are the core of the product, not a feature of it.

3. Time-series databases ​

Time-series data — metrics, sensor readings, prices, events — has a shape so specific that specialised engines beat general ones by an order of magnitude.

What makes it special:

  • Writes are almost always appends at the current time, never updates.
  • Reads are almost always a range of time, often aggregated: average per minute over the last day.
  • Old data becomes less interesting at a predictable rate.
  • Adjacent values are very similar, which makes them compress extremely well.

What the engines do about it:

Columnar storage per time chunk (Chapter 7.8.1 explains why this matters), so reading one metric does not read the others.

Delta and delta-of-delta encoding. A timestamp is normally stored as a full 64-bit number. But readings arrive at a steady pace, so most of those 64 bits repeat. Store instead the difference from the previous timestamp, the delta. Then store the difference between deltas, the delta-of-delta. For a sensor reporting every 10 seconds, almost every delta-of-delta is zero. Facebook's Gorilla system, published in 2015, then spends a single bit on each zero:

ts
// Why time-series timestamps compress so well: delta-of-delta, with Gorilla's bit costs.
const start = 1_785_000_000;                              // a Unix time in seconds
const timestamps = [0, 10, 20, 30, 40, 51, 60, 70, 80, 90].map((s) => start + s); // (1)

const deltas = timestamps.slice(1).map((t, i) => t - timestamps[i]);            // (2)
const dods = deltas.slice(1).map((d, i) => d - deltas[i]);                       // (3)

function gorillaBits(dod: number): number {                                     // (4)
  if (dod === 0) return 1;
  if (Math.abs(dod) <= 63) return 2 + 7;
  if (Math.abs(dod) <= 255) return 3 + 9;
  if (Math.abs(dod) <= 2047) return 4 + 12;
  return 4 + 32;
}

const rawBits = timestamps.length * 64;                                          // (5)
const packedBits = 64 + 14 + dods.reduce((sum, d) => sum + gorillaBits(d), 0);   // (6)

console.log("deltas:          ", deltas.join(" "));
console.log("delta-of-deltas: ", dods.join(" "));
console.log(`raw ${rawBits} bits, packed ${packedBits} bits, ${(rawBits / packedBits).toFixed(1)}x smaller`);

(1) Ten readings, ten seconds apart, except one that arrived a second late at 51. (2) The deltas are the gaps between readings. (3) The delta-of-deltas are how much each gap changed. (4) Gorilla's rule: a zero costs 1 bit, and a small number costs a short prefix plus a few bits. Only a wild jump pays for a full 32. (5) Stored plainly, every timestamp costs 64 bits. (6) Gorilla stores the first timestamp in full, the first delta in 14 bits, and then only the delta-of-deltas.

It prints:

deltas:           10 10 10 10 11 9 10 10 10
delta-of-deltas:  0 0 0 1 -2 1 0 0
raw 640 bits, packed 110 bits, 5.8x smaller

Ten points already shrink almost six times, and the gain grows with length, because every on-time reading costs 1 bit instead of 64. The late reading costs a little extra twice: once when the gap grows to 11, and once when it shrinks back to 9. The values get a similar trick: each reading is compared with the previous one bit by bit, and only the bits that changed are stored. Gorilla reported an average of about 1.4 bytes per point, timestamp and value together, against 16 bytes raw. That is the main reason a time-series database holds about ten times more data on the same disk.

Automatic retention policies and downsampling. Keep raw data for 7 days, one-minute averages for 90 days, one-hour averages for two years, and delete the rest — expressed as configuration rather than a cron job that someone must maintain.

Continuous aggregates: pre-computed rollups updated as data arrives, so a dashboard query reads a small summary rather than a billion points.

The main systems, honestly. Prometheus is a metrics system with its own store, pull-based, and is the default for infrastructure monitoring (Chapter 10.10). InfluxDB and TimescaleDB are general time-series stores — TimescaleDB is a PostgreSQL extension, which means you keep SQL, joins and your existing tooling, and is often the pragmatic choice. ClickHouse is a columnar analytics engine that is extremely good at time-series-shaped queries. Chapter 11.19 designs a metrics system end to end.

The trap that hits every metrics system: cardinality. A metric such as http_requests_total is stored as one separate series for every combination of its labels. Labels are the tags attached to it, such as method, route and status. The number of series is the number of possible values of each label, multiplied together. With 5 methods, 40 routes and 10 status codes, that is 5 × 40 × 10 = 2,000 series, which is fine. Now someone adds a user_id label "for debugging". With 100,000 users it becomes 200 million series. Each one needs memory and index space, and the metrics server runs out of memory and falls over. Never put an unbounded value, such as a user ID, an order ID or a full URL, in a metric label. It belongs in logs or traces (Chapter 10.10).

The other trap: storing high-volume metrics in your transactional database. A metrics table in PostgreSQL grows to hundreds of millions of rows, bloats, competes for the buffer pool with the data your users are waiting on, and makes vacuum a permanent background problem. Metrics belong somewhere else — that separation is worth more than any index you could add.

4. Choosing, as a procedure ​

Do not start from the database. Start from four questions, in this order.

1. What are the access patterns? Write down every query the system will run, with rough frequencies. If you cannot list them, you need a relational database, because it is the only family that answers questions you have not thought of.

2. What is the actual scale? Rows, bytes, writes per second, reads per second. Then check against a real number: a well-indexed PostgreSQL instance on modern hardware handles low tens of thousands of simple transactions per second and terabytes of data. Most systems that "outgrew" relational never measured.

3. What consistency does each operation need? Not the system — each operation. A payment needs strict correctness; a view counter does not. If the answer is "everything must be strictly correct", distributed alternatives get much less attractive.

4. What is the shape of the data? Deeply relational, self-contained aggregates, pure key lookups, relationship traversal, or a stream of timestamped points.

Then:

IfChoose
Anything unclear or evolvingRelational
Key lookups, extreme throughputKey-value
Self-contained aggregates, varying shapeDocument, or jsonb in PostgreSQL
Huge write volume, known key access, multi-regionWide-column
Deep traversal is the productGraph
Timestamped appends, range readsTime-series
Aggregation over billions of rowsColumnar (Chapter 7.8.1)

Two rules that outrank the table.

Start relational unless you have a specific reason not to. The reason must be a number or a named access pattern, not "scale". You can always move a specific workload out later, and moving one table out of a relational database is far easier than discovering three years in that you cannot answer a new question.

Polyglot persistence is the normal end state, and it is not free. Real systems end up with PostgreSQL for core data, Redis for cache and sessions, Elasticsearch for search, and a time-series store for metrics — because each is genuinely better at its job. But every additional store is another thing to operate, back up, secure, monitor, and keep in agreement. Two stores holding the same fact will disagree eventually, and reconciling them becomes real work. Add a store when the pain of not having it exceeds that cost, and not before.

5. NewSQL and distributed SQL ​

The families above were designed when the choice was "SQL on one machine" or "scale without SQL". That is no longer the choice.

Distributed SQL systems — Google Spanner, CockroachDB, YugabyteDB, TiDB — shard data across machines while keeping SQL, joins and ACID transactions, using consensus (Chapter 10.7.2) for replication and either atomic clocks or careful timestamp ordering for cross-shard transactions.

Vitess and Citus take the other route: shard MySQL or PostgreSQL itself, keeping the engine and adding a coordination layer.

The honest cost of all of them: a cross-shard transaction requires coordination, so it is much slower than a local one, and the latency floor is set by the distance between replicas. You get SQL and transactions at scale, and you pay in write latency and operational complexity. They are a real option for a system that genuinely needs both, and over-engineering for most.

What the interviewer will push on ​

"When would you use Cassandra?" Very high write volume with a known partition-key access pattern and a real multi-region requirement. Then show you know the discipline it demands: every query must name a partition key, secondary indexes are weak so you duplicate into a second table, and partitions must be bucketed to stay bounded and to avoid a hot node.

"What is a partition key versus a clustering key?" The partition key decides which machine holds the data; the clustering key decides the sort order within the partition, which is what makes a range read sequential. The tell is drawing the consequence — a poorly chosen partition key concentrates all of today's writes on one node.

"With a replication factor of 3, which consistency levels give you read-your-writes?" Any pair where the copies written plus the copies read add up to more than 3: QUORUM plus QUORUM (2 + 2), or ALL plus ONE (3 + 1). ONE plus ONE does not. The tell is stating the rule rather than reciting "use quorum", and adding LOCAL_QUORUM for multi-region clusters so requests do not wait on a remote data centre.

"How do you model 'orders by customer' and 'orders by hour' in Cassandra?" Two tables, one per question, each partitioned by what that question names, and the application writes every order to both, grouped in a logged batch. Bound the second table's partitions by hour rather than day. Then admit the cost: duplicated data, and an application responsible for keeping both copies written.

"Why did deleted data come back in our Cassandra cluster?" A node missed the delete while it was down, and was not repaired before the tombstone was cleared after gc_grace_seconds. When it synced, its old copy looked newer than nothing and spread back. Repair every node more often than the grace period.

"Why did our Prometheus server run out of memory?" Label cardinality. Each combination of label values is its own series, so a label with an unbounded value, such as a user ID, multiplies the series count by the number of users. The fix is removing that label and putting per-user detail in logs or traces.

"Why is a graph database faster for friends-of-friends?" Index-free adjacency: a node holds direct pointers to its relationships, so traversal is pointer-following rather than an index lookup per hop, and the cost does not grow with total graph size. Then be honest — at two hops SQL is fine, and the difference only becomes decisive at depth or with variable-length paths.

"Why not store metrics in PostgreSQL?" Volume and shape. Hundreds of millions of append-only rows bloat the table, compete for the buffer pool with user-facing data, and make vacuum a permanent problem — while a time-series engine compresses the same data by ten times using delta-of-delta encoding and downsamples it automatically. The separation is worth more than any index.

"How do you choose a database?" Access patterns first, then measured scale, then per-operation consistency, then data shape. Say the sentence that matters: if you cannot list the access patterns, you need relational, because it is the only one that answers questions you have not thought of yet. "We might need to scale" is not a reason.

"What is the cost of polyglot persistence?" Each store is another thing to operate, back up, secure and monitor, and two stores holding the same fact will disagree. It is the normal end state and it should be reached deliberately, one store at a time, when the pain of not having it exceeds that cost.

One thing to volunteer: mention that a queue implemented in Cassandra is a known anti-pattern — insert, read, delete produces tombstone-heavy range scans, which is precisely the access pattern an LSM store is worst at. It shows you reason from the storage engine to the workload rather than from marketing material.

Recall

  • Wide-column is a distributed sorted map of maps: the partition key picks the machine, the clustering key sorts within it. Every query must name the partition key; ALLOW FILTERING is a hazard, not a feature.
  • Cassandra buys linear write scaling, no leader, tunable consistency (quorum reads plus quorum writes give read-your-writes) and multi-region replication. It costs hot partitions, unbounded partitions, tombstones, and last-write-wins by timestamp.
  • A queue in Cassandra is the classic anti-pattern — insert/read/delete makes tombstone-heavy range scans, the worst case for an LSM store.
  • Model one table per question and write each record to every table that needs it. Reads see the latest write when copies written + copies read > replication factor (QUORUM + QUORUM with 3). Cassandra 5.0's SAI indexes are good, and a query without the partition key still asks every node.
  • Repair more often than gc_grace_seconds (10 days), or deleted rows come back. Lightweight transactions (IF NOT EXISTS) cost four round trips, so keep them rare.
  • Recursive SQL handles bounded traversal and grows with friends^hops; a graph database follows stored pointers. GQL became an ISO standard in 2024; SQL/PGQ is in SQL:2023 but not yet in PostgreSQL 18.
  • Metric label cardinality multiplies: never put user IDs, order IDs or URLs in labels.
  • Graph databases use index-free adjacency: nodes point directly at their relationships, so traversal cost does not grow with graph size. Decisive at depth and for variable-length paths; unnecessary at two hops.
  • Time-series engines win on shape: append-only writes, range reads, delta-of-delta and XOR compression taking points from ~16 bytes to ~1.4, plus retention policies, downsampling and continuous aggregates. Keep metrics out of your transactional database.
  • Choosing: access patterns → measured scale → per-operation consistency → data shape. If you cannot list the access patterns, you need relational.
  • Start relational. The reason to leave must be a number or a named access pattern. Moving one workload out later is far easier than losing the ability to ask new questions.
  • Polyglot persistence is normal and not free — every store is another thing to operate and another copy that can disagree. Distributed SQL (Spanner, CockroachDB, Vitess, Citus) keeps SQL and transactions at scale, paying in write latency and operational complexity.

Self-test: What decides which Cassandra node holds a row, and what decides its order there? · Why does bucketing a partition key by month matter? · What is index-free adjacency and when does it stop mattering? · Why does time-series data compress to about a tenth? · What is the first question when choosing a database? · What does every extra datastore cost you?

Next: 7.6 covers the store almost every system ends up adding first — Redis — its data structures, its persistence models, and the failure modes of putting a cache in front of a database.

Combine chapters into one PDF

Pick the chapters you want. They print in the order you pick them.

Volume I — Technology
Part 0 — Retention & Notation
Part 1 — Foundations of Computation
Part 2 — Operating Systems
2.1 The Kernel
2.2 Processes
2.3 Threads & Scheduling
2.4 Concurrency Under the Hood
2.5 Memory Management
2.6 File Systems
2.7 Input/Output
2.8 Linux for Engineers
2.9 Windows & macOS in Practice
Part 3 — Languages, Compilers & Runtimes
3.6 JavaScript & V8
3.7 TypeScript
3.8 Node.js Internals
3.13 Python & CPython
3.14 FastAPI & Production Python
Part 4 — Data Structures & Algorithms
4.0 Classic Problems — Before NeetCode
4.4 Arrays & Hashing — Problems
4.5 Two Pointers
4.6 Sliding Window
4.8 Stack — Problems
4.9 Linked List — Problems
4.11 Binary Search — Problems
4.13 Trees
4.14 Tree — Problems
4.15 Trie — Problems
4.17 Heap — Problems
4.18 Backtracking — Problems
4.19 Graphs
4.20 Graph — Problems
4.21 Advanced Graph — Problems
4.23 1-D DP — Problems
4.24 2-D DP — Problems
4.26 Greedy — Problems
4.27 Interval — Problems
4.28 Math & Geometry — Problems
4.30 Bit Manipulation — Problems
Part 5 — Networking & the Web
5.3 IP
5.4 Transport
5.6 HTTP
Part 6 — Frontend Engineering
6.1 Browser Internals
6.2 HTML & CSS Mastery
6.3 JavaScript in the Browser
6.4 React, from First Component to Full Shop
6.5 Frameworks & Rendering
6.8 UI Engineering & Patterns
Part 7 — Databases & Storage
7.2 SQL Mastery
7.3 Storage Engine Internals
7.4 Transactions
7.5 NoSQL Taxonomy
7.8 Analytics & Big Data
Part 8 — Security, Identity & Cryptography
8.2 Cryptography
8.3 Protocols of Trust
8.4 Identity: AuthN & AuthZ
8.5 Application Security
8.6 Infrastructure Security
Part 9 — Software Design (LLD)
9.2 OOP Foundations
9.3 Design Principles
9.4 Design Patterns
9.5 Concurrency
9.6 API Design
9.7 LLD Interview Machines
9.9 Node/Express Production Playbook
Part 10 — Distributed Systems & HLD
10.7 Consistency & Consensus
10.8 Messaging & Microservices
10.14 Caching
Building blocks from the design seat
Part 11 — System Design Case Studies
Part 12 — AI & ML Engineering
12.1 What AI Engineering Is
12.2 The Math You Need
12.3 Classical Machine Learning
12.4 Data for ML
12.5 Deep Learning
12.6 Embeddings & Vector Search
12.7 Transformers & LLMs
12.8 Building with LLMs
12.9 Retrieval-Augmented Generation
12.10 Agents
12.11 Adapting Models
12.12 Production AI
12.13 Multimodal AI
12.14 AI Security & Governance
12.15 Case Studies & Capstone
Part 13 — Cloud, DevOps & Infrastructure
13.11 Git, from First Commit to Team Workflow
Part 14 — Containers: Docker & Kubernetes
14.1 Foundations
14.2 Docker
14.3 Kubernetes
14.4 Kubernetes on Azure
Part 15 — The Craft & Career
Nothing picked yet