Katkat

practice a little every day, paws crossed ♡

Software Engineering Fundamentals 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 601–630 of 1208 results

  • Jump TradingHardSoftware Engineer
    Design a Compact Columnar File Format

    Design an append-friendly, compact columnar file format optimized for fast analytical scans over tabular financial market data (e.g., tick feeds or order book snapshots). Define the on-disk binary layout, reader/writer abstractions, serialization rules, and operational trade-offs.

    Software Engineering FundamentalsTechnical Screensystems-designfile-formatscolumnar-storage
  • KikoffEasySoftware Engineer
    Build a Robust Log Parser and Prefix-Operator Search

    Implement a log parser and query engine that converts raw server log lines into structured records and supports filtering via prefix-operator tokens.

    Software Engineering FundamentalsTechnical ScreenString ParsingData StructuresSoftware Architecture
  • KikoffEasySoftware Engineer
    Validate a Third-Party Identity Payload

    Implement a pipeline that validates a third-party identity verification response against schema requirements and business rules while returning sanitized failure reason codes.

    Software Engineering FundamentalsTechnical ScreenData ValidationPythonClean Code
  • LatitudeaiMediumBackend Engineer
    Design a Thread-Safe Bounded Blocking Queue

    Tests your ability to design a concurrent, thread-safe bounded blocking queue using synchronization primitives, handle edge cases like spurious wakeups and timeouts, and cleanly coordinate shutdown across multiple threads.

    Software Engineering FundamentalsOnsiteConcurrencyMultithreadingQueue
  • LayerzeroMediumSoftware Engineer
    Choose a Safe Polling Strategy for Delayed Records

    Evaluate whether delayed arrivals can support a fixed polling interval that always yields exactly one new record. Use worst-case reasoning, then define a practical live contract covering observation limits, warm-up, buffering, cursors, deduplication, retries, out-of-order data, and multiple pollers.

    Software Engineering FundamentalsTechnical Screen
  • LegoraMediumBackend Engineer
    Design a Cloud-Agnostic Upload Adapter

    Design a provider-neutral object storage upload client that unifies cloud SDK behaviors while supporting streaming, multipart uploads, error normalization, and provider-specific escape hatches.

    Software Engineering FundamentalsOnsiteapi-designcloud-storageobject-oriented-design
  • LegoraMediumSoftware Engineer
    Design a Cloud-Provider Upload Adapter

    Design a modular, provider-agnostic upload adapter interface that enables clients to perform direct uploads to cloud storage (e.g., S3, GCS, Azure Blob). The problem evaluates object-oriented API design, error normalization, capability negotiation, and idempotent verification workflows.

    Software Engineering FundamentalsOnsiteapi-designobject-oriented-designcloud-storage
  • LiftoffMediumSoftware Engineer
    Design and implement core Tetris game logic

    This question evaluates practical implementation skills in game logic, real-time state and event management, piece rotation and movement handling, line-clearing algorithms, and clean, testable code organization.

    Software Engineering FundamentalsOnsite
  • LilaMediumMachine Learning Engineer
    Debug a Transformer bug in an unfamiliar repo

    This question tests your ability to identify and rectify a logical error in a Transformer's multi-head self-attention mechanism, specifically focusing on tensor dimensionality, causality masking, and numerical stability.

    Software Engineering FundamentalsOnsiteTransformersDeep LearningDebugging
  • LinkedInMediumSoftware Engineer
    Design a Raffle Drum That Draws Duplicate Tickets Fairly in O(1)

    Design a drum that holds raffle ticket codes, where the same code can be dropped in more than once, and supports adding a ticket, pulling a specific ticket out, and drawing one at random so every physical ticket in the drum is equally likely to come out — all in average O(1) time. Tests combining an array with a hash index so removal and random draw both stay constant time even with string keys and duplicates.

    Software Engineering FundamentalsTechnical Screendesignhash-maprandomization
  • LinkedInMediumSoftware Engineer
    Design a meeting scheduler API

    This problem tests your ability to design a thread-safe scheduling system using interval management techniques and efficient data structures for range querying.

    Software Engineering FundamentalsOnsiteObject-Oriented DesignConcurrencyIntervals
  • LinkedInMediumSoftware Engineer
    Explain a Project with a Diagram and Deep Dive into Your Design

    Communicate a project through a simple data-flow diagram, then explain design choices, implementation ownership, failure behavior, and validation.

    Software Engineering FundamentalsOnsite
  • LinkedInMediumSoftware Engineer
    Explain the Design of a Recent Feature

    Tests your ability to communicate software design clearly by breaking down a production feature into its architecture, trade-offs, individual ownership, and verification strategy.

    Software Engineering FundamentalsOnsiteSystem DesignTechnical CommunicationArchitecture
  • LinkedInMediumDevOps Engineer
    Explore an Unknown Grid and Return a Robot Path

    This problem tests graph traversal, state-space representation, and pathfinding in an environment where the map must be discovered dynamically.

    Software Engineering FundamentalsOnsiteGraph TraversalBFSState Machine
  • LinkedInMediumSoftware Engineer
    Implement map and render to DOM

    This question evaluates a candidate's skills in vanilla JavaScript utility implementation and DOM rendering, covering array and plain-object iteration semantics, higher-order functions, input validation, error handling, and safe text rendering for browser environments.

    Software Engineering FundamentalsHR Screen
  • LinkedInHardSoftware Engineer
    Merge and Serialize N-ary Trees

    Tests recursive tree manipulation, immutable merging semantics, and robust string serialization/deserialization with input validation.

    Software Engineering FundamentalsTechnical Screentreerecursionparsing
  • LinkedInMediumSoftware Engineer
    Randomized String Multiset With Average O(1) Insert, Remove and Weighted Random Pick

    Design a collection of strings that allows duplicates and supports insert, remove and a random pick in average constant time, where each stored occurrence is equally likely to be returned. It tests hash map and array layout, index bookkeeping on removal, and how string keys change the cost analysis.

    Software Engineering FundamentalsTechnical Screen
  • Luma AIMediumSoftware Engineer
    Reverse-Engineer an App's Undocumented API and Rebuild It With Better UX

    A take-home asks you to reverse-engineer the undocumented API behind an existing app and rebuild the app with a better user experience, then review its fragility and extend it with safe write support. Tests API discovery, schema inference, resilient client design, credential and legal judgment, and UX scoping.

    Software Engineering FundamentalsOnsite
  • LyftMediumSoftware Engineer
    Design a Globally Versioned Key-Value Store

    Design a globally versioned key-value store with sparse key histories, binary-search reads, atomic version publication, and correct history retention.

    Software Engineering FundamentalsOnsite
  • LyftMediumSoftware Engineer
    Design a Transactional In-Memory Key-Value Store

    Design a transactional in-memory key-value store with correct value counts, efficient rollback, and explicitly defined command semantics.

    Software Engineering FundamentalsOnsite
  • LyftMediumSoftware Engineer
    Implement Stateful Fetch-N over a Paginated Upstream

    Implement a stateful fetchN wrapper over a paginated upstream that returns items in source order across repeated calls. Define buffering, page-token progression, exhaustion, empty pages, invalid input, and retry behavior without losing or duplicating items.

    Software Engineering FundamentalsOnsite
  • LyftMediumSoftware Engineer
    In-Memory Key-Value Store with Nested Begin, Commit, and Rollback Transactions

    A coding question to implement an in-memory key-value store with begin, set, unset, commit and rollback, where transaction blocks can be nested and committed changes can no longer be rolled back. It tests how state is recorded per block, restoring keys that were absent, nested commit semantics, and operation complexity.

    Software Engineering FundamentalsOnsite
  • LyftMediumSoftware Engineer
    Wrapper Over a Paginated Page API That Fetches the Next N Words

    A coding question that wraps an external paginated API, where each page returns a variable number of words, behind a fetch(n) method that returns the next n words in order. It tests handling words left over between calls, requests that span several or empty pages, lazy fetching, the end of the content, and API failures.

    Software Engineering FundamentalsOnsite
  • MathWorksMediumSoftware Engineer
    Compare Core Networking and Language Runtime Concepts

    Compare pointer ownership and storage duration, HTTP with HTTPS, and TCP with UDP using concrete technical examples. Strong responses separate guarantees from common implementations, connect concepts to production failures, and avoid simplistic claims about memory or network speed.

    Software Engineering FundamentalsOnsite
  • Maven SecuritiesHardQuantitative Trader
    Solve Graduate Trader Probability Questions

    This set evaluates quantitative reasoning and probabilistic thinking, testing competencies in combinatorics, probability, expectation, conditional probability, enumeration, and logical deduction.

    Software Engineering FundamentalsOnline Assessment
  • MercorMediumSoftware Engineer
    Charge-Then-Save: Making a Checkout Handler Safe Under Retries

    Review a ticket-checkout handler that bills a card through a remote gateway and then saves an order row, explain every way it breaks when calls fail or are retried, and redesign it. Tests reasoning about partial failure, idempotency, and reconciliation.

    Software Engineering FundamentalsTechnical Screenidempotencydistributed-systemspayments
  • MercorMediumSoftware Engineer
    Code Review: A Ride Fare Method That Charges a Card Then Logs the Trip

    Review a Java method that charges a rider's card through an external processor and then writes a trip record, and explain what goes wrong if the caller fails mid-call and how to fix it.

    Software Engineering FundamentalsTechnical Screencode-reviewidempotencydistributed-systems
  • MercorEasySoftware Engineer
    Code Review: Find the Problems in a Python Dict-Based Memoization Cache

    A Python code review question about a function that memoizes an expensive computation in a module-level dictionary. It tests whether a candidate can find correctness, memory, concurrency and key-equality problems in simple caching code and propose fixes with clear trade-offs.

    Software Engineering FundamentalsTechnical Screen
  • MercorMediumSoftware Engineer
    Code Review: Improve a Java Method That Builds a CSV String

    A Java code-reading question: review a short method that concatenates a list of rows into a CSV string and propose improvements. It tests knowledge of string-building performance, separator and escaping rules for CSV, null handling, streaming output for large exports, and risks when files are opened in spreadsheets.

    Software Engineering FundamentalsTechnical Screen
  • MercorMediumSoftware Engineer
    Code Review: Partial Failure in a Java Payment Method That Charges Then Records

    A Java code-reading question about a payment method that charges an external provider and then inserts a database record, focused on what happens when the client fails in the middle of the call. It tests reasoning about partial failures, retries, idempotency keys, payment states, and reconciliation with the provider.

    Software Engineering FundamentalsTechnical Screen