Learn systems design

Design multi-tier caching strategies using client-side, CDN, application, and database caches

Apply cache eviction policies (LRU, LFU, TTL) based on access patterns

Apply cache invalidation strategies including write-through, write-back, and write-around patterns

Design solutions for cache stampede and thundering herd problems

Choose between local and distributed caching based on system requirements

Calculate cache hit ratio requirements and their impact on backend load

Design horizontal scaling strategies for stateless services

Design horizontal scaling strategies for stateful services

Apply load balancing algorithms (round-robin, least connections, consistent hashing) for different scenarios

Design systems using message queues for asynchronous processing and load smoothing

Apply rate limiting as a client-side and server-side pattern to manage load

Design auto-scaling policies based on system metrics

Combine auto-scaling and message queues to elastically absorb traffic bursts in backend services

Design systems with circuit breakers and bulkheads to prevent cascading failures

Design retry strategies with exponential backoff and jitter

Design service discovery patterns for a microservices architecture

Design health check mechanisms to monitor service availability and readiness

Apply redundancy for stateless and stateful services to eliminate single points of failure

Design graceful degradation strategies for partial system failures

Calculate and improve system availability (uptime) by applying fault tolerance patterns

Choose between batch and stream processing based on latency and data freshness requirements

Design a batch ETL pipeline for aggregating and transforming data, such as for daily analytics reports

Identify the core components of a stream processing system, including sources, sinks, and processing engines

Design a real-time data processing pipeline for a concrete problem, such as calculating trending topics

Design data pipelines using pub-sub patterns and event-driven architectures

Design strategies for achieving exactly-once processing semantics in distributed data pipelines

Design a URL shortening service with custom aliases and analytics

Design the API for a key-value store, focusing on GET/PUT operations and consistency guarantees

Design a data partitioning and replication strategy for a key-value store using consistent hashing

Design the data consistency model and request handling workflow for read and write operations in a key-value store

Design failure detection and handling mechanisms for a key-value store to ensure high availability

Design a distributed rate limiter, considering different algorithms (e.g., token bucket) and storage options

Design the video upload and processing pipeline, including transcoding for adaptive bitrate streaming

Design the video delivery architecture using a CDN to ensure low-latency streaming for a global user base

Design the APIs and metadata services required to support video search and playback on client devices

Design the data model and core APIs for a social media service, focusing on posts and user relationships

Architect the timeline generation mechanism, comparing fan-out-on-write and fan-out-on-read strategies

Design a scalable feed ranking service for timeline personalization

Design the caching strategy for delivering low-latency, personalized user feeds

Design a service for efficient geospatial queries using techniques like geohashing and quadtrees

Design a ride-sharing service with real-time matching and geospatial lookups

Design a notification system supporting multiple channels and delivery guarantees

Compare multi-region deployment architectures (e.g., active-passive, active-active) and their trade-offs regarding latency, availability, and cost

Design a data replication and synchronization strategy for a globally distributed system

Select a global traffic routing policy (e.g., GeoDNS, Anycast) to direct users to the appropriate region

Design conflict resolution strategies for multi-master replication systems

Describe the function and structure of an inverted index for a search system

Compare foundational ranking algorithms for search results, such as TF-IDF and PageRank

Design the high-level, distributed architecture for a search system, covering data ingestion, indexing, and query processing

Compare collaborative filtering and content-based filtering for generating recommendation candidates

Design a two-stage architecture (candidate generation and ranking) for a real-time recommendation system

Design the data models and offline processing pipeline for training recommendation models

Design a centralized logging architecture for a distributed system

Design a metrics and alerting system for monitoring system health and performance

Design a distributed tracing solution to analyze request flows in a microservices architecture

Design authentication flows for distributed services using patterns like OAuth 2.0 and JWT

Select and apply authorization models, such as Role-Based Access Control (RBAC), for securing system APIs and data

Design strategies for data encryption in transit (TLS) and at rest within a distributed system