DDIA interview prep

• ACID Properties — What atomicity, consistency, isolation and durability each promise, which part of the database delivers each o
• B-Trees and Write-Ahead Logs — How a B-tree finds any key in a few page reads, how it splits pages as it grows, and how the write-ahead log k
• Beyond MapReduce: Dataflow Engines — How Spark, Tez and Flink run a whole pipeline as one graph of operators instead of a chain of MapReduce jobs,
• Change Data Capture (CDC) — How change data capture turns every committed write in a database into an ordered stream of events, so search
• Clocks and Time in Distributed Systems — Why the clocks on different machines disagree, which clock to use for what, how last-write-wins silently loses
• Column-Oriented Storage and Compression — Why analytics databases store each column on its own, how that makes data small enough to scan fast, and what
• Consensus Algorithms: Paxos and Raft — How a group of servers agrees on one value, or one ordered log, even when some of them crash: the problem, how
• Consistency Guarantees: Eventual, Causal and Linearizable — What a read is allowed to return when data has several copies: eventual, session, causal and linearizable cons
• Declarative vs Imperative Query Languages — Why saying what you want (SQL, Cypher, a MongoDB pipeline) instead of how to get it lets the database pick ind
• Encoding Formats: JSON, Protobuf, Avro, Thrift — How programs turn in-memory data into bytes, and how text formats like JSON compare with schema-based binary f
• End-to-End Correctness and the Exactly-Once Myth — Why transactions and exactly-once messaging inside one component do not stop duplicate effects across the whol
• Event Streams and Message Brokers — How events move from producers to consumers through a broker: queues that delete a message once handled, logs
• Fan-Out and the Twitter Timeline Problem — Build a feed by merging at read time or by copying each post to followers at write time; how Twitter chose bet
• Fault Tolerance in Stream Processing — How a stream processor survives crashes without losing or double-counting events: microbatches, checkpoints wi
• Faults and Partial Failures — Why a distributed system can be half broken, why a missing reply tells you almost nothing, and the tools that
• Graph Data Models — Property graphs, RDF triples and graphs stored in SQL tables: how each works, how you query paths of unknown l
• Implementing Serializability — Three ways a database makes concurrent transactions behave as if they ran one at a time: actual serial executi
• Isolation Levels — Read uncommitted, read committed, snapshot isolation and serializable: which anomalies each one allows, how MV
• Joins in Batch Processing — How a batch job joins two datasets that live on many machines: shuffle both sides, copy the small side everywh
• Joins in Stream Processing — How a stream processor joins data that never stops arriving: two event streams within a time window, a stream
• Lambda and Kappa Architectures — Lambda runs a batch pipeline and a streaming pipeline side by side and merges their answers; Kappa keeps one s
• Leaderless Replication (Dynamo-Style) — Any replica takes reads and writes, and quorums decide success. How W + R > N works, how stale replicas catch
• Linearizability — The guarantee that a replicated system behaves as if there were one copy of the data: what it promises, when y
• LSM-Trees and SSTables — How a log-structured merge-tree turns random writes into sequential ones, what compaction costs, and how Bloom
• MapReduce — How MapReduce splits a big batch job into map, shuffle and reduce across many machines, how it survives failur
• Modes of Dataflow: Databases, Services, Messages — The three ways encoded data travels between processes (through a database, through service calls, through a me
• Multi-Leader Replication — Several nodes accept writes and replicate to each other. Why you would want that, why it creates write conflic
• OLTP vs OLAP — Transaction processing and analytics read data in opposite ways. This topic covers why they usually live in se
• Ordering and Causality — How distributed systems decide what happened before what: the happens-before relation, Lamport and vector cloc
• Partitioning Strategies: Range vs Hash — How a database splits data across machines by key range or by key hash, what each does to range queries and ho
• Rebalancing Partitions — How a partitioned database moves data when machines join or leave: fixed, dynamic and per-node partitioning, m
• Relational vs Document Data Models — How tables with joins and self-contained documents each fit the shape of your data, and how to choose between
• Reliability, Scalability, and Maintainability — The three qualities every data system is judged on: correct answers when parts fail, steady performance as loa
• Replication Lag and Consistency Anomalies — Reading from asynchronous replicas can show users old data. The three anomalies that lag causes (missing your
• Schema Evolution and Backward/Forward Compatibility — How to change the shape of your data while old and new code run side by side: backward and forward compatibili
• Schema-on-Read vs Schema-on-Write — Whether the database checks the shape of data when it is written, or the reading code interprets it later, and
• Secondary Indexes and Index Trade-offs — Hash, B-tree, composite, covering and inverted indexes: what each can answer, where it points, and what it cos
• Secondary Indexes on Partitioned Data — How to look records up by something other than the partition key: local indexes with scatter/gather reads, glo
• Single-Leader Replication — One node takes every write and streams its changes to read-only copies. How the log is shipped, what synchrono
• SLAs, SLOs, and Percentile Latency — How to state, measure and defend latency targets with percentiles instead of averages, why fan-out makes the s
• Unbundling the Database — The idea of treating a whole data platform as one database taken apart: an ordered log of writes at the center
• What Is a Data-Intensive Application? — Why most applications are limited by data rather than CPU, and how databases, caches, search indexes and logs
• Write Skew and Phantom Reads — The race that snapshot isolation lets through: two transactions check the same rule, write different rows, and
• ZooKeeper, etcd, and Distributed Coordination — How ZooKeeper and etcd package consensus as a small, strongly consistent store, and how systems build leader e

Start free on Cariara · Coding problems · System design studio