Katkat

practice a little every day, paws crossed ♡

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 481–510 of 4616 results

  • AnthropicMediumSoftware Engineer
    Design a Resilient Chat System

    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.

    System DesignTechnical Screensystem-designdistributed-systemschat-architecture
  • AnthropicHardSoftware Engineer
    Design a concurrent web crawler

    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.

    System DesignTechnical Screen
  • AnthropicMediumSoftware Engineer
    Design a distributed web crawler

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

    System DesignTechnical ScreenDistributed SystemsScalabilityCaching
  • AnthropicMediumSoftware Engineer
    Design a one-to-one chat system

    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.

    System DesignTechnical ScreenWebSocketsMessagingScalability
  • AnthropicMediumSoftware Engineer
    Design a prompt-sharing platform

    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.

    System DesignTechnical ScreenAPI DesignData ModelingScalability
  • AnthropicHardMachine Learning Engineer
    Design a scalable MapReduce pipeline

    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.

    System DesignTechnical Screen
  • AnthropicHardSoftware Engineer
    Design a scalable network I/O service

    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.

    System DesignTechnical Screen
  • AnthropicHardSoftware Engineer
    Design a scalable, reliable system

    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.

    System DesignTechnical Screen
  • AnthropicMediumSoftware Engineer
    Design a single- and multi-threaded web crawler

    This question evaluates skills in web crawling, URL parsing and fragment sanitization, graph traversal for deduplication, and concurrent programming for thread-safe crawling, and it falls under the Coding & Algorithms domain.

    Coding & AlgorithmsTechnical Screen
  • AnthropicMediumSoftware Engineer
    Design an LLM-based binary classifier

    This question evaluates knowledge of LLM-based binary classification, probabilistic scoring and numerical stability (including log-prob handling and log-sum-exp), prompt construction, batching and sequence-level aggregation, calibration and evaluation metrics, plus analysis of failure modes and inference-time complexity.

    ML System DesignTechnical Screen
  • AnthropicMediumSoftware Engineer
    Design file deduplication across nested directories

    This question evaluates a candidate's competency in file system traversal, robust I/O handling including symbolic links and cycles, content-based deduplication, and algorithmic efficiency within the Coding & Algorithms domain.

    Coding & AlgorithmsTechnical Screen
  • AnthropicHardSoftware Engineer
    Design production-ready dedup service

    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.

    System DesignTechnical Screen
  • AnthropicHardSoftware Engineer
    Design stack with O(1) minimum query

    This problem tests your ability to augment a standard stack with metadata to perform efficient minimum queries without sacrificing the constant-time complexity of stack operations.

    Coding & AlgorithmsTechnical ScreenStackData StructuresAlgorithms
  • AnthropicMediumSoftware Engineer
    Detect n-length consecutive sequences

    This question evaluates a candidate's competency in algorithm design and data-structure reasoning for detecting n-length consecutive integer sequences, encompassing handling of duplicates, negative values, and dynamic insertions and deletions.

    Coding & AlgorithmsTechnical Screen
  • AnthropicMediumSoftware Engineer
    Detect runs and answer suffix queries

    This question evaluates proficiency in array processing, run-length detection, algorithmic complexity analysis, and the use of range/suffix data structures within the Coding & Algorithms domain.

    Coding & AlgorithmsTechnical Screen
  • AnthropicHardSoftware Engineer
    Explain CPU-Bound vs I/O-Bound Work

    This question evaluates understanding of CPU-bound versus I/O-bound workloads and their interaction with concurrency models such as multithreading, asynchronous I/O, and multiprocessing in Python, including the impact of the Global Interpreter Lock (GIL) and relevance to tasks like web crawling, parsing, and heavy computation.

    Software Engineering FundamentalsTechnical Screen
  • AnthropicHardPerformance / Infrastructure Software Engineer
    Explain Why This Mission and Why Change Roles Now

    Tests your ability to articulate genuine alignment with AI safety and frontier model infrastructure, justify the timing of a career pivot, and link hands-on systems experience to high-scale performance engineering challenges.

    Behavioral & LeadershipTechnical ScreenBehavioralInfrastructureAI Safety
  • AnthropicHardSoftware Engineer
    Find duplicate files and apply image operations

    This question evaluates skills in string parsing and content-based grouping for duplicate file detection, along with matrix manipulation for image operations like horizontal flips and box blur, covering competencies in algorithm design, data-structure selection, and numerical array transformations.

    Coding & AlgorithmsTechnical Screen
  • AnthropicMediumSoftware Engineer
    Fix a Corrupted Bootloader Instruction

    Simulate a virtual machine's instruction set, detect an infinite loop cycle, and find the single instruction modification (between jmp and nop) that allows the program to terminate normally.

    Coding & AlgorithmsTechnical Screensimulationgraphdepth-first-search
  • AnthropicMediumSoftware Engineer
    Generate Function Profiling Events from Stack Samples

    Generate function start and end events from timestamped stack samples, including independently debounced frames across consecutive samples. Address transient appearances and absences, changing stack suffixes, shared timestamps, deep stacks, end-of-input behavior, complexity, and online processing.

    Coding & AlgorithmsTechnical Screen
  • AnthropicMediumSoftware Engineer
    Generate outputs for images and pipelines

    This question evaluates algorithmic and systems engineering skills related to batch image processing, parallelization, I/O versus CPU trade-offs, and deterministic output association within the Coding & Algorithms domain.

    Coding & AlgorithmsTechnical Screen
  • AnthropicMediumSoftware Engineer
    How would you scale batch image pipelines?

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

    System DesignTechnical ScreenDistributed SystemsScalabilityBatch Processing
  • AnthropicHardSoftware Engineer
    Identify and mitigate deduplication program risks

    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.

    System DesignTechnical Screen
  • AnthropicMediumSoftware Engineer
    Implement Task Management and Duplicate Detection

    This problem tests your ability to design an in-memory task management system with concurrency-aware state tracking and implement an efficient file-deduplication routine using hashing.

    Coding & AlgorithmsTechnical ScreenData StructuresHashingConcurrency
  • AnthropicMediumSoftware Engineer
    Implement a Batch Image Processor

    Design and implement an in-memory image transformation engine that applies sequential operations (grayscale, brightness scaling, nearest-neighbor resizing) over a batch of images efficiently.

    Coding & AlgorithmsTechnical ScreenParallelismMultiprocessingImage Processing
  • AnthropicEasySoftware Engineer
    Implement a Duplicate-File Reporter

    Implement an efficient file system scanner that identifies duplicate files while minimizing disk I/O and gracefully handling filesystem errors.

    Software Engineering FundamentalsTechnical Screenfile-systemio-optimizationhashing
  • AnthropicMediumSoftware Engineer
    Implement a Parallel Image Processor

    Design and implement a concurrent batch image processor that executes a sequence of matrix transforms across worker threads or processes while isolating per-job failures.

    Coding & AlgorithmsTechnical Screenconcurrencymultithreadingfault-tolerance
  • AnthropicHardSoftware Engineer
    Implement a Time-Aware Task Manager

    Design an in-memory task manager supporting per-user task versioning, time-to-live (TTL) expiration, and point-in-time historical queries.

    Coding & AlgorithmsTechnical ScreenBinary SearchData StructuresDesign
  • AnthropicMediumMachine Learning Engineer
    Implement cluster status tracker

    This question evaluates a candidate's competence in data structures and algorithms for time-ordered state tracking, time-series indexing, conflict resolution (last-write-wins), memory-efficient storage, and concurrent system behavior under high update rates.

    Coding & AlgorithmsTechnical Screen
  • AnthropicMediumSoftware Engineer
    Implement hostname-restricted web crawler

    This question evaluates skills in graph traversal and cycle detection, hostname-based filtering, URL parsing, and basic network error handling. Commonly asked in Coding & Algorithms interviews, it assesses algorithmic reasoning about traversal strategy and complexity (time and space) analysis while balancing conceptual understanding with practical implementation details.

    Coding & AlgorithmsTechnical Screen