Anthropic interview questions

Showing 61–90 of 225 results

• Design a Collaborative Prompt PlaygroundMedium

  Design a collaborative prompt playground with conflict-aware editing, immutable versions, asynchronous model runs, and reliable input and result provenance.

  AnthropicSoftware EngineerSystem DesignOnsite
• Design a Concurrent Image Processing ServiceHard

  Design a resilient, distributed image-processing pipeline that safely scales from a single worker to hundreds of concurrent nodes while guaranteeing job lease safety, idempotent output writes, and clean cancellation.

  AnthropicSoftware EngineerSystem DesignOnsite
• Design a Crash-Resilient LRU CacheHard

  This question evaluates a candidate's competency in designing a crash-resilient LRU cache, including which data and ordering must be persisted, durability and recovery concerns, and trade-offs between latency and persistence.

  AnthropicSoftware EngineerSystem DesignTechnical Screen
• Design a Distributed Rate LimiterMedium

  Tests the candidate's ability to design a low-latency, highly available distributed rate-limiting service that coordinates shared state across geographically distributed API gateways while gracefully handling network partitions and datastore failures.

  AnthropicSoftware EngineerSystem DesignOnsite
• Design a Double Descent ExperimentMedium

  Tests your ability to design a controlled synthetic experiment demonstrating double descent, explain the mathematical causes of test error divergence near the interpolation threshold, and analyze the interplay between noise, conditioning, and regularization.

  AnthropicMachine Learning EngineerMachine LearningHR Screen
• Design a Dynamically Batched Inference APIHard

  Design a scalable, multi-tenant LLM inference serving platform that balances Time-to-First-Token (TTFT) and throughput using dynamic iteration-level batching, KV cache memory management, and strict admission control.

  AnthropicMachine Learning EngineerSystem DesignOnsite
• Design a GPU inference APIHard

  This Anthropic ML system design onsite asks you to design a multi-tenant, GPU-backed inference API that serves many models and versions -- including large autoregressive LLMs -- under explicit latency SLOs. It spans API and schema design, streaming and async jobs, continuous batching with prefill/decode separation, KV-cache and GPU memory management, multi-model hosting on shared GPUs, heterogeneous autoscaling and placement, multi-region routing, canary rollout, and reliability and cost controls. The signature probe is the diagnostic scenario where CPU utilization is low but the GPUs are saturated.

  AnthropicSoftware EngineerML System DesignOnsite
• Design a Low-Latency GPU Inference ServiceMedium

  This problem tests the ability to design a high-throughput, low-latency inference architecture for large language models, focusing on hardware utilization and bottleneck mitigation.

  AnthropicSoftware EngineerML System DesignTechnical Screen
• Design a Model Inference API and Optimize Its GPU UsageMedium

  A system design interview question that asks you to design an inference API for a trained model served on GPUs, covering the public API, streamed responses, request queueing, scheduling onto GPU workers, overload handling and failure recovery. Follow-up questions probe how to raise GPU throughput and memory efficiency without missing latency targets.

  AnthropicSoftware EngineerSystem DesignOnsite
• Design a One-on-One Chat ServiceMedium

  Design a highly available, low-latency one-on-one messaging system capable of delivering messages in real time, maintaining strict ordering, and handling offline synchronization.

  AnthropicSoftware EngineerSystem DesignTechnical Screen
• Design a Parallel Image ProcessorMedium

  This problem tests your ability to design a thread-safe, parallelized image processing framework that handles neighborhood-based pixel operations without race conditions.

  AnthropicSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Design a Parallel and Resumable Model DownloaderMedium

  Design a parallel model downloader with version-bound byte ranges, resumable verified pieces, bounded resource use, and atomic publication of complete artifacts.

  AnthropicSoftware EngineerSystem DesignOnsite
• Design a Resilient Chat SystemMedium

  Design a resilient, distributed 1:1 and group messaging system focusing on durability guarantees, strict message ordering, robust fan-out, and reliable offline catch-up under partial failures.

  AnthropicSoftware EngineerSystem DesignTechnical Screen
• Design a Resumable Parallel Downloader for Game Client PatchesMedium

  Design a game launcher's patch downloader that fetches a multi-gigabyte update in parallel byte-range chunks, survives crashes and connection drops without re-downloading verified bytes, and only ever exposes a complete, verified patch to the game client.

  AnthropicSoftware EngineerSystem DesignOnsite
• Design a Resumable, Parallel Fetcher for Huge Dataset ReleasesMedium

  Design a node-side fetcher that downloads multi-terabyte dataset releases in parallel byte ranges, resumes from verified pieces after crashes, and atomically publishes only complete releases. Tests manifest design, range-request validation, durable progress tracking, and atomic filesystem publication.

  AnthropicSoftware EngineerSystem DesignOnsite
• Design a Shared API Request Workbench With Versioned RunsMedium

  Design a team tool where engineers co-edit a shared collection of HTTP request templates, freeze them into immutable versions, and execute versions asynchronously against third-party APIs with full provenance of inputs, config, and results.

  AnthropicSoftware EngineerSystem DesignOnsite
• 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 batch inference APIHard

  This question evaluates a candidate's ability to design asynchronous batch inference APIs and systems, including API schema and job lifecycle design, idempotency semantics, queueing and worker scaling, batching and accelerator utilization, rate limiting, observability, and error handling.

  AnthropicSoftware EngineerML System 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 high-concurrency LLM inference serviceHard

  This problem evaluates your ability to design a scalable LLM inference serving platform, focusing on throughput optimization, memory constraints, and scheduling strategies for long-running inference requests.

  AnthropicSoftware EngineerML System DesignOnsite
• Design a low-latency ML inference APIHard

  This question evaluates competency in ML system design for real-time, low-latency inference APIs, including multitenancy, SLO/SLI definition, feature retrieval, model serving and rollout strategies, observability, cost control, and security/compliance within the ML System Design category.

  AnthropicSoftware EngineerML System DesignOnsite
• Design a model downloaderMedium

  This question assesses the architectural design of a distributed, secure, and resilient system capable of deploying large-scale machine learning models to heterogeneous edge devices.

  AnthropicMachine Learning EngineerML System DesignOnsite
• 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 profiling plan for kernelsHard

  This question evaluates competency in performance profiling, experimental design, microarchitectural analysis, statistical methodology, and kernel-level performance engineering.

  AnthropicSoftware EngineerAnalytics & ExperimentationOnsite
• 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 processing backendHard

  Design a prompt processing backend evaluates ML product requirements, data/labeling, modeling, serving architecture, evaluation, monitoring, and trade-offs in a realistic interview setting. A strong answer states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

  AnthropicSoftware EngineerML System 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