System Design interview questions

Showing 121–150 of 1311 results

• Design a Team SQL Workbench with Snapshots and Async RunsMedium

  Design a multi-user SQL workbench where analysts co-edit drafts, freeze immutable snapshots, and launch long-running warehouse queries whose results stay traceable to their exact inputs. Tests concurrency control, immutability boundaries, and reliable async execution.

  AnthropicSoftware EngineerSystem DesignOnsite
• Design a Telemetry Pipeline That Handles Inconsistent Metric Names from Old ClientsMedium

  Design a telemetry pipeline that ingests metrics from a large fleet of deployed clients, then handle legacy clients that cannot be updated and report the same metric under inconsistent names. It tests durable ingestion, stream processing and storage design, canonical metric catalogs, version-scoped name mapping and schema evolution.

  AnthropicSoftware EngineerSystem DesignOnsite
• Design a Translation API That Batches Requests on a Fixed ClockHard

  Design a hosted translation API where a GPU worker runs one batch of pending requests every fixed round, and the candidate must derive throughput, batch-closing policy, and failure handling from that one constraint.

  AnthropicSoftware EngineerSystem DesignOnsite
• Design a concurrent web crawlerHard

  An Anthropic system design question: design and implement a concurrent web crawler, from a single-threaded baseline to manual threads, a thread pool and asyncio. It covers the URL frontier, deduplication across workers and redirects, robots.txt and per-host politeness, Retry-After backoff, completion detection, memory sizing, testing and monitoring.

  AnthropicSoftware EngineerSystem DesignTechnical Screen
• Design a distributed web crawlerMedium

  This question tests the ability to design a scalable, fault-tolerant distributed web crawler that handles URL management, distributed coordination, and domain politeness.

  AnthropicSoftware EngineerSystem DesignTechnical Screen
• Design a one-to-one chat systemMedium

  This problem tests your ability to design a scalable, real-time one-to-one messaging system by addressing requirements for message ordering, delivery guarantees, and user presence.

  AnthropicSoftware EngineerSystem DesignTechnical Screen
• Design a prompt playgroundHard

  This question evaluates a candidate's competency in large-scale system design, real-time streaming and prompt execution, multi-tenant data modeling, versioning and collaboration workflows, security and privacy controls, observability and cost tracking, and abuse prevention.

  AnthropicSoftware EngineerSystem DesignOnsite
• Design a prompt-sharing platformMedium

  This question assesses the ability to design a scalable content-sharing platform, focusing on data modeling, efficient retrieval of user-generated prompts, and the handling of concurrent access and permissions.

  AnthropicSoftware EngineerSystem DesignTechnical Screen
• Design a scalable MapReduce pipelineHard

  Design a scalable MapReduce pipeline 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.

  AnthropicMachine Learning EngineerSystem DesignTechnical Screen
• Design a scalable network I/O serviceHard

  This question evaluates a candidate's ability to design a scalable, highly available network I/O backend, testing competencies in distributed systems, storage architecture, CDN and caching integration, API and data model design, capacity planning, failure handling, observability, and security.

  AnthropicSoftware EngineerSystem DesignTechnical Screen
• Design a scalable service and model performanceHard

  This question evaluates a candidate's ability in large-scale distributed system design, performance modeling, capacity planning, and operational reliability for latency-sensitive, multi-region key-value services.

  AnthropicMachine Learning EngineerSystem DesignOnsite
• Design a scalable, reliable systemHard

  The prompt evaluates competence in large-scale distributed system design, covering storage architecture, consistency and replication strategies, caching, APIs and data models, operational reliability, security, and cost/capacity planning.

  AnthropicSoftware EngineerSystem DesignTechnical Screen
• Design an LLM Prompt Playground: Schema, Large Prompts, Sharing and Tiny EditsHard

  A system design interview to build an LLM prompt playground where users write, run, save and share prompts, starting from the database schema. Follow-ups probe storing very large prompts, designing sharing, and handling frequent one- or two-character edits to a large prompt without wasting storage.

  AnthropicSoftware EngineerSystem DesignOnsite
• Design an LLM Request Batcher When Every Batch Costs a Fixed TimeHard

  Design the serving path for a code-completion model whose accelerators run requests in batches. The interviewer says one batch always takes a fixed 250 ms. Tests batching policy, capacity math, latency budgets, routing results back to callers, failure handling, and questioning the fixed-latency assumption.

  AnthropicSoftware EngineerSystem DesignOnsite
• Design distributed median and modeHard

  This question evaluates skills in distributed systems and large-scale analytics, covering data partitioning, streaming and sliding-window processing, quantile and heavy-hitter summarization, fault tolerance, and trade-off analysis for time, space, and network I/O.

  AnthropicSoftware EngineerSystem DesignOnsite
• Design guardrails and fallback for LLM reliabilityHard

  Design an end-to-end safety and reliability middleware layer for a production LLM service, focusing on low-latency input/output guardrails, early streaming interception, multi-tier fallback strategies, and observability.

  AnthropicSoftware EngineerSystem DesignOnsite
• Design production-ready dedup serviceHard

  This question evaluates system design and distributed storage competencies, focusing on scalable file deduplication, content-defined chunking, metadata and index design, multi-tenant architectures, and operational reliability across regions.

  AnthropicSoftware EngineerSystem DesignTechnical Screen
• Distribute 500 GB of Model Weights to 1,000 GPU Workers: Lower Bound and DesignMedium

  Copy 500 GB of model weights to 100 to 1,000 GPU workers whose 10 Gbps links are shared between upload and download. Derive the lower bound on distribution time, evolve a naive fan-out into a chunked peer-to-peer design, and handle stragglers, failures and cutover. It tests bandwidth reasoning and large-scale distribution design.

  AnthropicSoftware EngineerSystem DesignOnsite
• Find a Distributed Mode EfficientlyHard

  Design an exact distributed mode-finding algorithm across partitioned workers that minimizes network I/O, prevents hotspotting, handles deterministic tie-breaking, and contrasts with approximate streaming sketches.

  AnthropicSoftware EngineerSystem DesignOnsite
• Guide and override compiler optimizationsHard

  This question evaluates a candidate's competency in low-level performance engineering and compiler optimization techniques—covering pragmas, intrinsics, manual code transformations, profiling and correctness verification—within the System Design and compiler-aware optimization domain.

  AnthropicSoftware EngineerSystem DesignOnsite
• How to stream a large file to 1000 hosts fastestMedium

  Design a high-throughput distribution system to broadcast a large file (e.g., 100 GB model checkpoint) to 1,000 cluster hosts in minimum time, analyzing network bottlenecks and replication topologies.

  AnthropicSoftware EngineerSystem DesignOnsite
• How would you scale batch image pipelines?Medium

  This problem evaluates your ability to design a distributed, fault-tolerant batch processing system for high-throughput image transformation tasks.

  AnthropicSoftware EngineerSystem DesignTechnical Screen
• Identify and mitigate deduplication program risksHard

  This question evaluates understanding of system design and practical engineering competencies required for building resilient file deduplication tools, covering filesystem semantics, error handling, hashing and collision considerations, concurrency, performance bottlenecks, cross-platform interoperability, and safety trade-offs.

  AnthropicSoftware EngineerSystem DesignTechnical Screen
• Optimize MapReduce performanceMedium

  This question evaluates understanding of the MapReduce programming model and distributed batch processing at scale. It tests practical knowledge of parallel efficiency, network bottleneck analysis, and optimization techniques like combiners, partitioning, and speculative execution — core competencies assessed in machine learning and data engineering roles.

  AnthropicMachine Learning EngineerSystem DesignTechnical Screen
• Optimize a compute kernel with a simulatorHard

  This question evaluates performance engineering and low-level kernel optimization competencies, including profiling, data-layout and instruction-level techniques, correctness verification, and benchmark-driven measurement within the System Design domain.

  AnthropicSoftware EngineerSystem DesignOnsite
• Review a Batched GPU Inference API Design Doc: Flaws, Throughput, Mixed-Model GPUsMedium

  Review a design document for a batched GPU inference API and find its flaws in load balancing, batching, caching, retries and admission control. Then compare theoretical and achievable throughput at 100 ms per batch and 10,000 QPS, and schedule a large and a small model on one 8-GPU pool.

  AnthropicSoftware EngineerSystem DesignOnsite
• Scale crawler with thread poolHard

  This question evaluates system design and concurrent programming competencies, focusing on bounded thread-pool architecture, thread-safe frontier and deduplication structures, per-host politeness and in-flight limits, reliability mechanisms (timeouts, retries, backoff), and graceful shutdown and termination semantics.

  AnthropicSoftware EngineerSystem DesignTechnical Screen
• Schedule instructions on a VLIW pipelineHard

  This question evaluates proficiency in VLIW instruction scheduling, pipeline hazard analysis (RAW/WAR/WAW), register-pressure management, and software-pipelining for loop kernels within the System Design domain of computer architecture and compiler backends.

  AnthropicSoftware EngineerSystem DesignOnsite
• System Design: Pushing a Multi-Terabyte Snapshot to Thousands of NodesMedium

  Figure out the theoretical floor on how fast a large search-index snapshot can reach every node in a fleet given each machine's shared upload/download bandwidth, then design a chunked, peer-assisted distribution scheme that approaches that floor and copes with stragglers and failures. Tests bandwidth reasoning and evolving a design from a naive baseline.

  AnthropicSoftware EngineerSystem DesignOnsite
• Design a Service That Sends a JSON Payload to a URL at a Scheduled TimeMedium

  Design a service that accepts JSON requests containing a target URL, a UTC timestamp and a payload, stores them durably, and sends each payload to its URL at the scheduled time. It tests finding due work at scale, delivery guarantees and retries, isolation from slow endpoints, outbound-request security and failure recovery.

  AnyscaleSoftware EngineerSystem DesignOnsite