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 811–840 of 2810 results

  • DatabricksMediumSoftware Engineer
    Design an IP filter using CIDR rules

    This question evaluates understanding of IP addressing and CIDR notation, bit-level conversion between prefixes and integer ranges, and the design of scalable data structures and algorithms for prefix/range queries, rule priority handling, and rule-set operations (allow/deny semantics).

    Coding & AlgorithmsTechnical Screen
  • DatabricksMediumSoftware Engineer
    Design an online bookstore: DB insert succeeds but SQS publish fails, and duplicate messages

    System design question about an online bookstore whose order service inserts orders into a database and then publishes messages to Amazon SQS. Probes what should happen when the insert succeeds but the publish fails, how to keep the database and queue consistent across crashes, and how consumers avoid duplicate processing under at-least-once delivery.

    System DesignTechnical Screen
  • DatabricksHardSoftware Engineer
    Determine allow/deny for an IP via CIDR rules

    This problem tests your ability to efficiently manage and query hierarchical IP address ranges, requiring knowledge of bitwise operations and data structures for range matching.

    Coding & AlgorithmsTechnical ScreenBit ManipulationTrieNetworking
  • DatabricksHardSoftware Engineer
    Evaluate ACL rules for IP and CIDR

    This problem tests your ability to manipulate binary representations of IP addresses and perform efficient prefix matching using CIDR notation, requiring careful bitwise arithmetic and efficient lookup structures.

    Coding & AlgorithmsTechnical ScreenBit ManipulationTrieNetworking
  • DatabricksHardSoftware Engineer
    Find Path Between Fibonacci Tree Nodes

    This problem tests your ability to map nodes in a recursively defined tree structure without materializing the tree, requiring an understanding of Fibonacci sequences and path-finding algorithms in binary trees.

    Coding & AlgorithmsTechnical ScreenTreesRecursionMath
  • DatabricksMediumSoftware Engineer
    Find first CIDR block covering IP

    This question evaluates a candidate's understanding of IPv4 and CIDR notation, ability to perform prefix-based address containment checks using bitwise reasoning, and competence in parsing and efficient lookup across many ranges.

    Coding & AlgorithmsTechnical Screen
  • DatabricksMediumSoftware Engineer
    Find k customers with least revenue

    This question evaluates a candidate's ability to aggregate per-customer revenue from event streams and perform selection on aggregated totals, testing knowledge of data aggregation, selection algorithms, and efficient use of data structures.

    Coding & AlgorithmsTechnical Screen
  • DatabricksHardSoftware Engineer
    Find path between nodes in Fibonacci tree

    This problem tests your ability to navigate implicit tree structures defined by recurrence relations and your proficiency in pathfinding within large graphs without materializing them.

    Coding & AlgorithmsTechnical ScreenTreesRecursionFibonacci
  • DatabricksHardSoftware Engineer
    Find shortest path in a Fibonacci-ordered tree

    This question evaluates understanding of recursive binary tree structures, preorder indexing, Fibonacci-like size relations, and arithmetic-based navigation for computing paths in an implicitly defined tree.

    Coding & AlgorithmsTechnical Screen
  • DatabricksHardSoftware Engineer
    Identify and handle race conditions

    This question evaluates understanding of concurrency, race conditions, synchronization mechanisms, and performance trade-offs in designing thread-safe in-memory data structures like key-value stores and hit counters.

    System DesignTechnical Screen
  • DatabricksMediumSoftware Engineer
    Implement CIDR firewall matcher

    This interview question evaluates requirements, scale assumptions, API/data design, architecture, trade-offs, failure modes, and rollout in a realistic interview setting. A strong answer for Implement CIDR firewall matcher states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

    Coding & AlgorithmsTechnical Screen
  • DatabricksMediumSoftware Engineer
    Implement Snapshot Iterator Without Order Guarantees

    This question evaluates data-structure design and iterator semantics—specifically snapshot iteration over a mutable, set-like collection without order guarantees—and tests skills in implementing mutation-isolated iteration and analyzing time and space complexity; it belongs to the Coding & Algorithms domain and emphasizes practical implementation.

    Coding & AlgorithmsTechnical Screen
  • DatabricksHardSoftware Engineer
    Implement a Snapshot Set Iterator

    This question evaluates understanding of set data structures, iterator and snapshot semantics, and the ability to reason about time and space complexity when providing stable views over mutable collections.

    Coding & AlgorithmsTechnical Screen
  • DatabricksMediumSoftware Engineer
    Implement a sliding-window hit counter

    This question evaluates understanding of time-based data structures and algorithms for sliding-window counters, including fixed-size array bucketing, handling timestamp collisions within buckets, refactoring for reuse, and time/space complexity analysis.

    Coding & AlgorithmsTechnical Screen
  • DatabricksHardSoftware Engineer
    Implement an Alternating Tic-Tac-Toe Game

    This problem tests your ability to design a robust state machine for a board game, focusing on efficient win-condition checking and clean API design.

    Coding & AlgorithmsTechnical ScreenState ManagementArraysGame Theory
  • DatabricksMediumSoftware Engineer
    Optimal Commute: Nearest Transit Distance in a City Grid

    Tests the ability to solve multi-source shortest path problems on a grid using multi-source Breadth-First Search (BFS). Evaluates graph traversal efficiency, boundary checking, and handling of impassable terrain.

    Coding & AlgorithmsTechnical ScreenBreadth-First SearchMatrixGraph
  • DatabricksHardSoftware Engineer
    Optimize a SQL query plan tree

    This problem tests your ability to manipulate an Abstract Syntax Tree (AST) representing a relational query plan to reduce data processing costs through predicate pushdown and projection pruning.

    Coding & AlgorithmsTechnical ScreenTreesRecursionDatabase Internals
  • DatabricksMediumSoftware Engineer
    Solve Grid Path and Graph Sampling

    This question tests the ability to solve a shortest-path problem with multiple constraints using Dijkstra's algorithm, followed by understanding sampling techniques for connected graph structures.

    Coding & AlgorithmsTechnical ScreenDijkstraGraph AlgorithmsDynamic Programming
  • DatadogMediumSoftware Engineer
    Build span trees from unordered trace spans

    This problem tests your ability to reconstruct a parent-child hierarchical tree from an unordered collection of trace spans by leveraging parent ID references and sorting mechanisms.

    Coding & AlgorithmsTechnical ScreenTreesHash MapsSorting
  • DatadogMediumSoftware Engineer
    Deep-dive a recent project

    This question evaluates project ownership, technical leadership, system architecture, trade-off reasoning, and the ability to articulate goals, constraints, decisions, metrics and postmortem lessons in a software engineering context.

    Behavioral & LeadershipTechnical Screen
  • DatadogMediumSoftware Engineer
    Describe handling conciseness feedback

    This question evaluates a candidate's ability to accept and act on conciseness feedback, encompassing communication clarity, adaptability, measurement of improvement, and leadership influence on stakeholder interactions.

    Behavioral & LeadershipTechnical Screen
  • DatadogMediumSoftware Engineer
    Design an LLM Agent System That Automatically Resolves Jira Tickets and Opens Pull Requests

    Design an autonomous agent pipeline that ingests Jira bug reports, grounds itself in a multi-repo codebase via code search and retrieval, iterates on a fix in a sandboxed runtime, and opens a validated pull request.

    ML System DesignTechnical ScreenLLM AgentsCode GenerationRAG
  • DatadogHardSoftware Engineer
    Design an image detection system

    This question evaluates a candidate's competence in designing scalable, reliable end-to-end machine learning systems for image object detection, including ingestion, preprocessing, model serving, data and version management, monitoring, and operational concerns.

    ML System DesignTechnical Screen
  • DatadogHardSoftware Engineer
    Design log-query stream processor

    Design log-query stream processor 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
  • DatadogMediumSoftware Engineer
    Explain a project concisely and deeply

    This question evaluates project leadership, technical ownership, stakeholder communication, decision‑making under trade‑offs, and the ability to quantify measurable impact through a concise overview followed by a deep dive.

    Behavioral & LeadershipTechnical Screen
  • DatadogMediumSoftware Engineer
    Implement DeleteTree With Limited Filesystem APIs

    Implement a robust recursive tree-deletion algorithm using a restricted set of filesystem primitives. This question tests post-order traversal, managing call-stack and heap memory across deep and wide directory structures, and handling edge cases cleanly.

    Software Engineering FundamentalsTechnical Screentreestackdfs
  • DatadogEasySoftware Engineer
    Implement buffered file writer with concurrency support

    This question evaluates a candidate's ability to implement buffered I/O and design concurrency-safe APIs, exercising skills in data buffering, performance optimization, and thread-safety.

    Coding & AlgorithmsTechnical Screen
  • DatadogMediumSoftware Engineer
    Implement log storage and querying

    This question evaluates a candidate's skill in designing and analyzing log storage and query systems, covering data layout, indexing strategies, time-range scans with optional filters, and time/space complexity reasoning.

    Coding & AlgorithmsTechnical Screen
  • DatadogMediumSoftware Engineer
    Implement write with internal buffer

    This question evaluates proficiency with buffered I/O, buffer management, memory handling, and performance optimization, including maintaining byte order, handling partial writes, and edge cases across consecutive write/flush/close operations.

    Coding & AlgorithmsTechnical Screen
  • DatadogMediumSoftware Engineer
    Match logs to prior queries

    This question evaluates understanding of streaming algorithms, string indexing, and set-based matching, focusing on designing efficient online data structures to match stored queries against incoming logs within the Coding & Algorithms domain.

    Coding & AlgorithmsTechnical Screen