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 7891–7920 of 9403 results

  • SnowflakeMediumSoftware Engineer
    Decide Whether Repeatedly Summing Squared Digits Reaches 1

    Starting from a positive integer, repeatedly replace it by the sum of the squares of its digits and decide whether the sequence reaches 1 or falls into a cycle. It tests cycle detection on an implicit sequence and reasoning about why the values stay bounded.

    Coding & AlgorithmsTechnical Screen
  • SnowflakeMediumSoftware Engineer
    Decide Whether an Undirected Graph Can Be Colored with Three Colors

    Given an undirected graph with up to fifteen nodes, decide whether every node can receive one of three colors so that no edge joins two nodes of the same color. It tests backtracking search with pruning and reasoning about odd cycles and cliques.

    Coding & AlgorithmsTechnical Screen
  • SnowflakeMediumSoftware Engineer
    Deep-Copy a Linked List Whose Nodes Also Carry a Random Pointer

    Return a deep copy of a singly linked list in which every node also has a random pointer to any node or to nothing, so that the copy shares no node with the original. It tests mapping original nodes to copies, pointer wiring and constant-space alternatives.

    Software Engineering FundamentalsTechnical Screen
  • SnowflakeMediumSoftware Engineer
    Deep-Copy a Linked List with Random Pointers

    Implement a deep copy of a linked list where each node has both a next pointer and an arbitrary random pointer, ensuring all reachable nodes and relationships are replicated without modifying the original list.

    Coding & AlgorithmsTechnical ScreenLinked ListHash TableGraph
  • SnowflakeMediumSoftware Engineer
    Delete the Fewest Tree Nodes to Meet a Height Limit

    Find a minimum-cardinality set of tree-node deletions under child-promotion semantics using height-budget dynamic programming and explicit solution reconstruction.

    Coding & AlgorithmsTechnical Screen
  • SnowflakeMediumData Scientist
    Describe navigating ambiguous, repetitive questioning

    This question evaluates a Data Scientist's skills in stakeholder communication, ambiguity management, diagnostic reasoning to identify misaligned goals or definitions, adaptive framing between technical and plain-language explanations, trade-off analysis under time pressure, and delivering measurable outcomes.

    Behavioral & LeadershipTechnical Screen
  • SnowflakeMediumSoftware Engineer
    Design a Cron Job Scheduler

    This question evaluates skills in designing reliable distributed schedulers, including durable state modeling, concurrency and race-condition reasoning, idempotency, and fault-tolerant handoff semantics, and is commonly asked to assess a candidate's ability to guarantee correctness and coordination when multiple replicas must manage recurring job triggers. Categorized under system design and distributed systems with overlap into data modeling and consistency, it emphasizes practical application of architectural and operational trade-offs rather than purely theoretical concepts.

    System DesignTechnical Screen
  • SnowflakeMediumSoftware Engineer
    Design a Distributed Job Scheduler with Cron, Pause and Resume

    Design a job scheduler service that runs one-time and cron jobs, supports pausing and resuming, and dispatches work to an unlimited pool of workers. It tests due-job indexing, claim and lease protocols, pause semantics, at-least-once execution with idempotency, and handling top-of-the-hour spikes.

    System DesignTechnical Screen
  • SnowflakeMediumSoftware Engineer
    Design a Geolocation Search Service

    This question tests your ability to design a scalable spatial indexing system capable of performing range-based queries (e.g., 'find all points of interest within 5km') while maintaining high availability and low latency.

    System DesignTechnical ScreenGeolocationIndexingScalability
  • SnowflakeMediumSoftware Engineer
    Design a Photo Album Backend: Upload Consistency, Deduplication and Scaling

    A backend system design prompt for a photo album service where users upload photos and organize them into albums. It probes keeping a metadata database and blob storage consistent on upload, showing new photos instantly despite processing lag, blocking duplicate uploads, and when a relational database stops scaling.

    System DesignOnsite
  • SnowflakeMediumMachine Learning Engineer
    Design a Pipeline That Distills Reusable Agent Skills for Enterprise Customers

    Design a pipeline that automatically extracts reusable agent skills for enterprise customers from traces and documents, validates them and delivers them to agents. It tests LLM system design, outcome labeling, offline evaluation against a baseline, tenant isolation, versioning and drift monitoring.

    ML System DesignOnsite
  • SnowflakeHardSoftware Engineer
    Design a Priority Task Executor with Duplicate Task IDs

    This problem tests your ability to design a thread-safe task scheduler that handles duplicate task IDs while ensuring each unique task is executed exactly once based on priority and submission time.

    Software Engineering FundamentalsOnsiteConcurrencyHeapsHash Maps
  • SnowflakeHardSoftware Engineer
    Design a REST API Abstraction Layer

    This question evaluates system design and API design competencies, focusing on creating a REST API abstraction layer and internal SDK that address cross-cutting concerns like reliability, observability, security, versioning, and contract/interface modeling.

    System DesignTechnical Screen
  • SnowflakeHardSoftware Engineer
    Design a Reliable Job Scheduler

    This problem tests the ability to design a distributed, fault-tolerant job scheduler capable of handling task persistence, concurrency, and strict timing requirements at scale.

    System DesignOnsiteDistributed SystemsConcurrencyFault Tolerance
  • SnowflakeMediumSoftware Engineer
    Design a Shared User Quota Service That Never Overdraws

    Design a quota service that several services draw from for each user, where the balance must never be overdrawn under highly concurrent requests and must stay strongly consistent. It tests atomic conditional updates, reserve-and-commit APIs with idempotency, replication choices, and scaling a single hot user's quota.

    System DesignTechnical Screen
  • SnowflakeHardSoftware Engineer
    Design a Thread-Safe Multi-Rule Rate Limiter

    This problem tests the ability to design a thread-safe, flexible rate-limiting system that handles multiple constraints, atomic permit management, and graceful error handling.

    Software Engineering FundamentalsTechnical ScreenConcurrencyRate-LimitingThread-Safety
  • SnowflakeHardSoftware Engineer
    Design a concurrent web crawler

    This problem evaluates your ability to design a distributed, concurrent web crawling architecture that balances high throughput with politeness policies, concurrency control, and robust state management.

    System DesignOnsiteConcurrencyDistributed SystemsCaching
  • SnowflakeEasySoftware Engineer
    Design a disk-backed KV store under contention

    This problem tests the ability to design a persistent key-value store that balances disk I/O, memory caching, and thread safety under high concurrency.

    System DesignOnsiteConcurrencyStorage EnginesLSM Trees
  • SnowflakeHardSoftware Engineer
    Design a distributed system end-to-end

    This question evaluates a candidate's ability to design scalable, multi-tenant distributed analytics platforms, testing competencies in distributed systems architecture, data layout and storage, query planning and execution, metadata management, consistency and replication strategies, fault tolerance, observability, and capacity planning.

    System DesignTechnical Screen
  • SnowflakeMediumSoftware Engineer
    Design a distributed tree node counter

    Design a distributed tree node counter 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
  • SnowflakeHardSoftware Engineer
    Design a multi-tenant quota system

    This question evaluates a candidate's ability to design a global multi-tenant quota service, testing competencies in distributed systems, data consistency, concurrency control, API and storage modeling, and scalability within the System Design domain.

    System DesignTechnical Screen
  • SnowflakeHardData Scientist
    Design an A/B test for ML model launch

    This question evaluates a data scientist's competence in experimental design, statistical power analysis, sequential monitoring, covariate adjustment (e.g., CUPED), and practical operational concerns like guardrails, interference, and ramping for ML model launches.

    Analytics & ExperimentationTechnical Screen
  • SnowflakeMediumSoftware Engineer
    Design an Audit Logs Service

    Tests the ability to design an immutable, highly available, multi-tenant audit logging service that supports high-throughput ingestion and tamper-evident storage while providing fast, tenant-scoped querying.

    System DesignTechnical ScreenDistributed SystemsSecurityMulti-Tenancy
  • SnowflakeMediumSoftware Engineer
    Design an Interactive Query Execution Notebook

    Tests your ability to design an asynchronous, scalable system for executing interactive SQL queries and streaming execution state and tabular results back to web clients.

    System DesignTechnical Screensystem-designdistributed-systemsapi-design
  • SnowflakeMediumData Scientist
    Design an analytic warehouse for event data

    This question evaluates a candidate's competency in data warehousing and engineering for analytics, including event-level schema and partitioning, slowly changing dimensions, idempotent ingestion and deduplication, derived metrics modeling, and query performance and cost trade-offs using SQL/Python.

    Data Manipulation (SQL/Python)Onsite
  • SnowflakeMediumSoftware Engineer
    Design an in-memory filesystem and circular queue

    This question evaluates a candidate's skills in data-structure and algorithm design, API specification, correctness reasoning, and time/space complexity analysis within the Coding & Algorithms domain by combining an in-memory hierarchical filesystem design with a fixed-size circular queue implementation.

    Coding & AlgorithmsTechnical Screen
  • SnowflakeMediumSoftware Engineer
    Design an object store with deduplication

    This question evaluates a candidate's ability to design scalable, durable object storage systems with deduplication, touching on storage architecture, data modeling, metadata management, consistency, and garbage collection.

    System DesignTechnical Screen
  • SnowflakeMediumMachine Learning Engineer
    Design and Implement a Rate Limiter with an AI Assistant, Then Defend and Test It

    Design and implement a rate limiter in an AI-assisted coding round: choose and defend an algorithm against its alternatives, direct an AI assistant to write the code, review it and test it. It tests rate-limiting algorithm trade-offs, concurrency, time handling and critical review of generated code.

    Software Engineering FundamentalsOnsite
  • SnowflakeHardData Scientist
    Design and validate a cost-sensitive classifier

    This question evaluates competence in cost-sensitive binary classification, handling delayed and imbalanced labels, calibration and decision-threshold selection, distributional-drift detection, monitoring, and low-latency deployment within the Machine Learning / Data Science domain.

    Machine LearningTechnical Screen
  • SnowflakeHardSoftware Engineer
    Design cache for DAG-based query views

    This question evaluates a candidate's understanding of caching, consistency, versioning, eviction, and update propagation in DAG-based materialized views, testing competencies in distributed systems, data engineering, and storage-hierarchy design.

    System DesignOnsite