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 481–510 of 1208 results

  • GoogleEasySoftware Engineer
    Design an ads retrieval service using a heap

    This question tests the ability to design a retrieval system using a priority queue and the implementation of efficient operations to maintain a sorted collection of ad candidates.

    Software Engineering FundamentalsOnsiteHeapPriority QueueData Structures
  • GoogleMediumSoftware Engineer
    Design an editable sequence with marker

    This question evaluates understanding of mutable ordered sequence data structures, marker semantics and invariants, API and data model design, and algorithmic time-complexity trade-offs for insert, delete, and move operations.

    Software Engineering FundamentalsOnsite
  • GoogleHardSoftware Engineer
    Event Topic Router With Named Placeholders and Tail Wildcards

    Build a router for a telemetry message bus that maps dot-separated topics to registered subscription patterns with named placeholders and a trailing multi-segment wildcard; tests trie design, precedence rules and backtracking.

    Software Engineering FundamentalsOnsitetriebacktrackingstring-parsing
  • GoogleMediumSoftware Engineer
    Evolve Duplicate Detection for Sliding Windows and Read-Heavy Queries

    Design a data structure that preprocesses an array in linear time to answer duplicate-within-distance-k queries in constant time.

    Software Engineering FundamentalsTechnical ScreenHash TableSliding WindowArray
  • GoogleHardSoftware Engineer
    Explain SLI/SLO/SLA and design monitoring

    This question evaluates a candidate's competency in service reliability and observability, specifically understanding and distinguishing SLIs, SLOs, and SLAs, planning error budgets, and designing monitoring and alerting for a production web API.

    Software Engineering FundamentalsOnsite
  • GoogleMediumSoftware Engineer
    Explain what happens when you run ls

    This question evaluates a candidate's understanding of process creation and execution, shell command resolution, kernel and VFS filesystem interactions, and how directory entries and file metadata are retrieved; category/domain: Software Engineering Fundamentals.

    Software Engineering FundamentalsTechnical Screen
  • GoogleMediumSoftware Engineer
    Explore the Island at a Given Cell With BFS, Then Count Lakes Enclosed by Land

    Given a satellite image as a grid of land and water cells and a starting cell, traverse the island containing that cell with breadth-first search, then extend the solution to count lakes, bodies of water completely enclosed by land. It tests grid traversal, precise problem definitions, connectivity rules and linear-time flood fill.

    Software Engineering FundamentalsTechnical Screen
  • GoogleMediumSoftware Engineer
    Find the Most Frequent IP Addresses in a File Too Large for Memory

    Find the ten most frequent normalized IP addresses with cutoff ties preserved, first in memory and then exactly through disk partitioning, per-partition aggregation, global thresholding, and skew handling.

    Software Engineering FundamentalsTechnical Screen
  • GoogleMediumSoftware Engineer
    How to handle huge inputs?

    Answer the coding interview follow-up "what if the input is huge?" Covers memory checks, streaming, chunking, external sort, approximate structures, distributed processing, and engineering tradeoffs.

    Software Engineering FundamentalsOnsite
  • GoogleHardSoftware Engineer
    Implement a Lazy Tee Iterator in Python

    This problem tests your understanding of iterator protocols, generator patterns, and memory-efficient data buffering for multi-consumer streams.

    Software Engineering FundamentalsTechnical ScreenPythonIteratorsGenerators
  • GoogleHardSoftware Engineer
    Implement a URL router that matches request paths against patterns with placeholders

    Implement a URL router that registers path patterns with placeholder segments such as {userId} and returns the registered pattern that matches a concrete request path. It tests choosing a segment-level data structure, defining precedence between literal and placeholder matches, and analyzing registration and lookup complexity.

    Software Engineering FundamentalsOnsite
  • GoogleMediumSoftware Engineer
    Implement an HTTP Router That Resolves Handlers for Paths with Named Parameters

    Implement an HTTP router that registers handlers for path patterns, some with named parameters and some without, and looks up the handler and parameter values for a request path. It tests data structure choice, precedence between fixed and parameterized segments, conflict handling and lookup complexity.

    Software Engineering FundamentalsTechnical Screen
  • GoogleMediumSoftware Engineer
    Implement matrix transforms and discuss eigenvalues

    This problem tests your ability to perform in-place 2D matrix transformations and your conceptual understanding of how linear algebraic properties like eigenvalues describe matrix behavior.

    Software Engineering FundamentalsOnsiteArraysMatricesLinear Algebra
  • GoogleMediumSoftware Engineer
    Implement quicksort and a binary search tree, and explain how each works internally

    Implement quicksort and a binary search tree from scratch and explain how each works internally, including partitioning, pivot choice, insertion, search and deletion. Tests correctness invariants, best, average and worst-case complexity, duplicate and sorted inputs, alternative approaches, and how library implementations differ.

    Software Engineering FundamentalsTechnical Screen
  • GoogleMediumSoftware Engineer
    Layer Config Trees with Pluggable Per-Path Merge Strategies

    Combine a default configuration tree with an environment overlay where each path can pick a merge strategy such as deep, override, preserve, concat, union, or keyed list matching, and new strategies plug in without touching the traversal. Tests simultaneous tree recursion, registry-based extensibility, ordering rules and type-conflict handling.

    Software Engineering FundamentalsTechnical Screenrecursiontreesextensibility
  • GoogleMediumSoftware Engineer
    Merge Two YAML Configuration Trees with Per-Node Merge Rules

    Merge two configuration trees parsed from YAML files, where each node can follow its own merge rule, such as recursive merging, replacing, keeping, appending lists, or matching list items by a key field. Tests recursive traversal of two trees, an extensible way to apply many rules, and careful handling of ordering, one-sided keys and type conflicts.

    Software Engineering FundamentalsTechnical Screen
  • GoogleMediumSoftware Engineer
    Process Sharded Login Logs

    This problem tests your ability to design a robust data pipeline for processing sharded, potentially out-of-order login logs from a distributed system.

    Software Engineering FundamentalsOnsiteDistributed SystemsStream ProcessingData Structures
  • GoogleHardSoftware Engineer
    Project Deep Dive: Kafka Streaming, Redis Caching, and a Go Edge API Gateway

    A resume deep dive from a software engineering intern screen: explain a Kafka streaming architecture and Redis caching from past backend work, then defend choosing Go for a distributed edge API gateway and explain how its latency was managed. Tests ownership, trade-off reasoning and failure handling.

    Software Engineering FundamentalsTechnical Screen
  • GoogleMediumSoftware Engineer
    Reason About an Endpoint-Only Interval Score

    This problem tests the understanding of interval arithmetic properties and algorithmic implementation of selection logic in the presence of tied boundary indices.

    Software Engineering FundamentalsOnsiteArraysMathOptimization
  • GoogleHardSoftware Engineer
    Resolve Templated CDN Asset Paths to Their Registered Handlers

    Implement a resolver that registers CDN asset path templates containing placeholder segments and, given a concrete request path, returns the matching template's handler along with the captured placeholder values.

    Software Engineering FundamentalsOnsitetriedata-structuresalgorithms
  • GoogleEasySoftware Engineer
    Shortest Distance Between Two Words, Then a Word-List Class With an Anagram Check

    Find the smallest distance between occurrences of two given words in a list, then build a class over the word list that answers repeated distance queries and checks whether two words are anagrams. It tests linear-time scanning, precomputation for repeated queries, and correct letter-count comparison.

    Software Engineering FundamentalsOnsite
  • GoogleMediumSoftware Engineer
    Track the User with the Most Distinct Contacts: O(1) Query and Top-K for Changing k

    Design a class that records undirected messages between users and returns the user who has talked with the most distinct people, then make that query constant time and add a top-K query whose k changes on every call. It tests deduplication with hash sets, space analysis of per-user sets, and incremental ranking structures.

    Software Engineering FundamentalsTechnical Screen
  • GoogleMediumSoftware Engineer
    Trie-Based URL Router with Path Variables and Catch-All Tails

    Implement a request router that registers path templates with {variable} and {*catch-all} segments and resolves a concrete path to its handler and captured values. Tests trie design, literal-over-variable precedence with backtracking, conflict detection, and lookup complexity.

    Software Engineering FundamentalsTechnical Screentriebacktrackingdesign
  • GrammarlyMediumSoftware Engineer
    Implement a rate limiter and a pub/sub API

    This problem evaluates your ability to implement a thread-safe rate limiter using the token bucket algorithm and design a lightweight, in-memory publisher-subscriber system.

    Software Engineering FundamentalsTechnical ScreenConcurrencySystem DesignAPI Design
  • GustoMediumSoftware Engineer
    Design an Extensible Tax Policy Engine

    Design a modular, versioned tax policy engine that evaluates payroll taxes across different tax years and filing statuses using progressive and flat-rate strategies with deterministic precision.

    Software Engineering FundamentalsOnsiteobject-oriented-designsystem-designclean-code
  • HackerRankMediumSoftware Engineer
    Debug React Sorting, Persistence, Routing, and Accessibility

    This problem tests your ability to identify and rectify common React anti-patterns, including state mutations, improper side-effect handling, and accessibility failures in a data-driven application.

    Software Engineering FundamentalsOnline AssessmentReactJavaScriptAccessibility
  • HadrianHardSoftware Engineer
    Design a Rule-Driven Process Graph Validator

    This problem tests your ability to model dependency constraints in a directed graph and implement an efficient algorithm to validate that a given execution sequence satisfies all structural and ordering requirements.

    Software Engineering FundamentalsOnsiteGraphsValidationAlgorithms
  • HarveyMediumFrontend Engineer
    Build a Virtualized React Spreadsheet with Cell Formulas

    Design and implement a virtualized React spreadsheet component supporting editable cells, formula evaluation with string concatenation, cycle detection, and targeted re-rendering.

    Software Engineering FundamentalsTechnical ScreenReactVirtualizationGraph Algorithms
  • HarveyMediumBackend Engineer
    Explain project decisions and trade-offs

    This question evaluates proficiency in technical decision-making, trade-off analysis, and system design ownership for backend projects, including architecture rationale, technology selection, and the candidate's specific role and measurable impact.

    Software Engineering FundamentalsOnsite
  • HarveyMediumSoftware Engineer
    Find Duplicate Files Safely at Scale

    Design and implement a robust file duplicate finder that handles filesystem cycles, minimizes disk I/O using multi-stage filtering, and avoids loading entire large files into memory.

    Software Engineering FundamentalsTechnical ScreenFile SystemsI/O OptimizationHashing