Learning path
Designing Data-Intensive Applications learning path: everything to study, topic by topic
Master the principles, patterns, and trade-offs in designing reliable, scalable, and maintainable data systems. Cover database fundamentals, data models, indexing, replication, consistency, partitioning, and stream processing.
Short answer
To learn Designing Data-Intensive Applications, work through 6 modules and 26 topics in the order they build on each other. It starts with Foundations, then moves on to Data Models & Query Languages and Storage & Indexing. Use the map as a checklist, or measure your level and study only what is missing.
What you will study
Topics are grouped by module. Open one to see its objectives and key concepts.
1 · Foundations3 topics
Disk I/O Fundamentals
Understand disk seek time, rotational latency, sequential vs. random access patterns, and how disk characteristics impact database design.
Objectives
- Explain how disk I/O latency affects query performance
- Describe the trade-off between seek time and throughput
- Compare sequential vs. random access patterns
Key concepts
- disk seek time
- rotational latency
- sequential access
- random access
- page size
Database Types & Comparison
Overview of relational, NoSQL, in-memory, and specialized databases with use-case analysis.
Objectives
- Classify databases by architecture and use case
- Compare OLTP vs. OLAP workload patterns
- Identify when to use relational vs. NoSQL
Key concepts
- OLTP
- OLAP
- relational databases
- NoSQL
- data warehouses
Storage Concepts
In-memory vs. disk-based storage, durability, write-ahead logs, and memory management.
Objectives
- Explain the durability guarantees of in-memory vs. disk storage
- Describe how write-ahead logs enable crash recovery
- Analyze trade-offs between speed and durability
Key concepts
- in-memory storage
- disk-based storage
- write-ahead logs
- durability
- volatility
2 · Data Models & Query Languages4 topics
Relational vs. Document Data Models
Compare relational (normalized) and document (denormalized) data models with normalization and schema design implications.
Objectives
- Contrast relational normalization with document flexibility
- Explain the join problem in relational databases
- Analyze schema evolution in document stores
Key concepts
- normalization
- denormalization
- joins
- document model
- schema flexibility
Graph Data Models
Graph-based data representations, graph queries, traversals, and use cases in recommendation systems and social networks.
Objectives
- Model relationships using graph structures
- Write and optimize graph traversal queries
- Apply graph patterns to recommendation systems
Key concepts
- vertices
- edges
- graph queries
- graph traversal
- path algorithms
Schema Design Patterns
Schema design for relational and document databases, including denormalization patterns, nested documents, and evolvability.
Objectives
- Design scalable schemas for read/write workloads
- Apply denormalization patterns effectively
- Manage schema evolution over time
Key concepts
- schema design
- denormalization
- nested documents
- schema migration
- backwards compatibility
Query Languages & Optimization
SQL, declarative query languages, query optimization, and indexes for query performance.
Objectives
- Write optimized SQL queries
- Understand query execution plans
- Apply indexes to improve query performance
Key concepts
- SQL
- query execution plans
- cost estimation
- query optimization
- full-text search
3 · Storage & Indexing5 topics
B-Tree Index Structures
B-tree data structure, balance properties, insertion/deletion algorithms, and why databases use B-trees for indexing.
Objectives
- Explain B-tree structure and rebalancing
- Analyze the cost of B-tree operations
- Compare B-trees with hash indexes
Key concepts
- B-tree
- balance
- node splitting
- range queries
- sorted order
SSTables & LSM Trees
Log-Structured Merge trees, write amplification, compaction, and their use in modern databases like RocksDB and Cassandra.
Objectives
- Explain LSM tree architecture and compaction strategies
- Analyze write amplification in LSM trees
- Compare LSM trees vs. B-trees for different workloads
Key concepts
- LSM tree
- SSTables
- memtable
- compaction
- write amplification
Indexing Strategies
Primary vs. secondary indexes, multi-column indexes, full-text search, and bitmap indexes.
Objectives
- Design effective index strategies for query patterns
- Optimize multi-column indexes
- Apply full-text search to text data
Key concepts
- primary index
- secondary index
- covering index
- full-text search
- bitmap index
Compression & Encoding
Data compression techniques, encoding schemes, and their impact on storage and query performance.
Objectives
- Apply compression techniques to reduce storage
- Balance compression ratio vs. query performance
- Implement encoding schemes for different data types
Key concepts
- dictionary compression
- run-length encoding
- entropy encoding
- columnar compression
Query Execution & Optimization
Query planning, cost estimation, join algorithms, and advanced optimization techniques.
Objectives
- Understand query plan generation and cost models
- Optimize complex multi-join queries
- Apply adaptive query execution techniques
Key concepts
- query planner
- cost estimation
- join algorithms
- histogram statistics
- adaptive query execution
4 · Replication & Consistency5 topics
Leader-Follower Replication
Master-slave replication, synchronous vs. asynchronous replication, replication lag, and failure handling.
Objectives
- Explain leader-follower replication topology
- Analyze eventual consistency and replication lag
- Handle failover scenarios
Key concepts
- master-slave replication
- replication lag
- synchronous replication
- failover
- replica
Multi-Leader Replication
Multi-master replication, conflict resolution, and challenges in managing writes across multiple leaders.
Objectives
- Compare multi-leader vs. single-leader replication
- Implement conflict resolution strategies
- Handle write conflicts in geo-distributed systems
Key concepts
- multi-master
- write conflicts
- conflict resolution
- last-write-wins
- custom conflict resolver
Consistency Models
Strong, eventual, causal, and session consistency with trade-offs and implications for distributed systems.
Objectives
- Understand consistency guarantees and trade-offs
- Apply appropriate consistency models to use cases
- Analyze consistency implications for applications
Key concepts
- strong consistency
- eventual consistency
- causal consistency
- session consistency
- consistency ordering
ACID vs. BASE Transactions
ACID properties, BASE properties, transaction semantics, and when to apply each model.
Objectives
- Explain ACID guarantees and isolation levels
- Compare ACID vs. BASE trade-offs
- Choose appropriate transaction semantics for applications
Key concepts
- Atomicity
- Consistency
- Isolation
- Durability
- BASE
- eventual consistency
Consensus Algorithms
Paxos, Raft, Byzantine fault tolerance, and achieving agreement in distributed systems.
Objectives
- Understand Raft consensus algorithm
- Analyze Paxos and its complexity
- Apply consensus for coordinated decisions
Key concepts
- Paxos
- Raft
- Byzantine fault tolerance
- leader election
- quorum
5 · Partitioning & Scalability5 topics
Sharding & Partitioning
Data partitioning strategies, sharding keys, range-based and hash-based partitioning with rebalancing.
Objectives
- Choose effective sharding keys
- Understand range vs. hash partitioning
- Manage data rebalancing across shards
Key concepts
- sharding
- partition key
- range-based partitioning
- hash-based partitioning
- rebalancing
Distributed Joins
Executing joins across partitioned data, colocation strategies, and handling joins on different keys.
Objectives
- Optimize distributed join execution
- Apply colocation strategies
- Handle multi-partition joins efficiently
Key concepts
- distributed join
- colocation
- broadcast join
- shuffle join
- three-way join
Hot Key Problems
Identifying hot keys, mitigation strategies like replication, splitting, and micro-partitioning.
Objectives
- Identify and measure hot keys
- Apply mitigation strategies
- Monitor and prevent load skew
Key concepts
- hot key
- load skew
- micro-partitioning
- key-level replication
- scattering
Skewed Data & Load Balancing
Handling skewed data distributions, adaptive partitioning, and load rebalancing in distributed systems.
Objectives
- Detect and measure data skew
- Apply adaptive partitioning
- Implement dynamic load balancing
Key concepts
- data skew
- adaptive partitioning
- load balancing
- dynamic rebalancing
Distributed Transactions
Two-phase commit, saga pattern, compensating transactions, and maintaining consistency across partitions.
Objectives
- Implement two-phase commit
- Apply saga pattern for distributed transactions
- Handle transaction failures and compensation
Key concepts
- two-phase commit
- saga pattern
- compensating transaction
- event-driven choreography
6 · Stream Processing4 topics
Event Streaming Architectures
Event logs, message brokers, Kafka, and stream processing systems with guarantees and semantics.
Objectives
- Design event streaming architectures
- Understand message ordering and partitioning
- Apply Kafka for scalable event systems
Key concepts
- event log
- message broker
- Kafka
- topic
- partition
- offset
Exactly-Once Semantics
Delivery semantics (at-most-once, at-least-once, exactly-once) and implementing exactly-once processing.
Objectives
- Understand delivery semantics trade-offs
- Implement exactly-once processing
- Apply idempotency for deduplication
Key concepts
- at-most-once
- at-least-once
- exactly-once
- idempotent
- deduplication
Stream Joins & Windowing
Time windows, stream joins, sessionization, and handling out-of-order events.
Objectives
- Apply windowing strategies for stream aggregation
- Implement stream joins across tables
- Handle late-arriving and out-of-order events
Key concepts
- time window
- sliding window
- stream join
- sessionization
- watermark
Event Sourcing & CQRS
Event sourcing as a design pattern, command-query responsibility separation (CQRS), and state reconstruction.
Objectives
- Design event-sourced systems
- Implement CQRS pattern
- Manage read and write models independently
Key concepts
- event sourcing
- CQRS
- event store
- command
- query model
- state reconstruction
Levels: Junior, Mid, Senior, and Expert
Explain it in your own words
Graded by AI · no account · 1 questionNo options to guess from: you write, the AI grades against the topic's rubric and tells you what level your answer reads at.
Already studying Designing Data-Intensive Applications?
The assessment measures topic by topic, and your plan skips what you already know.
Open to read. An account is only needed to be measured.
Frequently asked questions
Where should I start studying Designing Data-Intensive Applications?
Start with Foundations: Disk I/O Fundamentals, Database Types & Comparison, and Storage Concepts. The map orders topics by what they depend on, so each one prepares the next.
How long does a full Designing Data-Intensive Applications assessment take?
A full assessment of this path takes about 60 minutes. Study time depends on where you start; a diagnostic shows which topics you can skip.
Do I need an account to use this page?
No. The map, objectives and key concepts are open. You only need an account to be measured, get your gap by topic and receive a plan.