System Design Interview Playbook

Design a globally distributed web crawler capable of indexing 1 billion pages per day. The system must address the challenges of URL discovery at scale, ensuring 'politeness' to avoid overwhelming target servers, deduplicating content, and managing the storage of petabytes of data. Explain how you would handle DNS resolution bottlenecks, prioritize URLs based on 'freshness' requirements, and ensure the system is resilient to network failures or worker crashes.

Design a scalable infrastructure for a high-concurrency inference API. The system must use a fixed, black-box GPU inference endpoint. Your primary focus should be the architectural components required to implement a high-performance dynamic batching service that aggregates incoming user requests into optimal groups before calling the GPU worker. Address the challenges of request-to-result mapping in a distributed environment, handling backpressure during peak loads (10k+ QPS), and minimizing the latency overhead introduced by the batching logic.

Design a highly available and scalable communication system similar to WeChat. The system must support real-time 1:1 and group messaging for over 1 billion users, a social feed (Moments) with a complex social graph, and real-time presence tracking. Address the challenges of maintaining hundreds of millions of concurrent persistent connections, ensuring message delivery guarantees (no loss, correct ordering), and managing high-throughput write-heavy workloads for social updates. Discuss the trade-offs between push and pull models for feed distribution and the protocols used for mobile network resilience.

Design a distributed rate-limiting system capable of handling 1M+ requests per minute for an AI provider like OpenAI. The system must support complex metrics including Requests Per Minute (RPM) and Tokens Per Minute (TPM) across hierarchical levels (Organizations and API Keys). Focus on achieving sub-5ms latency, high availability with fail-open capabilities, and handling the unique challenge of 'token-based' limiting where the exact cost is only known after the request completes.

Design a high-scale user management system for a global AI platform. The system must handle user profiles, flexible preference configurations (e.g., model parameters), multi-device session management with revocation capabilities, and a high-throughput API quota enforcement engine. Ensure the design can handle 100M+ users with low-latency quota checks (<10ms) and high availability, while discussing the trade-offs between strict consistency and system performance.

Design a globally distributed messaging platform similar to Facebook Messenger. The system must support real-time delivery to billions of users, multimodal attachments (images/video), and seamless synchronization across multiple devices (mobile, web). Key requirements include low-latency message delivery, tracking delivery/read status, and high availability. Discuss how you handle millions of persistent connections, ensure message ordering, and manage storage for trillions of historical messages while maintaining reliability during network partitions.

Design the core architecture for a global social media news feed similar to Facebook or Instagram. The system must handle over 2 billion Daily Active Users (DAU). Key requirements include: supporting various media types (text, images, video), generating a personalized feed with low latency (<200ms), and managing the 'celebrity problem' (high-profile accounts with millions of followers). Explain your strategy for feed generation (push vs. pull), how you handle real-time interaction counters (likes/comments), and your data sharding approach to ensure high availability and horizontal scalability.

Design a web crawler capable of processing 1 billion URLs per month. The system should automatically discover new links, store the page content for future indexing, and strictly adhere to politeness constraints (robots.txt and per-domain rate limits). Detail the architecture for the URL Frontier, deduplication strategy, and how you would handle distributed workers while maintaining scalability and fault tolerance.

Design a high-performance distributed rate limiting system capable of handling 10 million requests per second with sub-2ms latency. The system must support various granularities (User, IP, API Key) and dynamic rule updates. Focus on high availability, the trade-offs between consistency and performance, and ensuring the system does not become a single point of failure for the entire architecture.

Design a highly available and horizontally scalable distributed Key-Value store. The system must support millions of requests per second, handle petabytes of data, and provide tunable consistency models. Detail how you would handle data partitioning, replication across multiple nodes, conflict resolution for concurrent writes, and decentralized failure detection without a single point of failure.

Design a high-scale virtual currency escrow service (e.g., for Robux) that allows users to schedule payments to be released after a designated future delay (ranging from seconds to days). The system must deduct funds immediately from the sender, support cancellations prior to maturity, and ensure at-least-once execution within a tight SLA. Handle 5,000 QPS and discuss how you ensure ledger consistency, handle short-term vs. long-term delays, and manage the race conditions between execution and cancellation.

Design a high-performance distributed file transfer system similar to BitTorrent. The system must support millions of concurrent users sharing large files (GBs to TBs) while minimizing server bandwidth costs. Focus on the architecture for peer discovery (Tracker), metadata management, and the logic for direct peer-to-peer data exchange. Address challenges such as peer churn, data integrity verification, and incentives to prevent leeching (free-riding).