practice a little every day, paws crossed ♡
System Design Interview Questions
Practice 9403 coding, system design and machine learning questions from 546 companies, sorted by role, topic and interview round. Every question has step-by-step hints, a code runner that supports 8 languages and an AI mentor; members also get the full solution walkthrough.
- 9403
- Questions
- 546
- Companies
- 11
- Topics
- 8
- Languages
Showing 331–360 of 1311 results
- CrowdstrikeMediumSoftware EngineerDesign scalable worker pool for template jobs
This question evaluates a candidate's competency in designing scalable, concurrent backend systems, covering distributed worker pools, producer–consumer patterns, queuing, load balancing, fault tolerance, backpressure, and domain-specific considerations like template parsing and caching.
System DesignTechnical Screen - CrusoeEasySoftware EngineerDesign a Slack-Like Messaging Platform
Design a real-time team messaging platform supporting channels, direct messages, message persistence, and presence tracking. The design tests your ability to model conversations, ensure reliable and ordered message delivery, and handle high-throughput fan-out.
System DesignOnsiteDistributed SystemsWebSocketsPub/Sub - CurrentHardSoftware EngineerDesign a metrics monitoring system
Design a metrics monitoring system evaluates requirements, scale assumptions, API/data design, architecture, trade-offs, failure modes, and rollout in a realistic interview setting. A strong answer states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.
System DesignTechnical Screen - CursorMediumBackend EngineerDesign Scalable Notification Rate Limiter
This question evaluates expertise in designing distributed rate-limiting systems with hierarchical quotas, focusing on concurrency control, exact rolling-window counting, and correctness under concurrent stateless servers; it belongs to the System Design domain and tests practical application of distributed systems, storage, and API design as well as conceptual understanding of atomicity and consistency. It is commonly asked to assess reasoning about atomic decision-making across multiple scopes, scalability and partitioning strategies, handling reconfiguration and operational concerns, and the trade-offs between correctness and system performance (English).
System DesignTechnical Screen - CursorMediumSoftware EngineerDesign Versioned IDE Settings for Users and Teams
Design a distributed, hierarchical configuration management service for an IDE that synchronizes versioned settings across individual users, multiple teams, and workspaces while supporting offline modifications and deterministic conflict resolution.
System DesignTechnical ScreenDistributed SystemsOffline SyncData Modeling - CursorMediumSoftware EngineerDesign a Durable Cron Job Scheduler
Design a cron scheduler with durable occurrences, timezone rules, missed-run policies, worker leases, idempotent dispatch, and failure recovery.
System DesignTechnical Screen - Da Vinci TradingHardSoftware EngineerDesign an in-memory order matching engine
Matching engine design guide for an in-memory order book. Covers price-time priority, limit and market orders, matching rules, data-structure choices, edge cases, and how to explain tradeoffs in a system design interview.
System DesignOnline Assessment - DatabricksHardSoftware EngineerDesign Chat APIs, Storage, and Core Message Flows
Design a highly available and consistent backend chat system focusing on APIs, storage schema, idempotent message publishing, per-conversation sequencing, and versioned group membership.
System DesignOnsiteDistributed SystemsStorageAPIs - DatabricksMediumSoftware EngineerDesign Chat APIs, Storage, and Message Flows
Design chat APIs and database tables with durable message sends, idempotent retries, ordered history, live delivery, and reconnect recovery.
System DesignOnsite - DatabricksMediumSoftware EngineerDesign Chat Deletion Semantics Under Concurrent Sends
Design the data consistency, concurrency control, and deletion semantics for a distributed chat platform when message creation and thread deletion occur concurrently across distributed nodes.
System DesignTechnical ScreenDistributed SystemsConcurrencyData Consistency - DatabricksMediumSoftware EngineerDesign KV store with sliding-window QPS metrics
This question tests the ability to design an in-memory key-value store that supports basic operations while maintaining accurate sliding-window QPS (queries per second) metrics.
System DesignTechnical ScreenConcurrencyData StructuresMetrics - DatabricksMediumSoftware EngineerDesign Messaging With Message Deletion
Design real-time messaging with conversations, history, and deletion that converges across storage layers and online or offline clients. Clarify authorization and retention, then address duplicate events, edit/reaction races, search and attachment cleanup, reconnect behavior, regional failover, audits, and strict erasure.
System DesignOnsite - DatabricksMediumSoftware EngineerDesign a Book Price Aggregator
Tests the ability to architect a resilient aggregation system interfacing with heterogeneous, unreliable third-party APIs under strict latency, rate-limiting, and cache consistency constraints.
System DesignTechnical Screensystem-designdistributed-systemscaching - DatabricksHardSoftware EngineerDesign a Bookstore Pricing API with Batch Fetches
Tests system design skills for building a high-throughput, contextual pricing service that balances HTTP protocol semantics, batch orchestration, personalized caching, and downstream protection.
System DesignOnsiteAPI DesignCachingMicroservices - DatabricksMediumSoftware EngineerDesign a Chat Application with a Partitioned Cache
Design an end-to-end direct and small-group messaging system with strict delivery guarantees, message ordering, and an explicitly partitioned multi-tier caching layer.
System DesignTechnical ScreenDistributed CachingReal-Time MessagingData Partitioning - DatabricksMediumFrontend EngineerDesign a Collaborative Playlist Editor
Tests your ability to architect a real-time collaborative frontend application, focusing on client-side state synchronization, deterministic list ordering, idempotent mutation protocols, and graceful network reconnection.
System DesignOnsiteFrontendReal-TimeData Modeling - DatabricksMediumBackend EngineerDesign a Distributed File System
This question tests the ability to design a scalable, fault-tolerant distributed file system by addressing challenges in metadata management, data chunking, and cluster availability.
System DesignTechnical ScreenDistributed SystemsStorageScalability - DatabricksMediumBackend EngineerDesign a Distributed File System, Scoping the Requirements Yourself
Design a distributed file system from a one-line prompt, driving the scoping of workload, semantics, scale and durability yourself. Tests separating metadata from data, block replication and placement, read and write paths, failure recovery, and scaling the namespace for a staff-level backend role.
System DesignOnsite - DatabricksHardSoftware EngineerDesign a Durable Concurrent Event Writer
Design a high-throughput, thread-safe embedded log writer that safely batches and persists records from thousands of concurrent producer threads into an append-only file.
System DesignOnsiteStorage SystemsConcurrencyWrite-Ahead Log - DatabricksHardSoftware EngineerDesign a Hierarchical File System
This question tests the ability to design a distributed file system namespace capable of handling millions of files and directories with strong consistency and high availability.
System DesignOnsiteDistributed SystemsMetadataScalability - DatabricksHardSoftware EngineerDesign a KV store with QPS API
This question tests the ability to design a distributed key-value store architecture that incorporates observability, specifically tracking per-key or per-prefix Queries Per Second (QPS) metrics in real-time.
System DesignTechnical ScreenDistributed SystemsObservabilityCaching - DatabricksMediumSoftware EngineerDesign a Shared, Crash-Safe Telemetry Buffer for Thousands of Worker Threads
Design a single, thread-shared component that lets up to 4,000 worker threads inside one process append small telemetry records to one local file, durably and without a disk sync per call. Tests group-commit concurrency design, a crash-safe on-disk record format, and backpressure reasoning.
System DesignOnsiteconcurrencydurabilitysystem-design - DatabricksMediumSoftware EngineerDesign a Slack-Like Messaging System
Tests your ability to architect a scalable, real-time messaging platform like Slack, focusing on connection handling, fan-out delivery, channel message ordering, and presence management.
System DesignOnsiteDistributed SystemsWebSocketsPub/Sub - DatabricksMediumSoftware EngineerDesign a Thread-Safe Buffered Writer with a Background Flush Thread
Tests the ability to design a high-throughput, thread-safe buffering system that decouples client write operations from high-latency storage I/O using concurrent synchronization, backpressure, and background worker threads.
System DesignOnsiteConcurrencyMultithreadingI/O - DatabricksMediumSoftware EngineerDesign a Visa-Style Card Payment Processing System
Design a Visa-style card payment system, choosing between the card network and a merchant-side scope. Tests real-time authorization routing to issuers, idempotent handling of retries and reversals, clearing and settlement with an auditable ledger, fraud checks, and multi-region availability.
System DesignOnsite - DatabricksHardSoftware EngineerDesign a Visa-like payment processing system
This problem tests your ability to design a high-throughput, fault-tolerant transaction processing system that guarantees data integrity across distributed services.
System DesignTechnical ScreenDistributed SystemsConsistencyPayments - DatabricksHardSoftware EngineerDesign a digital game shop backend
This question tests your ability to design a distributed, fault-tolerant transaction processing system for a digital storefront, focusing on data consistency and concurrency control.
System DesignOnsiteDistributed SystemsConcurrencyDatabase - DatabricksMediumSoftware EngineerDesign a generic key-value store
This question evaluates a software engineer's ability to design a clean, type-safe API for a generic key-value store, covering data modeling, interface design, and extensibility. It tests practical software design skills including generics, error handling, concurrency, and the ability to evolve an in-memory prototype into a persistent implementation without breaking callers.
System DesignTechnical Screen - DatabricksHardSoftware EngineerDesign a key-value store
This question evaluates understanding of durable storage and crash-consistency, including on-disk data layout, filesystem durability semantics, concurrency control, and performance trade-offs for single-node embeddable key–value engines.
System DesignOnsite - DatabricksHardSoftware EngineerDesign a single-node persistent in-memory cache
This question evaluates a candidate's skills in single-node cache design, including in-memory key/value storage, eviction policy management (e.g., LRU), durability considerations, concurrency control, and techniques for reducing contention such as sharding or striping.
System DesignTechnical Screen
Crowdstrike
Cursor
Databricks