Design Deck is an open-source collection of 160+ system design flash cards.
It helps you prepare and succeed in your system design interview.
The topics covered are the following:
- Cache: eviction, locations, strategies, when to use a cache, etc.
- Cloud: main cloud components
- Database: ACID, CAP, partitioning, consistency, isolation, denormalization, etc.
- Design: general topics such as idempotence, bloom filter, causality, asynchronous communications, vector clocks
- HTTP: main HTTP knowledge
- Interview: system design interview
- Kafka: main Kafka building blocks
- Network: TCP, CORS, ping & heartbeat, OSI, etc.
- Reliability: how to guarantee reliability
- Security: main security knowledge such as TLS, cipher, encryption
- Time: time and distributed systems
- Cache aside
- Cache aside vs. inline caching
- Cache eviction policy
- Cache locations
- Main metric for cache
- Read-through
- Refresh-ahead
- Write through vs. write back
- When to use a cache
- ACID property
- Byzantine fault-tolerant
- CALM theorem
- CAP theorem
- Causal consistency
- Chain replication
- Concurrency control
- Consensus
- Consistency models
- Consistent prefix reads
- CQRS
- CRDT
- DB indexes tradeoff
- DB internal components
- Denormalization
- Difference view & materialized view
- Dirty read
- Dirty write
- Document vs. relational
- Document-partitioned vs. term-partitioned indexes
- Event sourcing
- Eventual consistency
- Examples of solutions offering leader election abstractions
- Federation
- Fencing token
- Fuzzy read
- Gossip protocol
- Graph DB main use case
- Hot spot in partitioning
- In a database, strategy to handle rebalancing
- Isolation level
- Key range vs. hash partitioning
- Knee point
- Leader election
- Linearizability
- LSM tree
- LSM tree vs. B-tree
- Main downside of distributed transactions
- Main reasons to partition data
- Monotonic reads consistency
- Monotonic writes
- MVCC
- N+1 select problem
- NoSQL
- Optimistic concurrency control: pros and cons
- PACELC theorem
- Partitioning (sharding)
- Phantom read
- Quorum
- Raft
- Read committed consistency
- Read uncommitted consistency
- Read-after-write consistency
- Read-heavy vs. write-heavy impacts
- Relation between replication factor, write consistency and read consistency
- Relationship between causality and linearizability
- Replication or partition?
- Schema-on-read vs. schema-on-write
- Serializability
- Serializable Snapshot Isolation (SSI)
- Snapshot Isolation (SI)
- Split-brain
- SSTable
- Strong eventual consistency
- Synchronous replication in DB
- Two-phase commit (2PC)
- WAL
- When to use a column-oriented store
- Why DB schemaless is misleading
- Why is in-memory faster
- Write and read amplification
- Write skew
- Write-follows-reads
- Auditing
- Bloom filter
- Causality
- Consistent hashing
- Exactly-once delivery
- Hashing
- Idempotent
- Load balancing
- Locality
- Log
- Log compaction
- Microservices: pros and cons
- Outbox pattern
- Rebalancing
- REST
- REST vs. gRPC
- Saga
- Scalability
- Source of truth
- Throughput
- Two generals problem
- UUID
- Validation vs. verification
- Vector clock
- Why asynchronous communication
- Cache-control header
- Etag
- HLS
- HTTP
- HTTP methods: safeness and idempotence
- Keep-alive
- Main HTTP 2 features
- Safe method
- Status codes
- Status code 301 vs. 302
- Status code 409
- What happens if you type http://www.google.com in your browser
- Consumer types
- Log compaction
- Offset
- Partition
- Partition distribution
- Rebalancing
- Segment
- Shared subscription
- Backpressure
- CORS
- Difference ping & heartbeat
- Difference TCP & UDP
- DNS
- Health checks: active vs. passive
- Layer 4 vs. layer 7 load balancer
- OSI model
- Service mesh
- TCP congestion control
- TCP connection backlog
- TCP handshake
- Websocket
- Bulkhead pattern
- Cascading failure
- Circuit breaker
- Exponential backoff
- Fallback & timeout
- Fault tolerance
- Hard vs. soft dependencies
- How to set a timeout
- Jitter
- Load shedding
- Phi-accrual failure detector
- Rate-limiting (throttling)
- Reliability
- Retry amplification
- Scalability ceiling
- Service dependency, 5 questions to ask