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 241–270 of 448 results

  • 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
  • MetaHardSoftware Engineer
    Analyze Minimum Completion Time for Target Courses in a Prerequisite DAG

    Analyze the minimum time needed to finish target courses and only their transitive prerequisites in a DAG. Distinguish total study effort from elapsed time with parallel courses, count shared prerequisites once, exclude unrelated nodes, and detect reachable cycles.

    Software Engineering FundamentalsOnsite
  • MetaMediumSoftware Engineer
    Design an Expected O(1) Randomized Container

    Design a distinct-element container with expected constant-time insertion and uniformly random removal. The discussion covers mutation invariants, uniformity, empty-state behavior, expected complexity, deterministic randomness tests, and how duplicate or concurrent variants would change the contract.

    Software Engineering FundamentalsOnsite
  • MetaHardSoftware Engineer
    Design and Evaluate a Solver for a 36-Card Sum-Fifteen Game

    Tests state-space search (DFS with memoization), heuristic design, and simulation benchmarking for a deterministic 36-card solitaire game.

    Software Engineering FundamentalsOnsiteBacktrackingGame TheoryHeuristics
  • MetaMediumSoftware Engineer
    Execute Dependency-Constrained Work at Scale

    This problem tests the ability to design an execution engine that manages task dependencies using a directed acyclic graph (DAG), respects concurrency limits, and handles task failures.

    Software Engineering FundamentalsOnsiteConcurrencyGraphSystem Design
  • MetaMediumSoftware Engineer
    Explain ACID and isolation levels

    This question evaluates a candidate's knowledge of database transactions, the ACID properties (Atomicity, Consistency, Isolation, Durability), and common isolation levels (Read Uncommitted, Read Committed, Repeatable Read, Serializable), testing competency in concurrency control and data consistency.

    Software Engineering FundamentalsOnsite
  • MicrosoftMediumSoftware Engineer
    Debug a Numerical Underflow in an A/B Testing Analytics Repo When the AI Agent Is Wrong

    An AI-assisted debugging exercise set in a multi-file A/B testing analytics codebase with five reported issues, centered on a numerical underflow that makes a sequential test stall on large experiments. It tests triage under a time limit, numerical root-cause analysis, and judging when an AI agent's proposed fix is wrong.

    Software Engineering FundamentalsOnsite
  • MicrosoftMediumSoftware Engineer
    Deep-Clone a Hand-Built Doubly Linked List with an Arbitrary Special Pointer

    Implement your own doubly linked list whose nodes also carry a special pointer to any node in the list, then write a deep clone without using a built-in list type or adding fields to the node class. It tests pointer handling, mapping nodes by identity, edge cases such as null or self pointers, and proving the copy is fully independent.

    Software Engineering FundamentalsOnsite
  • MicrosoftMediumSoftware Engineer
    Design a Dictionary for Heterogeneous Key and Value Types

    Design a heterogeneous dictionary with explicit type-aware equality, hashing, collision resolution, variable-length ownership, resizing, and persistence boundaries.

    Software Engineering FundamentalsOnsite
  • MicrosoftMediumSoftware Engineer
    Discuss mutexes, memory alignment, polymorphism, idempotency

    This question evaluates understanding of concurrency control (mutexes and synchronization), memory alignment and layout, object-oriented polymorphism, and idempotent operations, encompassing key Software Engineering Fundamentals and systems-level concepts.

    Software Engineering FundamentalsOnsite
  • MicrosoftMediumSoftware Engineer
    Explain Python, Java, and Memory Management

    This question tests your understanding of language runtimes, memory management strategies, and the trade-offs between managed environments like Python and JVM-based languages like Java.

    Software Engineering FundamentalsOnsiteJavaPythonGarbage Collection
  • MicrosoftMediumMachine Learning Engineer
    Explain a project deeply

    This question assesses the candidate's depth of ownership over a previous machine learning project, specifically testing their ability to articulate system design choices, technical trade-offs, and operational resilience.

    Software Engineering FundamentalsOnsiteSystem DesignMLOpsArchitecture
  • MicrosoftMediumSoftware Engineer
    Implement a Thread-Safe Per-Key Ordered Executor

    Implement per-key FIFO task execution with thread-safe submission, bounded global concurrency, ready-key scheduling, and exception-safe slot release.

    Software Engineering FundamentalsOnsite
  • MicrosoftMediumSoftware Engineer
    Implement the Linux cp Command, Then Explain Its OS and C++ Internals

    A low-level engineering exercise to implement the Linux cp command in C++ and then explain what happens beneath it. It tests system calls, short writes and error handling, the page cache and kernel-assisted copying, and RAII-based management of file descriptors.

    Software Engineering FundamentalsOnsite
  • MicrosoftMediumSite Reliability Engineer
    Live troubleshooting: diagnose and mitigate very high CPU on a public-facing service

    Live troubleshooting scenario for a senior reliability role: a public-facing service shows very high CPU, and you must keep answering what you would check next. It tests impact-first triage, separating traffic growth from per-request regressions, profiling, and weighing rollback, scaling, throttling and asynchronous queueing.

    Software Engineering FundamentalsOnsite
  • MicrosoftMediumSoftware Engineer
    Respond to a Reliability Regression Shortly After Deployment

    Respond to a post-deployment latency or reliability regression with scoped diagnosis, safe rollback decisions, customer-impact measurement, and prevention.

    Software Engineering FundamentalsOnsite
  • MicrosoftMediumSoftware Engineer
    Thread Safety, Deadlock Prevention, and Arrays vs Linked Lists

    A rapid-fire software engineering fundamentals round covering what makes code thread-safe, what a deadlock is, the main ways to prevent, avoid or recover from deadlocks, and how arrays and linked lists compare. It tests precise definitions, concrete examples and practical trade-offs such as lock ordering and cache locality.

    Software Engineering FundamentalsOnsite
  • MicrosoftMediumSite Reliability Engineer
    When to automate operations work, and good-enough versus excellent automation

    Reliability engineering discussion question: explain your philosophy on automating operational work to free engineers for development, your bar for good-enough versus excellent automation, and where automation stops being worth it. It tests toil measurement, cost-benefit reasoning, safety guardrails and concrete examples.

    Software Engineering FundamentalsOnsite
  • MillenniumMediumSoftware Engineer
    C++ Atomics, Memory Ordering, and Safe Publication

    Understand C++ atomics, relaxed counters, acquire-release publication, lost updates, and when multi-field invariants still require a mutex.

    Software Engineering FundamentalsOnsite
  • MillenniumMediumSoftware Engineer
    Debug missing output in Python async HTTP flow

    This question evaluates understanding of asynchronous programming in Python, including event loop management and async I/O semantics, and is categorized under Software Engineering Fundamentals with a focus on practical application of concurrency concepts.

    Software Engineering FundamentalsOnsite
  • MillenniumMediumSoftware Engineer
    GCC, Clang, LLVM, and C++ Compiler Optimization

    Compare GCC, Clang, and LLVM compilation stages, optimization trade-offs, undefined behavior, and methods for investigating generated-code differences.

    Software Engineering FundamentalsOnsite
  • MillenniumMediumSoftware Engineer
    How a C++ Mutex Protects Shared State

    Explain C++ mutex ownership, memory visibility, RAII locking, contention, and deadlock prevention with a shared-counter example.

    Software Engineering FundamentalsOnsite
  • MintlifyMediumBackend Engineer
    Design a CRUD API for a document service

    Design the create, read, update and delete API for a document service, covering the resource model, endpoints, request shapes and status codes. It tests REST fundamentals plus production concerns such as concurrent edits, idempotent retries, pagination, authorization, deletion semantics and API versioning.

    Software Engineering FundamentalsOnsite
  • MintlifyMediumSoftware Engineer
    Recreate a Card Interface from a Screenshot

    Recreate a screenshot-defined card and chip component through extracted design tokens, accessible semantics, responsive layout, and visual comparison.

    Software Engineering FundamentalsOnsite
  • MintlifyMediumBackend Engineer
    Should you add an index for a slow query on a large table's unindexed columns?

    A query on a large database table is slow and the columns it filters on have no index: should you add one? It tests reading query plans, weighing selectivity and query frequency against write cost, designing composite or partial indexes, and building an index safely on a busy production table.

    Software Engineering FundamentalsOnsite