Chapter 4 checkpoint

Chapter 4 checkpoint: scaling relational databases

Every question from this chapter’s lessons. Your first answer to each is the one that counts; afterward you can practice again as often as you like. Passing needs 75% right on the first attempt.

0 of 19 answered0 right on the first attempt

Question 1 of 19

A user changes their billing address and immediately reloads their account page, which reads from one of four asynchronous replicas, and sees the old address. Which change fixes this for that user without giving up the replicas?

Send that user’s reads to the primary for a few seconds after they writeAlways send each user to the same replicaCache the account page for longerAdd more read replicas

Question 2 of 19

Match each replication mode to what a commit waits for.

AsynchronousSynchronous (PostgreSQL)Semisynchronous (MySQL)

Question 3 of 19

A user sees a new comment, refreshes, and the comment has disappeared; a moment later it is back. Reads go to whichever replica the load balancer picks. What is happening, and what fixes it?

The reads hit replicas with different lag; send each user to the same replicaThe comment was deleted and restoredThe primary lost the write; switch to semisynchronous replicationSplit-brain between two primaries

Question 4 of 19

An old leader pauses for a minute, a new leader is elected, and then the old one wakes up and tries to write. What does a fencing token do?

Vector clocks merge both leaders’ writesStorage rejects the write because it carries an older, smaller tokenHeartbeats tell the old leader to stopLast-write-wins keeps the old leader’s write

Question 5 of 19

What does federation split a database by?

Rows of one table, by a keyReads and writesOld and new dataFunction or domain, such as users, catalog and orders

Question 6 of 19

An order page used to run one SQL join across orders, users and products. After federating into separate Orders, Users and Catalog databases, how does it usually get the same data?

The application queries each database, in parallel where it can, and combines the resultsThe same SQL join keeps workingIt must shard all three tables by order_idForeign keys between the databases find the rows

Question 7 of 19

After federating, the Orders database still receives most of the traffic and is reaching its limits. What does that tell you?

The databases should be merged backFederating the other domains further will fix itAdding foreign keys will spread the loadFederation only bought time; the Orders database now needs sharding

Question 8 of 19

Which guarantee does a single database give that federated databases lose?

Foreign key constraints between tables in different domainsTransactions inside one domainReplicationIndexes

Question 9 of 19

One database primary handles 2,500 writes per second. A ledger must sustain 20,000 writes per second at peak, and you provision 25% more capacity than the peak. With writes spread evenly, how many shards does it need?

Your answershards

Answers within 1% count.

Question 10 of 19

Keys are placed with

\text{hash}(k) \bmod N

. Going from 4 shards to 5, about what percentage of keys must move?

Your answer%

Answers within 3% count.

Question 11 of 19

With consistent hashing and virtual nodes, about what percentage of keys move when a fifth shard joins four?

Your answer%

Answers within 5% count.

Question 12 of 19

A multi-tenant SaaS has 50,000 customer accounts, and almost every query is about one account. Which shard key fits best?

The account idThe record’s statusThe creation date, in rangesThe account’s country

Question 13 of 19

A query without the shard key fans out to 20 shards, and each is independently slow 1% of the time. About what percentage of these queries are slow?

Your answer%

Answers within 5% count.

Question 14 of 19

Why do high-throughput services often prefer sagas to two-phase commit for transactions across shards?

A saga does not hold locks across shards while waiting, and does not block on a failed coordinatorA saga needs no extra code to undo failuresA saga commits all steps atomicallyA saga gives stronger isolation

Question 15 of 19

A table has a composite index on (tenant_id, status, created_at). Which condition cannot use the index to narrow the scan?

WHERE status = 'ACTIVE'WHERE tenant_id = 42 AND status = 'ACTIVE' AND created_at >= '2026-01-01'WHERE tenant_id = 42 AND status = 'ACTIVE'WHERE tenant_id = 42

Question 16 of 19

A query filters tenant_id = 42 AND status = 'POSTED' AND created_at > '2026-11-01'. Which index lets all three conditions narrow the scan?

(tenant_id, created_at, status)(created_at, tenant_id, status)(status)(tenant_id, status, created_at)

Question 17 of 19

After scaling out to many application servers, each opening its own PostgreSQL connections, the database spends most of its memory and CPU on connections rather than queries. What helps most?

Denormalize the schemaAdd more indexesPut a connection pooler between the applications and the databaseRaise the database’s connection limit

Question 18 of 19

What does denormalization trade?

Faster reads for more write work and a risk of inconsistent copiesFaster writes for slower readsNothing: it is always fasterLess storage for more joins

Question 19 of 19

A database takes 10,000 queries a second, 20% of them writes. Writes go to the primary; reads are spread evenly over two read replicas. Each database server can do 5,000 operations a second, and replaying a write costs a replica as much as the write cost the primary. Which saturates first?

App servers ×10Each handles 1,500 requests/s

Primary5,000 operations/sRead replicas ×2Each 5,000 operations/s