System Design interview questions

Showing 331–360 of 1311 results

• Design scalable worker pool for template jobsMedium

  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.

  CrowdstrikeSoftware EngineerSystem DesignTechnical Screen
• Design a Slack-Like Messaging PlatformEasy

  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.

  CrusoeSoftware EngineerSystem DesignOnsite
• Design a metrics monitoring systemHard

  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.

  CurrentSoftware EngineerSystem DesignTechnical Screen
• Design Scalable Notification Rate LimiterMedium

  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).

  CursorBackend EngineerSystem DesignTechnical Screen
• Design Versioned IDE Settings for Users and TeamsMedium

  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.

  CursorSoftware EngineerSystem DesignTechnical Screen
• Design a Durable Cron Job SchedulerMedium

  Design a cron scheduler with durable occurrences, timezone rules, missed-run policies, worker leases, idempotent dispatch, and failure recovery.

  CursorSoftware EngineerSystem DesignTechnical Screen
• Design an in-memory order matching engineHard

  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.

  Da Vinci TradingSoftware EngineerSystem DesignOnline Assessment
• Design Chat APIs, Storage, and Core Message FlowsHard

  Design a highly available and consistent backend chat system focusing on APIs, storage schema, idempotent message publishing, per-conversation sequencing, and versioned group membership.

  DatabricksSoftware EngineerSystem DesignOnsite
• Design Chat APIs, Storage, and Message FlowsMedium

  Design chat APIs and database tables with durable message sends, idempotent retries, ordered history, live delivery, and reconnect recovery.

  DatabricksSoftware EngineerSystem DesignOnsite
• Design Chat Deletion Semantics Under Concurrent SendsMedium

  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.

  DatabricksSoftware EngineerSystem DesignTechnical Screen
• Design KV store with sliding-window QPS metricsMedium

  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.

  DatabricksSoftware EngineerSystem DesignTechnical Screen
• Design Messaging With Message DeletionMedium

  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.

  DatabricksSoftware EngineerSystem DesignOnsite
• Design a Book Price AggregatorMedium

  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.

  DatabricksSoftware EngineerSystem DesignTechnical Screen
• Design a Bookstore Pricing API with Batch FetchesHard

  Tests system design skills for building a high-throughput, contextual pricing service that balances HTTP protocol semantics, batch orchestration, personalized caching, and downstream protection.

  DatabricksSoftware EngineerSystem DesignOnsite
• Design a Chat Application with a Partitioned CacheMedium

  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.

  DatabricksSoftware EngineerSystem DesignTechnical Screen
• Design a Collaborative Playlist EditorMedium

  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.

  DatabricksFrontend EngineerSystem DesignOnsite
• Design a Distributed File SystemMedium

  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.

  DatabricksBackend EngineerSystem DesignTechnical Screen
• Design a Distributed File System, Scoping the Requirements YourselfMedium

  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.

  DatabricksBackend EngineerSystem DesignOnsite
• Design a Durable Concurrent Event WriterHard

  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.

  DatabricksSoftware EngineerSystem DesignOnsite
• Design a Hierarchical File SystemHard

  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.

  DatabricksSoftware EngineerSystem DesignOnsite
• Design a KV store with QPS APIHard

  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.

  DatabricksSoftware EngineerSystem DesignTechnical Screen
• Design a Shared, Crash-Safe Telemetry Buffer for Thousands of Worker ThreadsMedium

  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.

  DatabricksSoftware EngineerSystem DesignOnsite
• Design a Slack-Like Messaging SystemMedium

  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.

  DatabricksSoftware EngineerSystem DesignOnsite
• Design a Thread-Safe Buffered Writer with a Background Flush ThreadMedium

  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.

  DatabricksSoftware EngineerSystem DesignOnsite
• Design a Visa-Style Card Payment Processing SystemMedium

  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.

  DatabricksSoftware EngineerSystem DesignOnsite
• Design a Visa-like payment processing systemHard

  This problem tests your ability to design a high-throughput, fault-tolerant transaction processing system that guarantees data integrity across distributed services.

  DatabricksSoftware EngineerSystem DesignTechnical Screen
• Design a digital game shop backendHard

  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.

  DatabricksSoftware EngineerSystem DesignOnsite
• Design a generic key-value storeMedium

  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.

  DatabricksSoftware EngineerSystem DesignTechnical Screen
• Design a key-value storeHard

  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.

  DatabricksSoftware EngineerSystem DesignOnsite
• Design a single-node persistent in-memory cacheHard

  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.

  DatabricksSoftware EngineerSystem DesignTechnical Screen