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 991–1020 of 1208 results

  • SigmacomputingMediumSoftware Engineer
    Build a pivot table class over shirt sales records with running and grand totals

    Implement a class that stores shirt sales records and builds pivot tables summing shirts sold by any row field and column field, then extend it with running totals and grand totals along both axes. It tests object-oriented structure, aggregation with dictionaries, deterministic layout, and consistency between cells and totals.

    Software Engineering FundamentalsTechnical Screen
  • SnapchatHardSoftware Engineer
    Compare WebSocket, SSE, and long polling

    This question tests a software engineer's depth in web networking fundamentals, covering real-time communication protocols and the OSI and TCP/IP models. It assesses practical knowledge of WebSocket, SSE, and long polling trade-offs, as well as understanding of how modern transport protocols like QUIC differ from TCP in multiplexing, handshake latency, and connection migration.

    Software Engineering FundamentalsOnsite
  • SnapchatMediumSoftware Engineer
    Design and Implement a Thread-Safe LRU Cache

    Design an `O(1)` LRU cache and extend it with clear thread-safety semantics. The solution covers hash-map and doubly linked-list invariants, boundary cases, linearization points, single-lock correctness, sharding trade-offs, eviction callbacks, and concurrent testing.

    Software Engineering FundamentalsTechnical Screen
  • SnapchatMediumSoftware Engineer
    Find Duplicate Files with a Hand-Written Directory Traversal

    This problem tests iterative directory traversal techniques, efficient file hashing strategies to handle large data, and the ability to manage edge cases like file system inconsistencies or symbolic links.

    Software Engineering FundamentalsTechnical ScreenFile SystemHashingIteration
  • SnapchatHardSoftware Engineer
    Implement an iOS scrollable grid with navigation

    This question tests the ability to build a responsive, performance-optimized grid interface in iOS using modern frameworks like SwiftUI, focusing on layout constraints, state management, and navigation flow.

    Software Engineering FundamentalsOnsiteiOSSwiftUILayout
  • SnapchatMediumSoftware Engineer
    Stream Records into Clusters and Track Each Cluster's Maximum and Median

    Design and implement an in-memory component that assigns each record of a data stream to an existing or a new cluster and returns the maximum value of every cluster. Follow-ups probe read and write optimizations, concurrent ingestion, and how to report each cluster's median.

    Software Engineering FundamentalsOnsite
  • SnorkelMediumSoftware Engineer
    Design SnapshotMap with Sparse Histories and Constant-Time Snapshots

    Design an in-memory key-value store supporting point-in-time snapshots, sparse version histories, binary-search historical reads, tombstones, and write coalescing.

    Software Engineering FundamentalsTechnical Screendata-structuresbinary-searchsystem-design
  • SnowflakeMediumSoftware Engineer
    Adapt Throne Inheritance When Initialization Does Not Supply a King

    Design a throne inheritance system with an uninitialized monarch, handling dynamic root establishment, pre-order succession, and edge-case validation.

    Software Engineering FundamentalsTechnical Screentreedesigndfs
  • SnowflakeHardSoftware Engineer
    Build a Tiered Rate Limiter With Runtime-Updatable Limits, Then Test and Scale It

    Build an in-memory rate limiting service in Python where clients belong to tiers such as free, pro and enterprise, tier limits change at runtime without a restart, and clients with missing or invalid tiers fall back to a global default policy. Follow-ups probe algorithm trade-offs, deterministic tests for refill timing, and a distributed design.

    Software Engineering FundamentalsTechnical Screen
  • SnowflakeMediumFrontend Engineer
    Build an Arrow-Controlled Kanban Board in React

    Design and implement a performant React Kanban board in TypeScript with normalized state and accessible arrow controls for shifting tasks across ordered columns at scale.

    Software Engineering FundamentalsTechnical Screenreacttypescriptfrontend
  • SnowflakeHardSoftware Engineer
    Clarify and Prune an N-ary Tree to a Depth Limit

    This problem tests tree traversal techniques and recursive state management by requiring the pruning of an N-ary tree nodes based on a depth constraint while maintaining valid structural connectivity.

    Software Engineering FundamentalsTechnical ScreenTreesRecursionData Structures
  • SnowflakeHardSoftware Engineer
    Count a Distributed Tree with Nonblocking Messages

    This problem tests your ability to design a distributed protocol that ensures eventual consistency and message idempotency in a tree-based network without global synchronization.

    Software Engineering FundamentalsTechnical ScreenDistributed SystemsProtocolsTrees
  • SnowflakeMediumSoftware Engineer
    Count the Nodes of a Process Tree Using Only Asynchronous Messages

    Each node of a tree is a separate process that can only send asynchronous messages and block on receive; write the logic that lets the root learn how many nodes exist. Follow-ups cover lost and duplicated messages, retries and idempotency, and how to structure a result that may be incomplete.

    Software Engineering FundamentalsTechnical Screen
  • SnowflakeMediumSoftware Engineer
    Deep-Copy a Linked List Whose Nodes Also Carry a Random Pointer

    Return a deep copy of a singly linked list in which every node also has a random pointer to any node or to nothing, so that the copy shares no node with the original. It tests mapping original nodes to copies, pointer wiring and constant-space alternatives.

    Software Engineering FundamentalsTechnical Screen
  • SnowflakeHardSoftware Engineer
    Design a Priority Task Executor with Duplicate Task IDs

    This problem tests your ability to design a thread-safe task scheduler that handles duplicate task IDs while ensuring each unique task is executed exactly once based on priority and submission time.

    Software Engineering FundamentalsOnsiteConcurrencyHeapsHash Maps
  • SnowflakeHardSoftware Engineer
    Design a Thread-Safe Multi-Rule Rate Limiter

    This problem tests the ability to design a thread-safe, flexible rate-limiting system that handles multiple constraints, atomic permit management, and graceful error handling.

    Software Engineering FundamentalsTechnical ScreenConcurrencyRate-LimitingThread-Safety
  • SnowflakeMediumMachine Learning Engineer
    Design and Implement a Rate Limiter with an AI Assistant, Then Defend and Test It

    Design and implement a rate limiter in an AI-assisted coding round: choose and defend an algorithm against its alternatives, direct an AI assistant to write the code, review it and test it. It tests rate-limiting algorithm trade-offs, concurrency, time handling and critical review of generated code.

    Software Engineering FundamentalsOnsite
  • SnowflakeMediumSoftware Engineer
    Effective Permissions in an Inheritance DAG with Allow and Deny Lists

    Nodes of a directed acyclic graph carry allow and deny permission lists that are inherited along its edges; compute every node's final permissions. It tests topological processing, settling an unstated conflict rule between allow and deny, cycle detection and incremental updates.

    Software Engineering FundamentalsTechnical Screen
  • SnowflakeMediumFrontend Engineer
    Explain React classes, lifecycle, and hooks

    This question assesses the evolution of React component patterns, specifically focusing on the transition from class-based lifecycles to functional hooks, and the management of stateful side effects.

    Software Engineering FundamentalsTechnical ScreenReactFrontendJavaScript
  • SnowflakeMediumSoftware Engineer
    Fewest Link Clicks Between Two Wiki Pages, Then Scale the Search

    Find the fewest link clicks between two wiki pages when each page's links come from a slow fetch call, returning the path. Follow-ups cover parallel level-by-level search, bidirectional search with a correct stopping rule, and caching fetched link lists across searches.

    Software Engineering FundamentalsTechnical Screen
  • SnowflakeMediumSoftware Engineer
    Find the Shortest Click Path with a Fallible Link API

    Implement a breadth-first search to find the shortest URL click path between two pages using a fallible link-fetching API with retry and tie-breaking logic.

    Software Engineering FundamentalsTechnical Screenbfsgrapherror-handling
  • SnowflakeMediumSoftware Engineer
    Implement and Test a Sliding-Window Rate Limiter

    This problem tests your ability to implement an efficient sliding-window algorithm and design a robust testing strategy for a stateful component.

    Software Engineering FundamentalsOnsiteAlgorithmsRate LimitingData Structures
  • SnowflakeMediumSoftware Engineer
    In-Memory Key-Value Store with Constant-Time Nested Transactions

    Build an in-memory key-value store with get, set and delete plus nested begin, commit and rollback, aiming for constant-time operations. Follow-ups extend it to concurrent threads, keys with a time to live, and reads of a key's value at an earlier point in time.

    Software Engineering FundamentalsTechnical Screen
  • SnowflakeMediumSoftware Engineer
    Multiset with O(1) Insert, Remove, and Count-Weighted Random Pick

    Design a collection of integers that allows duplicates and supports insert, remove and a random pick weighted by occurrence count, each in average constant time. Tests array and hash map bookkeeping, careful handling of moved elements during removal, and how to test randomized behavior.

    Software Engineering FundamentalsOnsite
  • SnowflakeMediumSoftware Engineer
    Multithreaded Web Crawler with Retries for a Failing Fetch API

    Write a web crawler that visits every page reachable from a start URL through a slow link-fetching API, first with BFS or DFS, then with multiple threads, then with retries when the API fails. It tests visited-set safety, termination detection, backoff and failure reporting.

    Software Engineering FundamentalsTechnical Screen
  • SnowflakeMediumSoftware Engineer
    Rate Limiter with Tiers, Runtime Config Changes and Multiple Rules

    Implement a rate limiter using a token bucket or sliding window, then support client tiers whose limits change while the service runs, several rules checked on one request, and deterministic tests with a mock clock. It tests algorithm choice, safe configuration swaps and thread-safe all-or-nothing checks.

    Software Engineering FundamentalsTechnical Screen
  • SnowflakeMediumSoftware Engineer
    Serialize a List of Arbitrary Strings into One String and Back, Then Compare Schemes

    A two-part coding question that asks you to pack a list of arbitrary strings, which may contain any character, into a single string and rebuild the identical list from that string alone. It tests unambiguous format design, empty-string edge cases, linear-time parsing and a reasoned comparison of alternative encoding schemes.

    Software Engineering FundamentalsOnsite
  • SnowflakeMediumSoftware Engineer
    Time-Versioned Key-Value Store and Time-Window Event Counter

    Build a key-value store that keeps every timestamped value of a key and returns the value in effect at a given time, then a counter that answers how many events occurred in a time window. It tests binary search over histories, window semantics and memory bounds.

    Software Engineering FundamentalsTechnical Screen
  • SoFiMediumSoftware Engineer
    Explain GC, singleton, and OOP principles

    This question evaluates understanding of Java runtime memory management (generational garbage collection, marking, compaction), software design patterns (Singleton), and object-oriented design and SOLID principles, testing competencies in performance reasoning, concurrency and thread-safety considerations, design trade-offs, and maintainability.

    Software Engineering FundamentalsTechnical Screen
  • SocureHardSoftware Engineer
    Implement a Concurrent Payment Queue with Visibility Timeouts

    Implement a thread-safe in-memory payment queue supporting atomic message consumption, visibility timeouts, receipt-handle validation to prevent stale ACKs, and idempotent submissions.

    Software Engineering FundamentalsTechnical ScreenConcurrencyData StructuresMessage Queues