Katkat

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 181–210 of 517 results

  • DuolingoHardSoftware Engineer
    Design Animal Chess game classes

    This interview question evaluates requirements, scale assumptions, API/data design, architecture, trade-offs, failure modes, and rollout in a realistic interview setting. A strong answer for Design Animal Chess game classes states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

    System DesignTechnical Screen
  • EngelhartMediumSoftware Engineer
    Design a Daily Weather-Forecast Pipeline That Runs Power Models for Energy Traders

    Design a pipeline that ingests a weather forecast CSV published daily at a variable time, validates and stores it, runs black-box demand, wind, solar, hydro and price models across every scenario, and serves aggregated forecasts to traders. It tests scheduling, DAG design, failure handling, dashboard delivery and scaling to thousands of scenarios.

    System DesignTechnical Screen
  • ExpediaHardSoftware Engineer
    Design a listing connectivity ingestion service

    This question evaluates a candidate's ability to design scalable, reliable REST APIs and distributed ingestion pipelines, testing competencies in API specification, idempotency, authentication/authorization, asynchronous processing, observability, and integration with downstream validation services.

    System DesignTechnical Screen
  • FigmaMediumSoftware Engineer
    Design Comments for a Collaborative Whiteboard

    Design a real-time, durable commenting system for an infinite collaborative whiteboard where comments attach to dynamic canvas objects or fixed coordinates.

    System DesignTechnical ScreenReal-Time SystemsWebSocketsData Modeling
  • FigmaMediumSoftware Engineer
    Design Real-Time Collaborative Comments

    Prepare for a real-time collaborative comments system design prompt for shared documents or canvases. The question covers durable comment writes, WebSocket fanout, reconnect backfill, ordering, permissions, hot-document scaling, and missed-update recovery.

    System DesignTechnical Screen
  • FigmaMediumSoftware Engineer
    Design Trending Collaborative Files

    This problem tests the ability to design a distributed streaming architecture that aggregates real-time user activity while maintaining strict privacy and performance requirements.

    System DesignTechnical ScreenStream ProcessingScalabilityDistributed Systems
  • FigureaiMediumData Engineer
    Build a Firmware Data Quality and Release-Feedback Framework

    This question tests the ability to design an end-to-end data pipeline architecture that ensures high-fidelity telemetry collection, automated quality validation, and safe release orchestration for embedded firmware devices.

    System DesignTechnical ScreenData EngineeringFirmwareObservability
  • FigureaiMediumData Engineer
    Design a Telemetry Platform Ingesting Two Gigabytes per Second

    This question tests your ability to design a high-throughput, fault-tolerant telemetry ingestion pipeline capable of handling high-velocity data streams from distributed robotic systems.

    System DesignTechnical ScreenData EngineeringScalabilityDistributed Systems
  • FivetranEasySoftware Engineer
    Design a Simplified WhatsApp: Message Send and Receive, Schema, and Scaling

    Design a simplified WhatsApp focused on sending and receiving messages: the online and offline delivery flow, client APIs, the database schema, and scaling. It tests connection routing, delivery guarantees and ordering, and a choice between relational and NoSQL storage justified by access patterns.

    System DesignTechnical Screen
  • FlipsterEasySoftware Engineer
    Design 64-bit distributed IDs and a parking lot

    The question evaluates distributed-systems and scalability competencies for globally unique 64-bit ID generation (including sharding, time-ordering, fault tolerance and clock issues) as well as object-oriented design, concurrency control, API design, and data modeling for a parking lot backend.

    System DesignTechnical Screen
  • FluidstackMediumSoftware Engineer
    Design a Distributed Job Scheduler for One-Off and Recurring Jobs

    A system design question asking you to design a distributed job scheduler that runs jobs immediately, at a set time or on a recurring cron schedule across a pool of workers. It tests how you find due jobs at scale, prevent duplicate runs, recover from worker failures, and handle retries, bursts and missed runs.

    System DesignTechnical Screen
  • Fora TravelMediumSoftware Engineer
    Design Radius-Based Notifications from Mobile Locations

    Tests the ability to design an end-to-end location ingestion and geo-fenced notification system, focusing on spatial indexing, staleness filtering, scalable fan-out, and hotspot mitigation.

    System DesignTechnical Screensystem-designgeospatialdistributed-systems
  • FordMediumSoftware Engineer
    Design EV Telemetry Monitoring App

    This question evaluates skills in designing real-time telemetry systems, including vehicle data collection and transmission, backend ingestion and validation, API and frontend design, operational controls for per-vehicle data flow, and the incorporation of AI-assisted development into the engineering process.

    System DesignTechnical Screen
  • Garner HealthMediumSoftware Engineer
    Design a Concurrent Appointment Booking System

    Design a concurrent healthcare appointment scheduling system that prevents double booking, supports fast availability searches, and ensures reliable notifications and state auditability.

    System DesignTechnical Screensystem-designconcurrencydistributed-systems
  • Garner HealthMediumSoftware Engineer
    Design a Doctor Appointment Booking System for Sudden Demand

    Design a doctor appointment system with searchable availability, atomic booking, cancellation, and protection against double booking. The follow-up examines a vaccine-demand spike through waiting-room admission, fairness, throttling, hot-slot partitioning, caching, autoscaling, load shedding, and reconciliation.

    System DesignTechnical Screen
  • GeneralmotorsMediumSoftware Engineer
    Choose Between a Monolith, Microservices, and a Modular Architecture

    Compare monolithic and service-based architectures and plan incremental extraction or consolidation around domain boundaries, data ownership, and measured goals.

    System DesignTechnical Screen
  • GoogleMediumSoftware Engineer
    Design A Drive-Style Usage Quota Limiter

    Design a distributed storage quota accounting and enforcement service for a cloud drive platform that handles concurrent multi-part uploads, deletions, retries, and usage drift reconciliation.

    System DesignTechnical ScreenDistributed SystemsCloud StorageConcurrency
  • GoogleMediumSoftware Engineer
    Design a Security Monitoring Framework

    Design a scalable, low-overhead security monitoring framework capable of capturing OS-level events via eBPF across a massive cloud fleet, streaming telemetry, and detecting malicious activity in near-real-time.

    System DesignTechnical ScreenSecurityeBPFStreaming
  • GoogleHardSoftware Engineer
    Design a Task Scheduler for Opaque Long-Running GPU Jobs ("Design Sora")

    This question tests your ability to design a distributed job scheduler and execution engine for long-running, compute-intensive GPU workloads. It evaluates distributed system fundamentals including multi-tenant fairness, gang scheduling, node failure recovery, and resource utilization.

    System DesignTechnical ScreenDistributed SystemsGPU SchedulingResource Management
  • GoogleHardSoftware Engineer
    Design a key-value store

    This question tests the ability to design a distributed, scalable, and fault-tolerant key-value store while addressing challenges related to data distribution, consistency, and storage engine implementation.

    System DesignTechnical ScreenDistributed SystemsStorageScalability
  • GoogleHardSoftware Engineer
    Design a prioritized log manager with eviction

    Design a prioritized log manager with eviction 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
  • GoogleMediumSoftware Engineer
    Design at-least-once notification delivery

    This question evaluates expertise in reliable distributed systems design, including at-least-once delivery semantics, idempotency and deduplication strategies, retry and dead-letter handling, API and message-schema design, ordering and out-of-order handling, and scalability for high-throughput multi-tenant notification platforms.

    System DesignTechnical Screen
  • GoogleHardSoftware Engineer
    Design deduplicated file storage on filesystem

    This question evaluates system design and storage engineering competencies, including multi-tenant isolation, authentication and authorization models, content-addressable storage and deduplication, reference counting and garbage collection, concurrency control, API surface design, and scaling across nodes using only filesystem primitives.

    System DesignTechnical Screen
  • GoogleHardSoftware Engineer
    Design distributed log storage service

    This question evaluates a candidate's expertise in designing distributed storage systems, covering partitioned append-only logs, high-throughput writes and reads, replication, retention, indexing, compaction, leader/follower roles, and recovery mechanisms.

    System DesignTechnical Screen
  • GoogleHardSoftware Engineer
    Design distributed transactions protocol

    This question evaluates a candidate's understanding of distributed transactions, coordination protocols, fault tolerance, consistency, and reliability across microservices and databases.

    System DesignTechnical Screen
  • GoogleHardSoftware Engineer
    Design executable notebook service APIs

    This question evaluates a candidate's competence in designing secure, scalable systems for executing user-supplied code, covering API design, sandboxing and isolation, dependency management, resource limits, scheduling, and streaming proxies for logs/results.

    System DesignTechnical Screen
  • GoogleHardSoftware Engineer
    Design high-throughput event subscription system

    This question evaluates a candidate's ability to design scalable, fault-tolerant event ingestion and subscription architectures, covering distributed systems, high-throughput messaging, content-based filtering, multi-tenant isolation, API/webhook design, delivery semantics, backpressure, sharding, security, and operational observability.

    System DesignTechnical Screen
  • GoogleHardSoftware Engineer
    Design key management service

    This question evaluates system design and security competencies—specifically cryptographic key lifecycle management, HSM integration, access control, auditing, multi-tenant isolation, and scalability—within the System Design domain.

    System DesignTechnical Screen
  • GoogleMediumSoftware Engineer
    Design nearest-available-taxi lookup with updates

    This question assesses the ability to design a high-concurrency geospatial system that maintains real-time state for moving entities and supports low-latency queries.

    System DesignTechnical ScreenGeospatialScalabilityCaching
  • GoogleHardSoftware Engineer
    Design quota enforcement for high concurrency

    This question evaluates a candidate's understanding of distributed system design and engineering competencies related to quota enforcement, high-throughput rate limiting, consistency models, sharding, and concurrency control under very high QPS.

    System DesignTechnical Screen