Katkat

practice a little every day, paws crossed ♡

Software Engineer 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 2311–2340 of 5874 results

  • GoogleMediumSoftware Engineer
    Design a waitlist system with top/bottom K

    This problem tests your ability to design a dynamic waitlist using efficient data structures to support logarithmic time complexity for insertions, deletions, and ranking operations.

    Software Engineering FundamentalsTechnical ScreenData StructuresDesignComplexity Analysis
  • GoogleMediumSoftware Engineer
    Design an Agent for Internal Document Search

    Design an enterprise search agent that provides grounded, cited answers over internal knowledge repositories while strictly enforcing access control lists (ACLs) and handling prompt injection.

    ML System DesignTechnical ScreenRAGSearch SystemsLLM Agents
  • GoogleMediumSoftware Engineer
    Design an Employee Coverage Timeline

    This problem tests your ability to handle overlapping intervals and state tracking using a sweep-line algorithm combined with a mapping structure.

    Software Engineering FundamentalsOnsiteSweep-lineIntervalsAlgorithms
  • GoogleMediumSoftware Engineer
    Design an Enterprise AI Adoption Agent for a Global Company

    Prepare for a Google system design interview about design an enterprise ai adoption agent for a global company. This question focuses on requirements, architecture, trade-offs, reliability, and follow-up discussion areas.

    System DesignOnsite
  • GoogleMediumSoftware Engineer
    Design an LLM Agent for Manufacturing: Production Status, Work Orders and Quotes

    Design an LLM-powered agent for a manufacturing business that checks production progress, opens work orders and gives customers price quotes. Probes tool design for reads and writes, how to stop the agent from inventing statuses or prices, and how to enforce user permissions outside the model.

    ML System DesignTechnical Screen
  • GoogleMediumSoftware Engineer
    Design an Offline-First Client That Syncs Edits and Resolves Multi-Device Conflicts

    Design the client side of an app where users keep editing data offline, store every edit locally, and sync with the server when the network returns. Covers the local data model and edit queue, a sync protocol that is safe to retry, and detecting and resolving version conflicts when several devices change the same data.

    System DesignOnsite
  • GoogleMediumSoftware Engineer
    Design an Online Coding Judge Platform

    This question tests the ability to design a high-throughput, secure, and fault-tolerant distributed system capable of executing untrusted user code in isolated environments.

    System DesignOnsiteScalabilitySecurityQueues
  • GoogleEasySoftware Engineer
    Design an ads retrieval service using a heap

    This question tests the ability to design a retrieval system using a priority queue and the implementation of efficient operations to maintain a sorted collection of ad candidates.

    Software Engineering FundamentalsOnsiteHeapPriority QueueData Structures
  • GoogleMediumSoftware Engineer
    Design an editable sequence with marker

    This question evaluates understanding of mutable ordered sequence data structures, marker semantics and invariants, API and data model design, and algorithmic time-complexity trade-offs for insert, delete, and move operations.

    Software Engineering FundamentalsOnsite
  • GoogleHardSoftware Engineer
    Design an elevator control system

    This question evaluates system design skills including architectural modeling of components, scheduling and concurrency control, state-machine design, and fault-tolerance for real-time control systems, and falls under the System Design domain.

    System DesignOnsite
  • GoogleHardSoftware Engineer
    Design anomaly detection and response platform

    This question evaluates a candidate's competency in designing end-to-end ML-driven systems that handle large-scale, low-latency OS snapshot ingestion, binary anomaly detection, decisioning and action orchestration with multi-tenant security, auditability, and failure rollback.

    ML System DesignTechnical Screen
  • GoogleMediumSoftware Engineer
    Design at-least-once notification delivery

    This question evaluates expertise in reliable distributed systems design, including at-least-once delivery semantics, idempotency and deduplication strategies, retry and dead-letter handling, API and message-schema design, ordering and out-of-order handling, and scalability for high-throughput multi-tenant notification platforms.

    System DesignTechnical Screen
  • GoogleEasySoftware Engineer
    Design compressed vector and compute dot product

    This problem tests your ability to design a memory-efficient data structure for sparse or repetitive vector data and implement an arithmetic operation without fully decompressing the representation.

    Coding & AlgorithmsOnsiteArraysTwo PointersData Structures
  • GoogleHardSoftware Engineer
    Design deduplicated file storage on filesystem

    This question evaluates system design and storage engineering competencies, including multi-tenant isolation, authentication and authorization models, content-addressable storage and deduplication, reference counting and garbage collection, concurrency control, API surface design, and scaling across nodes using only filesystem primitives.

    System DesignTechnical Screen
  • GoogleHardSoftware Engineer
    Design distributed log storage service

    This question evaluates a candidate's expertise in designing distributed storage systems, covering partitioned append-only logs, high-throughput writes and reads, replication, retention, indexing, compaction, leader/follower roles, and recovery mechanisms.

    System DesignTechnical Screen
  • GoogleHardSoftware Engineer
    Design distributed transactions protocol

    This question evaluates a candidate's understanding of distributed transactions, coordination protocols, fault tolerance, consistency, and reliability across microservices and databases.

    System DesignTechnical Screen
  • GoogleHardSoftware Engineer
    Design executable notebook service APIs

    This question evaluates a candidate's competence in designing secure, scalable systems for executing user-supplied code, covering API design, sandboxing and isolation, dependency management, resource limits, scheduling, and streaming proxies for logs/results.

    System DesignTechnical Screen
  • GoogleHardSoftware Engineer
    Design high-throughput event subscription system

    This question evaluates a candidate's ability to design scalable, fault-tolerant event ingestion and subscription architectures, covering distributed systems, high-throughput messaging, content-based filtering, multi-tenant isolation, API/webhook design, delivery semantics, backpressure, sharding, security, and operational observability.

    System DesignTechnical Screen
  • GoogleHardSoftware Engineer
    Design key management service

    This question evaluates system design and security competencies—specifically cryptographic key lifecycle management, HSM integration, access control, auditing, multi-tenant isolation, and scalability—within the System Design domain.

    System DesignTechnical Screen
  • GoogleMediumSoftware Engineer
    Design nearest-available-taxi lookup with updates

    This question assesses the ability to design a high-concurrency geospatial system that maintains real-time state for moving entities and supports low-latency queries.

    System DesignTechnical ScreenGeospatialScalabilityCaching
  • GoogleHardSoftware Engineer
    Design quota enforcement for high concurrency

    This question evaluates a candidate's understanding of distributed system design and engineering competencies related to quota enforcement, high-throughput rate limiting, consistency models, sharding, and concurrency control under very high QPS.

    System DesignTechnical Screen
  • GoogleHardSoftware Engineer
    Design relational-to-NoSQL migration pipeline

    This question evaluates a candidate's competency in designing a relational-to-NoSQL migration pipeline, covering distributed systems and data engineering concepts such as consistent snapshotting, change-data-capture, per-key ordering, idempotency, exactly-once behavior, schema evolution, partitioning, and operational reliability.

    System DesignTechnical Screen
  • GoogleMediumSoftware Engineer
    Design server allocation for multi-type nodes

    This question evaluates understanding of scalable resource-allocation and matching systems, encompassing data-structure and index design, availability tracking, fragmentation minimization, concurrency control, and failure handling for large node pools.

    Coding & AlgorithmsTechnical Screen
  • GoogleMediumSoftware Engineer
    Design set with O(1) random access

    This question evaluates skill in designing a composite data structure that supports average O(1) insertion, deletion, and uniform random access, and tests understanding of hashing, indexing, randomness, and concurrency control.

    Coding & AlgorithmsTechnical Screen
  • GoogleHardSoftware Engineer
    Design street-view image ingestion and storage system

    This question tests the ability to design a high-throughput, fault-tolerant ingestion pipeline for massive geospatial media, focusing on distributed storage strategies, data integrity, and efficient retrieval at scale.

    System DesignTechnical ScreenScalabilitySpatial IndexingData Ingestion
  • GoogleMediumSoftware Engineer
    Design structure for insert and k-th largest

    This problem tests your ability to design a dynamic data structure that maintains elements while efficiently querying the k-th largest value, necessitating a balance between insertion speed and retrieval performance.

    Coding & AlgorithmsOnsiteData StructuresHeapBinary Search Tree
  • GoogleHardSoftware Engineer
    Design viewing history and resume service

    This question evaluates a candidate's ability in large-scale system design, covering distributed state management, API design, data modeling for per-user progress, idempotent update semantics, cross-device synchronization, and privacy/compliance considerations.

    System DesignTechnical Screen
  • GoogleMediumSoftware Engineer
    Determine All Players with Fixed Rankings

    Determine which players in a competition have a uniquely determined ranking given a set of pairwise match outcomes.

    Coding & AlgorithmsOnsitegraphbfsdfs
  • GoogleMediumSoftware Engineer
    Determine Reporting Relationships

    This question evaluates understanding of hierarchical relationship modeling, transitive inference across relations, and dynamic data-structure design for tracking manager and peer links.

    Coding & AlgorithmsTechnical Screen
  • GoogleMediumSoftware Engineer
    Determine Whether a Word Exists in a Graph

    This problem tests the ability to implement a depth-first search (DFS) with backtracking to find a specific sequence within a grid, while managing state to avoid reusing the same path.

    Coding & AlgorithmsOnsiteDFSBacktrackingGraphs