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 511–540 of 1026 results

  • IntuitMediumSoftware Engineer
    Find largest file in a directory using Bash

    This problem tests your ability to navigate the file system using command-line utilities and process streaming data to identify files based on size metadata.

    Software Engineering FundamentalsOnline AssessmentBashLinuxScripting
  • J.P. MorganMediumSoftware Engineer
    Architecture and Data-Scaling Trade-offs

    This question assesses the ability to articulate trade-offs between architectural styles (monolith vs. microservices) and data storage strategies (sharding vs. replication) in the context of a high-throughput financial system.

    Software Engineering FundamentalsOnsiteSystem DesignMicroservicesDatabase
  • J.P. MorganMediumSoftware Engineer
    Exception Handling in a RESTful Service with @ControllerAdvice

    This problem tests your ability to design a centralized exception handling mechanism in a Java Spring environment, ensuring consistent API error responses and proper abstraction of internal implementation details.

    Software Engineering FundamentalsOnsiteSpring BootREST APIException Handling
  • J.P. MorganMediumSoftware Engineer
    Explain Polymorphism and Binary Trees, and How You Use AI Tools as an Engineer

    A software engineering fundamentals discussion with no coding problem: explain polymorphism with examples, describe binary trees and binary search trees with their traversals and costs, and explain how you use AI tools responsibly. It tests precise definitions, complexity reasoning and engineering judgment.

    Software Engineering FundamentalsTechnical Screen
  • J.P. MorganMediumSoftware Engineer
    Java Core Deep Dive: Concurrent Collections and Java 8 Features

    This question tests your understanding of thread-safety in Java collections and your ability to refactor imperative code into functional Java 8 style streams.

    Software Engineering FundamentalsOnsiteJavaConcurrencyCollections
  • J.P. MorganMediumSoftware Engineer
    Reason About Top K Frequent Values at Scale

    Tests understanding of single-machine bounded-heap top-k frequency counting and how to scale the design to distributed, partitioned data pipelines.

    Software Engineering FundamentalsTechnical ScreenHeapHash MapDistributed Systems
  • J.P. MorganMediumSoftware Engineer
    Review a PR for thread-safe request handling

    This problem tests your ability to identify race conditions and thread-safety issues in a concurrent service and suggests robust design patterns for handling shared resources.

    Software Engineering FundamentalsTechnical ScreenConcurrencyThread-SafetyDesign Patterns
  • J.P. MorganMediumSoftware Engineer
    Review concurrent code quality

    This question tests your ability to identify thread-safety issues, improper synchronization, and architectural code smells within a multi-threaded data processing class.

    Software Engineering FundamentalsTechnical ScreenConcurrencyJavaThread-Safety
  • Jane StreetMediumSoftware Engineer
    Design Exchange and Instrument Abstractions for Quote Arbitrage

    Design an in-memory cross-exchange quote aggregator and arbitrage detector that identifies profitable, actionable price discrepancies while handling invalid spreads, quote staleness, and order sizing.

    Software Engineering FundamentalsTechnical ScreenLow-Level DesignTrading SystemsData Structures
  • Jane StreetMediumSoftware Engineer
    Turning Interview Code into a Reusable Library or API

    This question evaluates a candidate's skills in software design and engineering practices, including modularization, API and library interface design, documentation and typing, robustness and error handling, testing, packaging, versioning, and state/transport considerations.

    Software Engineering FundamentalsTechnical Screen
  • Jane StreetMediumSoftware Engineer
    Write an Interpreter for a Small Language with Load, Store and Arithmetic

    Practice writing an interpreter for a small language with load, store and integer arithmetic instructions, using an assumed stack-based specification. It tests parsing source text into instructions, executing them with correct operand order, and reporting errors such as stack underflow, undefined variables and division by zero.

    Software Engineering FundamentalsTechnical Screen
  • Jump TradingEasySoftware Engineer
    Design Stack Evaluators and Low-Latency Memory Primitives

    This question tests your understanding of low-latency systems programming, focusing on thread-safe memory management, cache locality, and efficient expression parsing.

    Software Engineering FundamentalsTechnical ScreenC++ConcurrencyLow-Latency
  • 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
  • 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
  • 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
  • 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
  • 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