Katkat

Topic

System Design interview questions

1311 System Design questions from 230 companies, with hints, runnable code and solution walkthroughs.

Questions1311

60 easy819 medium432 hard

Your progress0/1311

System Design interview questions by the numbers

Last updated

Katkat has 1,311 System Design interview questions from 230 companies; the most come from OpenAI (8%), Meta (5%) and Amazon (4%). By difficulty: 5% easy, 62% medium and 33% hard. The most common round is Onsite (55%). Frequent concepts include System Design, Distributed Systems, Scalability and Caching.

Companies (230)

Difficulty

  • Easy5% · 60
  • Medium62% · 819
  • Hard33% · 432

Interview rounds

  • Onsite55% · 721
  • Technical Screen39% · 517
  • Online Assessment3% · 38
  • Other2% · 21
  • HR Screen1% · 13

Roles

  • Software Engineer91% · 1189
  • Machine Learning Engineer2% · 31
  • Data Engineer2% · 26
  • Backend Engineer2% · 25
  • Frontend Engineer1% · 19

Frequent concepts

  • System Design31% · 400
  • Distributed Systems24% · 316
  • Scalability15% · 196
  • Caching7% · 95
  • Concurrency7% · 91
  • system-design6% · 83

Showing 841–870 of 1311 results

  • This question evaluates a candidate's ability to design scalable, secure, real-time messaging systems, testing competencies in distributed systems, data modeling, API design, storage and sharding strategies, search indexing, and notification delivery.

    OpenAISoftware EngineerSystem DesignTechnical Screen
  • This question tests the ability to design a global, multi-tenant messaging platform that handles high-concurrency real-time delivery, data isolation, and low-latency synchronization across distributed environments.

    OpenAISoftware EngineerSystem DesignOnsite
  • This system design question tests a candidate's ability to architect asynchronous, distributed job-orchestration pipelines at scale. It evaluates practical knowledge of durable queues, state machines, reliability patterns like the outbox and idempotency, and trade-offs between throughput and latency in GPU-constrained systems.

    OpenAISoftware EngineerSystem DesignTechnical Screen
  • An OpenAI software-engineering system design interview question: design a production-grade CI/CD pipeline for a large microservices monorepo, end to end. It spans source-control triggers, build and artifact management, layered testing with flaky-test handling, progressive deployment and rollback, observability, supply-chain security, and — the differentiator — the job scheduler that orchestrates pipeline steps (DAG modeling, concurrency, priorities, retries, caching, rate limiting) plus its data stores, queues, APIs, schemas, multi-tenant fairness, KPIs/SLOs, and failure handling.

    OpenAISoftware EngineerSystem DesignTechnical Screen
  • This question tests the ability to design a distributed job orchestration system that handles task dependencies, secure execution, and low-latency log streaming at scale.

    OpenAISoftware EngineerSystem DesignTechnical Screen
  • This problem tests your ability to design a distributed job scheduling and orchestration system that handles process failures, network partitions, and job timeouts to ensure reliable execution in a high-scale environment.

    OpenAISoftware EngineerSystem DesignOnsite
  • Design the serving system for a chat assistant built on a large language model: stream replies token by token, rate-limit a free tier alongside paid users, schedule requests onto GPUs efficiently, and meet latency targets. It tests streaming protocols, batching, GPU memory limits, rate limiting and overload handling.

    OpenAISoftware EngineerSystem DesignOnsite
  • This problem evaluates your ability to design a performant, scalable front-end architecture for a real-time conversational AI interface, focusing on state management, streaming data handling, and network resilience.

    OpenAISoftware EngineerSystem DesignTechnical Screen
  • This question evaluates a candidate's ability to design scalable, secure cloud development platforms, testing competencies in distributed systems architecture, orchestration and scheduling, storage and persistence, multi-tenancy and RBAC, runtime isolation, and operational observability.

    OpenAISoftware EngineerSystem DesignTechnical Screen
  • Design a secure, multi-tenant cloud development environment platform that provisions isolated compute instances, supports low-latency interactive editing, and reliably persists workspace state across disconnects.

    OpenAISoftware EngineerSystem DesignTechnical Screen
  • Design a cloud development environment platform, like an online IDE, where developers open a repository in a hosted workspace with a browser editor, a terminal and forwarded ports, then stop and resume it later. It tests sandbox isolation, workspace storage, fast startup, secure connectivity and cost control.

    OpenAISoftware EngineerSystem DesignTechnical Screen
  • Design a cloud IDE in which developers edit and run code and use a terminal in the browser while their files and execution environments live on remote servers. It tests workspace lifecycle and cold starts, isolation of untrusted code, durable file storage, real-time editor and terminal channels, host scheduling, and failure handling at scale.

    OpenAISoftware EngineerSystem DesignOnsite
  • A system design question about building a cloud IDE in which developers get SSH access to remote development hosts, and a host can be used by one person or shared by several. It tests host lifecycle management, connection routing through a gateway, workspace persistence, multi-user access control and isolation.

    OpenAISoftware EngineerSystem DesignTechnical Screen
  • Design a scalable, content-addressed photo storage service with cryptographic verification, resumable chunked uploads, reference-counted deduplication, and protections against unauthorized hash-probing attacks.

    OpenAISoftware EngineerSystem DesignTechnical Screen
  • This question tests the ability to design a low-latency, scalable architecture for an LLM-based conversational assistant capable of handling concurrent user requests and streaming responses.

    OpenAISoftware EngineerSystem DesignTechnical Screen
  • System design question asking you to design a devbox service that gives engineers on-demand remote development environments. It tests scoping requirements before architecture, the devbox lifecycle, fast provisioning, persistent workspaces, idle cost control, isolation, connectivity and failure recovery.

    OpenAISoftware EngineerSystem DesignTechnical Screen
  • Design a high-scale game distribution platform covering reliable payment and entitlement tracking, content-addressed binary chunk distribution, offline license leasing, and canary rollouts.

    OpenAISoftware EngineerSystem DesignTechnical Screen
  • A system design interview question asking you to design a digital game store and distribution platform like Steam, covering the catalog, purchases, player libraries, and game downloads and updates. It tests content delivery for very large builds, entitlement consistency with payments, and handling traffic spikes during sales and launches.

    OpenAISoftware EngineerSystem DesignOnsite
  • This problem tests your ability to design a distributed system capable of solving large-scale constraint satisfaction problems (crossword puzzles) by partitioning search spaces and managing state across workers.

    OpenAISoftware EngineerSystem DesignOnsite
  • Tests your ability to architect a scalable, low-latency distributed rate limiter capable of enforcing multi-dimensional limits (such as requests per minute and tokens per minute) across distributed services.

    OpenAISoftware EngineerSystem DesignTechnical Screen
  • Design the backend for a SaaS image-upscaling API where every job runs on exactly one accelerator and a scheduler must divide a shared fleet across many paying customers, testing job-store design, weighted scheduling by accelerator-time rather than job count, and recovery from worker, accelerator, and scheduler failures.

    OpenAISoftware EngineerSystem DesignOnsite
  • This problem tests your ability to design a stateful, fault-tolerant system where move ordering, clock synchronization, and session persistence are critical for game integrity.

    OpenAISoftware EngineerSystem DesignTechnical Screen
  • This question tests the ability to design a distributed, asynchronous system capable of handling long-running, resource-intensive tasks while ensuring idempotency and fault tolerance in the event of partial component failure.

    OpenAISoftware EngineerSystem DesignTechnical Screen
  • Sketch an end-to-end metrics pipeline for a large service fleet, then choose one or two components — cardinality control, storage layout, or alert evaluation — and design them in real depth.

    OpenAISoftware EngineerSystem DesignTechnical Screen
  • This question evaluates system-design and engineering competencies for building a multi-tenant LLM chat web application, covering real-time token streaming, snapshot/versioned data modeling, full-text and metadata search, API and schema design, role-based sharing, security, and frontend state management.

    OpenAISoftware EngineerSystem DesignTechnical Screen
  • This problem tests the ability to design a high-throughput, fault-tolerant distributed system that bridges external payment processors with internal ledger state management.

    OpenAISoftware EngineerSystem DesignOnsite
  • Start with a minimal stateless conversational AI endpoint that streams responses, then evolve it for scale and resilience. Cover safety and authorization, cancellation, admission control, backpressure, dependency failures, regional isolation, durable history, and metrics that separate serving issues from model issues.

    OpenAISoftware EngineerSystem DesignOnsite
  • This question tests the ability to design a scalable, low-latency infrastructure for hosted interactive notebooks, focusing on container orchestration, state persistence, and session management.

    OpenAISoftware EngineerSystem DesignTechnical Screen
  • Design an end-to-end streaming architecture for an AI product feature serving millions of concurrent users. The focus is on low-latency token streaming, connection lifecycle management, data persistence, and graceful failure recovery.

    OpenAISoftware EngineerSystem DesignOnsite
  • Design a real-time game in which up to ~150 players per arena solve timed puzzle rounds, the wrong and slowest are knocked out each round, and large audiences watch live standings. Tests partitioning by arena, authoritative timing, mid-round failover, and isolating spectator fan-out from gameplay.

    OpenAISoftware EngineerSystem DesignOnsite

More topics