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 691–720 of 1208 results

  • 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
  • Mistral AIMediumSoftware Engineer
    Keep GPUs Fed with an Efficient Data-Preparation Pipeline

    Diagnose GPU input starvation across storage, CPU preprocessing, batching, transfer, and synchronization, then improve bounded overlap while preserving data correctness.

    Software Engineering FundamentalsTechnical Screen
  • Mistral AIMediumSoftware Engineer
    Set up a Python LLM dev environment

    This question evaluates practical competencies in Python development environment setup, reproducible dependency management with lockfiles, virtual environment and interpreter management, secrets handling via environment variables, project structuring, and basic API integration.

    Software Engineering FundamentalsTechnical Screen
  • MithrilMediumSoftware Engineer
    Debug GPU Resource Allocation

    This problem tests your ability to identify and debug concurrency issues and scheduling logic in a custom GPU resource manager.

    Software Engineering FundamentalsOnsiteConcurrencyDebuggingScheduling
  • ModalMediumSoftware Engineer
    Explain and Harden Two Shell Commands

    Tests deep understanding of Unix shell semantics, process management, file permissions, and standard stream handling by diagnosing subtle failure modes in common shell one-liners and writing robust, production-grade replacements.

    Software Engineering FundamentalsTechnical Screenbashlinuxsystems
  • ModalMediumSoftware Engineer
    Prove an Incremental Shuffle Is Uniform

    Tests formal inductive reasoning on randomized algorithms by proving the uniformity of the Fisher-Yates shuffle, and evaluates practical knowledge of common implementation pitfalls like off-by-one bounds and modulo bias.

    Software Engineering FundamentalsTechnical Screenalgorithmsprobabilityfisher-yates
  • ModalMediumSoftware Engineer
    Sort One Hundred Million Digits

    Implement counting sort to order 100,000,000 single-digit integers using O(1) auxiliary space, and analyze performance from a hardware and memory-bandwidth perspective.

    Software Engineering FundamentalsTechnical Screenalgorithmscounting-sortsystems
  • MomentMediumFrontend Engineer
    Build a Race-Free Memory Card Game in React

    Work through the state and timing logic for a React memory-card game that remains correct under rapid clicks and restarts. The exercise examines stale closures, input locking, timeout cleanup, stable card identity, accessible interaction, and tests for race-prone transitions.

    Software Engineering FundamentalsTechnical Screen
  • MongoDBHardSoftware Engineer
    Build an Exactly-Once Crawler and Add Safe Concurrency

    Build a crawler around a supplied fetch-and-parse API, then add bounded concurrency, atomic discovery, correct completion detection, and explicit failure semantics.

    Software Engineering FundamentalsTechnical Screen
  • MongoDBMediumSoftware Engineer
    Debug a slow concurrent network server under load

    This question tests your ability to diagnose performance bottlenecks in a multi-threaded network server using I/O multiplexing, focusing on how blocking calls and thread management impact latency.

    Software Engineering FundamentalsOnsiteConcurrencyPerformance TuningI/O Multiplexing
  • MongoDBMediumSoftware Engineer
    Evaluate a Nested Predicate Expression Tree

    Implement an evaluator for a serialized predicate expression tree against JSON documents, testing recursion, AST handling, and field resolution.

    Software Engineering FundamentalsTechnical Screenrecursiontreesdesign
  • MongoDBMediumSoftware Engineer
    Explain Modern Python Features and Ecosystem

    This question assesses your depth of knowledge regarding modern Python language evolution, the utility of popular libraries, and internal implementation details that impact memory and performance.

    Software Engineering FundamentalsHR ScreenPythonInternalsMemory Management
  • MongoDBHardSoftware Engineer
    Implement a Finite Concurrent Web Crawler

    Implement an orchestrator for a finite concurrent web crawler featuring transactional URL state tracking, per-host politeness rate-limiting, classified error handling, and robust termination detection.

    Software Engineering FundamentalsOnsiteConcurrencySystem DesignQueues
  • MongoDBMediumSoftware Engineer
    Implement a Lazy Union Iterator Over Two Strictly Sorted Iterators

    Implement a UnionIterator that lazily merges two strictly sorted iterators of integers or strings into one strictly sorted iterator without duplicates, using constant extra memory. Tests iterator protocol design, one-element lookahead, cross-input deduplication, end-of-stream behavior and edge cases such as empty inputs.

    Software Engineering FundamentalsTechnical Screen
  • MongoDBMediumSoftware Engineer
    Implement a sliding-window rate limiter (n requests per k seconds), then make it per key

    Coding and design question from a technical screen: implement a rate limiter that admits at most n requests in any k-second sliding window, then make it thread-safe and key-specific. It tests window boundary semantics, amortized complexity, race conditions and locking, per-key state creation and memory bounds.

    Software Engineering FundamentalsTechnical Screen
  • MongoDBMediumSoftware Engineer
    Reason About Recursive Key Search in Nested JSON

    Implement a recursive search function to extract all values associated with a given key from deeply nested JSON documents containing arbitrary combinations of dictionaries and lists.

    Software Engineering FundamentalsTechnical ScreenRecursionJSONTree Traversal
  • Morgan StanleyMediumData Scientist
    Estimate Greeks and hedging PnL

    This question evaluates understanding of option Greeks (delta, gamma, vega), mental approximation of Gaussian probabilities, and the ability to reason about delta-hedged profit-and-loss under Black-Scholes model misspecification, categorized under Software Engineering Fundamentals for a Data Scientist role.

    Software Engineering FundamentalsTechnical Screen
  • Morgan StanleyEasyData Scientist
    Explain forward contracts and options

    This question evaluates understanding of financial derivatives—specifically forwards and options—assessing competency in financial instruments, contractual rights and obligations, pricing concepts, and how these concepts inform data-driven modeling for a Data Scientist role.

    Software Engineering FundamentalsTechnical Screen
  • NVIDIAMediumSoftware Engineer
    Clarify and Design a Streaming Top-K Tracker

    This question tests the ability to design an efficient data structure for maintaining the top-K elements in a high-throughput stream with time-windowing requirements.

    Software Engineering FundamentalsTechnical ScreenData StructuresAlgorithmsStreaming
  • NVIDIAMediumSoftware Engineer
    Compare Java and Python: Execution, Typing, Concurrency and When to Use Each

    An engineering director asks how Java and Python differ and where each language is stronger or weaker. It tests understanding of execution models, static versus dynamic typing, concurrency and the global interpreter lock, ecosystems, and the judgment to recommend a language for a concrete project.

    Software Engineering FundamentalsOnsite
  • NVIDIAMediumSoftware Engineer
    Count Distinct Strings With a Hand-Built Hash Table, Then Parallelize It for GPUs

    A coding and concurrency question: count the distinct strings in an array with a hash table built from scratch, then keep the count correct when many threads insert at once. It tests hash table design, locks versus atomic compare-and-swap, and how work division and memory layout affect GPU and CPU performance for a million keys.

    Software Engineering FundamentalsTechnical Screen
  • NVIDIAMediumData Engineer
    Data Pipeline Reliability, Backfills, and Spark Optimization

    Prepare for a NVIDIA software engineering interview question about data pipeline reliability, backfills, and spark optimization. The prompt highlights practical reasoning, edge cases, trade-offs, and validation criteria without revealing the model answer.

    Software Engineering FundamentalsTechnical Screen
  • NVIDIAMediumSoftware Engineer
    Define a Git workflow for CI

    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 Define a Git workflow for CI states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

    Software Engineering FundamentalsOnline Assessment
  • NVIDIAMediumSoftware Engineer
    Demonstrate software engineering fundamentals

    This interview question evaluates engineering fundamentals, trade-offs, examples, pitfalls, and operational implications in a realistic interview setting. A strong answer for Demonstrate software engineering fundamentals states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

    Software Engineering FundamentalsOnsite
  • NVIDIAHardSoftware Engineer
    Design a Multi-Producer Multi-Consumer Circular Buffer

    Design a thread-safe, bounded multi-producer multi-consumer (MPMC) circular buffer supporting blocking operations, timeouts, and graceful shutdown (close-and-drain).

    Software Engineering FundamentalsTechnical ScreenConcurrencyData StructuresMultithreading
  • NVIDIAMediumSoftware Engineer
    Design a top-build target tracker

    This problem tests object-oriented design and data structure proficiency by requiring the implementation of a tracker that maintains the top-K most frequent entities within a sliding time window of events.

    Software Engineering FundamentalsTechnical ScreenDesignData StructuresSliding Window
  • NVIDIAMediumSoftware Engineer
    Design an IR for test workflows

    This interview question evaluates algorithm design, data structures, correctness, complexity, edge cases, and implementation details in a realistic interview setting. A strong answer for Design an IR for test workflows states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

    Software Engineering FundamentalsOnline Assessment
  • NVIDIAMediumSoftware Engineer
    Explain Amdahl’s law and GPU matmul optimization

    This question tests the ability to apply Amdahl's Law to real-world hardware acceleration and understand the architectural constraints involved in GPU matrix multiplication.

    Software Engineering FundamentalsTechnical ScreenAmdahl's LawGPU ArchitectureC++ Performance