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 1–30 of 517 results

  • Abnormal SecurityHardSoftware Engineer
    Design a scalable photo deduplication service

    Design a scalable photo deduplication service 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
  • AbridgeMediumSoftware Engineer
    Design a Secure Medical Audio Pipeline

    This problem tests your ability to design a secure, HIPAA-compliant audio processing pipeline that handles sensitive PHI (Protected Health Information) while ensuring scalability and reliability.

    System DesignTechnical ScreenSecurityHIPAAAsynchronous Processing
  • AddeparMediumSoftware Engineer
    Design a Multi-Region Event Ticketing System

    This question tests the ability to design a highly concurrent distributed system that balances strong consistency for inventory management with high availability for a global, read-heavy user base.

    System DesignTechnical ScreenDistributed SystemsConsistencyScalability
  • AdobeHardSoftware Engineer
    Analyze end-to-end request latency

    An Adobe software-engineer system-design screen on analyzing and optimizing end-to-end web request latency. The strong answer builds a client/network/server latency model, instruments both client (RUM) and server (OpenTelemetry, Server-Timing) with correlated traces, attributes frontend vs. backend time, investigates p95/p99 outliers, and ships layered optimizations behind SLO guardrails.

    System DesignTechnical Screen
  • AdobeHardSoftware Engineer
    Design distributed word count without MapReduce

    This question evaluates a candidate's competency in designing scalable distributed systems and large-scale data processing pipelines, focusing on ingestion, partitioning/sharding, partial aggregation and merging, global top‑K computation, fault tolerance, idempotency, and storage/serving concerns.

    System DesignTechnical Screen
  • AdyenHardSoftware Engineer
    Design scalable LRU cache and backtracking API

    Design scalable LRU cache and backtracking API 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
  • AffirmMediumSoftware Engineer
    Design Installment-Loan Payment Processing

    Design installment-loan payment processing around a bank debit API available during one daily one-hour window. Unify manual and scheduled intents, prevent duplicate debits with durable idempotency and state transitions, reconcile unknown outcomes, apply accounting atomically, and notify through an outbox.

    System DesignTechnical Screen
  • AirbnbHardSoftware Engineer
    Design a fast host listing metrics page

    This question evaluates backend system design and data engineering competencies, including scalable API design, time-range aggregation correctness (handling partial overlaps and state changes), data modeling and indexing, caching and precomputation, and performance validation.

    System DesignTechnical Screen
  • AirbnbHardSoftware Engineer
    Design a multi-channel notification system

    This question tests the ability to design a distributed, multi-channel notification system capable of handling high throughput, varying latency requirements across channels (e.g., email, push, SMS), and ensuring reliable message delivery.

    System DesignTechnical ScreenDistributed SystemsScalabilityMessage Queues
  • AirbnbHardSoftware Engineer
    Design an Airbnb wallet with holds and payouts

    This question evaluates a candidate's competency in designing financial transaction systems, covering double-entry append-only ledgers, holds/authorizations and captures, refunds and payouts, multi-currency FX conversion and rounding, idempotency, concurrency safety, and auditable reconciliation.

    System DesignTechnical Screen
  • AirbnbMediumSoftware Engineer
    Design and implement an Airbnb wallet

    This question evaluates system design and object-oriented design skills focused on transactional accounting, escrow-based payment flows, idempotency, and robust error handling, plus the ability to produce a runnable in-memory implementation.

    System DesignTechnical Screen
  • AirwallexMediumSoftware Engineer
    Design a High-Demand Ticketing System

    Design a ticketing system for high-demand events. Connect requirements and APIs to data modeling, consistency, scaling, failure recovery, observability, and the important design trade-offs.

    System DesignTechnical Screen
  • AirwallexMediumSoftware Engineer
    Design a Large-File Analysis Report System

    Tests system design skills in architecting a secure, multi-tenant pipeline for large file ingestion and asynchronous batch analytics with resumable uploads and idempotent job processing.

    System DesignTechnical ScreenObject StorageDistributed SystemsIdempotency
  • AirwallexMediumFrontend Engineer
    Design a Reusable React Autocomplete Input: API, Portals, Debounce and Caching

    Design a reusable autocomplete search input for a React application on top of an existing search API. The discussion covers the API contract with pagination and limits, the component and portal architecture, throttling versus debouncing, client-side result caching strategies, and the public props and exports.

    System DesignTechnical Screen
  • Akuna CapitalHardSoftware Engineer
    Design an order-matching engine

    This question evaluates a candidate's ability to design a high-throughput, low-latency in-memory limit order-matching engine, testing competencies in data structure selection, algorithmic complexity, deterministic concurrency, API design, and handling domain-specific constraints such as self-trade prevention.

    System DesignTechnical Screen
  • AlibabaMediumSoftware Engineer
    Idempotent Kafka Consumer: Duplicate Writes, Offset Commits and a Second Database

    A backend design discussion on making a concurrent Kafka consumer idempotent: how to stop duplicate effects when the same message is processed twice, whether a duplicate write should throw or return the existing data, how offsets keep advancing, and how to keep a second database consistent when publishing fails.

    System DesignTechnical Screen
  • AltruistHardSoftware Engineer
    Design scalable rate limiter with token bucket

    This question evaluates understanding of rate-limiting algorithms and scalability concepts, specifically comparing sliding-window and token-bucket approaches with attention to lazy refill, per-client state modeling, memory efficiency, concurrency, and extendability to distributed systems.

    System DesignTechnical Screen
  • AmazonMediumSoftware Engineer
    Accept Notification Bursts With Low Latency

    Design a high-throughput, low-latency notification ingestion and delivery service capable of absorbing sudden 10x traffic spikes while maintaining strict delivery SLOs and downstream rate limits.

    System DesignTechnical ScreenDistributed SystemsMicroservicesMessage Queues
  • AmazonMediumSoftware Engineer
    Architect an AI Chatbot for Enterprise Users

    This question tests your ability to design a scalable, enterprise-grade AI chatbot system that handles high throughput, ensures data privacy, and integrates with existing business data stores.

    System DesignTechnical ScreenRAGScalabilityAccess Control
  • AmazonMediumSoftware Engineer
    Design Human Avoidance for Warehouse Robots

    This problem evaluates your ability to design a real-time sensor-to-actuator pipeline for an autonomous robot, focusing on latency, sensor fusion, and safety-critical path adjustments.

    System DesignTechnical ScreenRoboticsSensor FusionReal-time Systems
  • AmazonHardSoftware Engineer
    Design VPC, IP plan, management, storage, SSO

    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 VPC, IP plan, management, storage, SSO states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

    System DesignTechnical Screen
  • AmazonMediumSoftware Engineer
    Design a Kafka-Based File Watcher for Millions of Files

    Design a Kafka file watcher for millions of files with source sharding, durable events, per-file ordering, missed-event reconciliation, and version-aware reads.

    System DesignTechnical Screen
  • AmazonHardSoftware Engineer
    Design a Library Management System (API and Schema)

    This problem evaluates your ability to design a schema and API for a transactional library system, focusing on handling concurrent checkouts and maintaining data integrity in a read-heavy environment.

    System DesignTechnical ScreenDatabase ModelingConcurrencyREST API
  • AmazonMediumSoftware Engineer
    Design a Multi-Branch Library Lending System

    This problem tests the ability to design a distributed inventory and reservation system, focusing on concurrency control, transaction integrity across branches, and fault-tolerant service communication.

    System DesignTechnical ScreenConcurrencyDistributed SystemsInventory
  • AmazonMediumSoftware Engineer
    Design a Perishable-Goods Inventory and Location Tracking System

    This question tests the ability to design a distributed inventory system that handles high-frequency location updates and strict FIFO/expiry logic for perishable goods.

    System DesignTechnical ScreenGeo-spatialScalabilityDatabase Modeling
  • AmazonEasySoftware Engineer
    Design a Scalable News Feed

    This problem evaluates your ability to design a feed generation architecture, specifically comparing push vs. pull models for users with varying follower counts.

    System DesignTechnical ScreenCachingScalabilityDatabases
  • AmazonHardSoftware Engineer
    Design a cloud database write path and recovery

    This question tests the ability to architect a distributed database write path that decouples compute from storage, specifically focusing on how to maintain ACID properties during failures.

    System DesignTechnical ScreenDistributed SystemsDatabasesDurability
  • AmazonHardSoftware Engineer
    Design a keyboard and mouse input system

    An Amazon software-engineer system-design screen: design a system that captures keyboard and mouse events and reconstructs exactly what the user typed. It tests low-latency event capture, total ordering across multiple devices, IME/composition and grapheme-safe text reconstruction, mouse selection and clipboard/undo-redo, plus durable persistence with deterministic crash-safe replay.

    System DesignTechnical Screen
  • AmazonMediumSoftware Engineer
    Design a large-scale temperature sensor system

    This question tests your ability to design a high-throughput data ingestion pipeline and storage architecture for a fleet of IoT sensors, focusing on write-heavy scalability and time-series query performance.

    System DesignTechnical ScreenTime-SeriesScalabilityDistributed Systems
  • AmazonHardSoftware Engineer
    Design a log filtering and analytics service

    An Amazon software engineer system design question: design a log filtering and analytics service that ingests high-volume application logs and supports attribute/substring filtering, error counts over a time window, and hourly histograms by pattern or ID. It tests ingestion API design, dual search + OLAP storage with hourly rollups, schema and indexing, late/duplicate-event handling, partitioning and retention, and correctness-vs-latency trade-offs with complexity analysis.

    System DesignTechnical Screen