Snowflake
A small, bank-driven loop: a handful of coding families recur, and the follow-ups plus your own test cases decide a round more than the base problem does. Prompts often start on a blank page with no signature, so clarify, pick the interface and write the tests yourself. System design is infrastructure — a job scheduler, a key-value store, an ACL service — and the interviewer drills one mechanism until the hour ends.
Typical loop
- 1Recruiter screen: ~30 min — background, location, work authorization
- 2Some applicants: a ~20 min AI-conducted voice pre-screen on two projects, a conflict, and how you use AI tools
- 3Technical phone screen: two 45–60 min CoderPad rounds — usually both coding, sometimes one coding and one system design
- 4Onsite, often in person: three to four 60 min rounds — one or two coding, one system design, one behavioral; some loops add a project deep dive or an AI-augmented coding round
- 5Team matching: hiring-manager and teammate chats, still evaluative
Questions
Callback's practice questions and the LeetCode questions Snowflake has been asking, filtered together.
Practice questions
Behavioral · The most common behavioral prompt, told in STAR: a disagreement where you changed the outcome, or changed your mind.
Frontend · List state done right: keys, controlled input, and deletes.
System Design · Metadata plane vs data plane, chunk replication, and the atomic-commit moment.
Algorithms & Data Structures · An undo log per open transaction: rollback replays it, commit hands it to the parent.
Algorithms & Data Structures · A tree of nodes keyed by path segment — the OOD-style prompt where the implementation is the test.
Frontend · Immutable board updates, gravity in dropPiece, and a win check that only looks through the last move.
Frontend · Two arrays and one Set of checked ids — get a working version fast, then polish.
Algorithms & Data Structures · A queue of admitted timestamps per key: evict what aged out, admit while under the limit.
Design and Scale a Yelp-like Reviews Platform
System Design · Geo plus text search over a read-heavy model, with review writes fanned out through queues to aggregates and the index.
Implement Array.prototype.flat
Frontend · Depth, holes and Infinity — without recursion, so 100,000 levels can't overflow the stack.
Frontend · Cycles, shared references, Date, RegExp, Map, Set, prototypes and symbol keys: everything spread and JSON get wrong.
Frontend · A closure over a Map keyed on every argument — and has, not truthiness, so 0 and undefined still hit.
Tic-Tac-Toe: N by N, M in a Row
Frontend · A board of any size, a win check that looks only through the last move, and a status line for turn, winner or draw.
Frontend · Store results by index, count down, resolve an empty input at once, reject on the first failure.
Frontend · Collect arguments until fn.length have arrived — with a fresh array per call so partials stay independent.
Frontend · A leading call, then at most one call per window — with a trailing call that carries the latest arguments.
Nearest Bathroom for Every Desk
Algorithms & Data Structures · Seed the queue with every bathroom and expand once — one BFS for the whole floor, not one per desk.
Algorithms & Data Structures · One pass and two remembered indexes — the last person and the last cake seen.
Algorithms & Data Structures · Nearest-cake greedy is wrong; with both lists sorted, an optimal matching never crosses, so a 2-D DP finds it.
Algorithms & Data Structures · Courses run in waves, and a wave takes as long as its slowest course.
Tree Height After Deletions II
Algorithms & Data Structures · Delete exactly the non-root nodes whose own subtree is k or more deep — one post-order pass, no DP.
Algorithms & Data Structures · Topological order with a 26-bit mask per node: inherited = AND of the parents, final = (inherited OR allow) AND NOT disallow.
Algorithms & Data Structures · BFS over an implicit graph, fetching each page exactly once.
Algorithms & Data Structures · Store one predecessor per page, not a path per queue entry, and walk it back from the target.
Algorithms & Data Structures · A BFS that keeps going after the target is gone — and the thread-safety story that comes with it.
Dropped Requests Under Two Rules
Algorithms & Data Structures · One queue of accepted timestamps per rule; dropped requests never enter either.
Algorithms & Data Structures · Per-client (tokens, last seen), a tier config read on every call, and an explicit fallback for clients with no valid tier.
Algorithms & Data Structures · Timestamps arrive in order, so each type's list is already sorted and a count is two binary searches.
Algorithms & Data Structures · One register, a dictionary of recorded bodies, and a mode flag that says whether a line runs or is being stored.
Algorithms & Data Structures · A heap of entries with lazy deletion: a task added twice has two entries, and the stale one is skipped on the way out.
Key-Value Store With Prefix Scan
Algorithms & Data Structures · A hash map for the point operations and a sorted key list for the scan — agree the smallest version, then extend.
Algorithms & Data Structures · Two pointers per run: find where the run ends, reverse it in place, carry on from there.
Algorithms & Data Structures · Turn each match into a clipped line range, merge ranges that touch, and print a separator between the groups left.
Algorithms & Data Structures · Recursive descent with one cursor: a value function that dispatches on the next character, and a parser per kind.
Document Store With Boolean Queries
Algorithms & Data Structures · An inverted index plus a tiny expression parser whose values are sets of document ids.
Does This Connect Four Move Win?
Algorithms & Data Structures · Only the four lines through the last move can have changed, so count outward in each direction from it.
Algorithms & Data Structures · Count the pieces, then check who has a line: X leads by one if X won, counts are equal if O won, and both cannot win.
Top K Search Terms, One Vote per User
Algorithms & Data Structures · Dedupe (user, term) pairs before counting, then sort by count with the term as the tie-break.
Top K Selling Books After Each Sale
Algorithms & Data Structures · Totals in a map; the top K is recomputed from the map on each update, or kept in a bounded structure when K is small and the catalogue huge.
Algorithms & Data Structures · Dutch national flag with three pointers, using only getColor and swap — one pass, no counting.
Algorithms & Data Structures · A course may start once any one prerequisite is done: swap the max for a min and relax in topological order.
Algorithms & Data Structures · A deleted node hands its children to its nearest surviving ancestor, so it simply adds no level.
Most Credits With at Most K Classes
Algorithms & Data Structures · Weighted interval scheduling with a count budget: sort by end, binary-search the compatible predecessor, add a dimension for the cap.
Algorithms & Data Structures · Meeting rooms with stations: a bus is reusable only where it arrived, so keep the idle buses per station.
Filter With a Dynamic Blacklist
Algorithms & Data Structures · Emitted items are final; held items wait in publish order and are re-checked whenever a word is unblocked.
Is the Graph Three-Colourable?
Algorithms & Data Structures · Backtracking over the vertices: try each colour not used by a coloured neighbour, undo on failure.
Fewest Coins When Change Is Given
Algorithms & Data Structures · Overpaying can save coins: minimise coins handed over plus coins handed back, over every payment up to one large coin above the price.
Design a Distributed Job Scheduler
System Design · A job store as the source of truth, dispatchers that claim due runs with a unique key, leased workers, and a reaper — then the policies a template answer forgets.
Design a Distributed Key-Value Store
System Design · Non-functional requirements first, then one real decision per layer — and the large-value variant, where the lock must never cover the disk write.
System Design · A durable source of truth for grants, a cache of compiled decisions on the caller's hot path, and a closed fail mode.
System Design · Start from a Queue class, then make every step survive a client, server or network failure in the middle of it.
Design a Control Plane for Cloud Clusters
System Design · Desired state in a consistent store, controllers that reconcile, heartbeating agents, and a failure detector that fences before it replaces.
System Design · Append-only events partitioned by account then time, a hot store for recent queries, object storage for retention, and tamper evidence per account.
Design a Pipeline From Bug Tickets to Generated Pull Requests
System Design · A ticket becomes a row with a state machine, a queue feeds long-running workers, and every step is idempotent because the AI step will be retried.
Design an RPC Layer Over Hand-Written REST Calls
System Design · An interface definition that generates stubs and skeletons, with marshalling, discovery, deadlines, idempotent retries and versioning handled once.
Design a Logging Library for Web and Mobile Clients
System Design · A non-blocking log() into a bounded buffer, flushed by size or time, persisted offline, with a stated policy for what to drop under pressure.
Design a Client for an Unreliable Token Service
System Design · Cache tokens with expiry, refresh ahead of time with jitter, single-flight the refresh, and decide between a slightly stale token and a failed request.
Design a Global Multi-Tenant Quota System
System Design · One usage record per tenant across every service, reserve-then-commit, idempotent usage events, and a chosen point between strict consistency and latency.
Design a Distributed Metrics System
System Design · Agents batch to an ingest tier, a time-series store partitioned by metric and time, downsampling for age — and a hard line on cardinality.
System Design · A frontier of URLs partitioned by host, fetchers that respect per-host limits, dedup by URL and by content, and failure handling that never stalls the crawl.
Count the Nodes in a Tree of Servers
System Design · A request fans down the tree and counts fan back up; messages can be lost or duplicated, so every message carries an id and every handler is idempotent.
The Project You Are Most Proud Of
Behavioral · Your flagship story: the goal, your role, the hardest technical problem, and a measurable result.
Your Most Complex Back-End Work
Behavioral · The same flagship project, told through its hardest design decision.
Your Hardest Situation at Work
Behavioral · A deadline or an incident where you had to cut scope and manage risk.
Behavioral · Declining or reshaping a request, with the reasoning and the result.
Delivering Under a Tight Deadline
Behavioral · What you did when the time was not enough: sequencing, trade-offs, communication.
One Piece of Advice for Your Team
Behavioral · A specific process or technical improvement, its impact, and how you would measure it.
Why Are You Leaving, and Why Snowflake?
Behavioral · Growth you want next, tied to something concrete about the work here.
Behavioral · Named tools, the tasks you use them for, a rough share of your coding, and how you verify the output.
SQL & Data · Writers create new versions instead of overwriting, so readers see a consistent snapshot without blocking writers.
SQL & Data · LSM buffers writes in memory and merges sorted files later; a B-tree updates in place for steadier reads.
SQL & Data · Rows suit point lookups and transactions; columns suit scans and aggregates and compress far better.
SQL & Data · Operators process batches of column values instead of one row at a time, cutting interpretation overhead and using CPU caches well.
SQL & Data · Record the change durably before applying it, so a crash can be replayed.
SQL & Data · Read committed, repeatable read, snapshot, serializable — know which anomaly each permits.
SQL & Data · Database storage, independent compute warehouses, and a cloud services layer — a hybrid of shared-disk and shared-nothing.
SQL & Data · Immutable 50–500 MB columnar chunks created automatically, with per-column metadata that lets queries skip them.
System Design · Prepare on all participants, then commit; it blocks if the coordinator dies after prepare.
System Design · A leader replicates a log to a majority before committing; a new leader is elected by majority vote.
Document Coverage: The Shortest Window
Algorithms & Data Structures · Minimum window over tokens: expand until every term is covered, shrink while it stays covered, keep the shortest.
Pick the Query Type That Maximises Revenue
Algorithms & Data Structures · Committing to one type, you run it floor(k / duration) times; score every type and keep the best, earliest on ties.
Reach a Target With +2, Double and Halve
Algorithms & Data Structures · Any sequence counts, so think constructively: +2 keeps parity, doubling then +2s then halving shifts it, and halving is how you get smaller.
Drop and Remove Runs in a Grid
Algorithms & Data Structures · Mark every horizontal and vertical run of three or more, clear them all at once, let columns fall, and repeat until nothing is marked.
Algorithms & Data Structures · Kahn's queue over course objects; a failed attempt goes to the back of the queue and its dependants stay locked until it passes.
Algorithms & Data Structures · A failure is explained if something it depends on, transitively, failed first; the unexplained failures are the root causes.
Algorithms & Data Structures · A recursive-descent parser: a command's operand is either an integer or a parenthesised sub-program evaluated from zero.
Count the Nodes of a Tree by Messages
Algorithms & Data Structures · A node asks every neighbour except the one that asked it, sums the replies plus one, and remembers answers so duplicates are harmless.
Algorithms & Data Structures · Pre-order with explicit end-of-word marks and parentheses around children; parsing it back is a recursive descent.
Pre-Order Traversal Skipping Marked Nodes
Algorithms & Data Structures · A pre-order walk with a stack; a marked node is dropped before its children are pushed, so its whole subtree disappears.
Delete a Node From a Forest Stored as a Parent Array
Algorithms & Data Structures · Children of the deleted node are re-parented to its parent; a deleted root's children become roots.
Rewrite Two Complete Trees With Subtree Sums
Algorithms & Data Structures · In array form the children of i are 2i + 1 and 2i + 2, so merge by index and accumulate sums from the last index down.
Design an Interactive SQL Notebook or Query Execution Service
System Design · A query is a record with a state machine: submit returns an id at once, workers stream results to storage, and clients fetch by id, never by connection.
Design a Multi-Tenant Interactive Analytics Platform
System Design · Immutable columnar files in object storage, a transactional metadata service that commits snapshots, and stateless compute that scales per tenant.
Design a Metadata Catalog and Schema Registry
System Design · Versioned entities in a consistent store partitioned by tenant, a per-tenant change log that caches subscribe to, and soft deletes for undrop.
Design a Cache for a DAG of Materialized Views
System Design · Key every entry by the view, its definition hash and the snapshot versions of all its inputs, so a changed input is a new key and nothing needs explicit invalidation.
Design a Multi-Core Service Startup Scheduler
System Design · Kahn's algorithm with a ready queue and M running slots, where a service unblocks its dependants only after its health check passes and the longest remaining chain goes first.
Design a Multi-Region API Whose Clients Need Tokens From a Flaky Third Party
System Design · Cache what the provider would tell you — signing keys, introspection results, permissions — so a provider outage degrades the API instead of taking it down.
SQL & Data · A window frame of six preceding rows is right only when every day has a row; fill the calendar first.
Extract Fields From a JSON Column
SQL & Data · Path into the document for scalars, cast them explicitly, and flatten arrays into rows before aggregating.
Frontend · Columns of cards with immutable moves: one pure moveCard function serves the buttons and the drag-and-drop alike.
Frontend · State in one object, a pure toggle that flips a cell and its neighbours, one delegated click listener, and a render from state.
Algorithms & Data Structures · A queue with an index pointer, a visited set marked on enqueue, neighbours in the order given.
Algorithms & Data Structures · Split in half, sort each half, merge with two indices — stable, O(n log n), and the merge is the whole interview.
Algorithms & Data Structures · A priority queue of tentative distances; a node's distance is final the first time it is popped.
Frontend · A map from event name to listener list; copy the list before emitting so listeners can unsubscribe mid-emit.
Frontend · Primitives by value (NaN equals NaN), arrays by length and elements, plain objects by key set and values, recursively.
Frontend · A recursive serializer with the real rules: undefined vanishes from objects but becomes null in arrays, and strings need escaping.
Frontend · Two stacks: a new value pushes the old one onto undo and clears redo; undo and redo move values between them.
Frontend · Derive the 64 squares in render — no board in state — then add selection and a move with one piece of state.
Frontend · Keyboard movement with walls and edges, then a breadth-first path to the nearest candy walked one cell at a time.
Frontend · Remember the order cells were lit; when all are lit, a self-re-arming timeout switches them off in reverse.
Frontend · A shuffled deck, at most two face-up ids, a set of matched faces, and one effect that resolves each pair.
Frontend · Two intervals owned by one effect keyed on the running flag, and a round that ends when the clock hits zero.
Frontend · Two corners in state and a derived rectangle; pointer events on cells plus one document listener for the release.
Frontend · A flat array of 225 colours, a palette, draw and erase modes, and a stroke that paints while the pointer is held.
Frontend · Store only the leaves; every parent's checked and indeterminate state is derived from the leaves beneath it.
Frontend · Three pieces of state — page, page size, sort — and rows derived from them in render.
Frontend · A recursive component over nested data, with a set of expanded ids as the only state.
Frontend · A state copy of the value and one effect whose cleanup cancels the pending update on every change.
Asked on LeetCode
164 questions · all time
- Happy NumbereasyHash TableMathTwo PointersFloyd's Cycle Finding Algorithmfrequency 100.0
- Parallel Courses IIIhardArrayDynamic ProgrammingGraph TheoryTopological Sort+1frequency 99.2
- Course Schedule IImediumDepth-First SearchBreadth-First SearchGraph TheoryTopological Sortfrequency 96.7
- Design In-Memory File SystemhardHash TableStringDesignTrie+1frequency 96.7
- Minimum Window SubstringhardHash TableStringSliding Windowfrequency 91.8
- Word Search IIhardArrayStringBacktrackingTrie+1frequency 89.6
- Calculate Amount Paid in TaxeseasyArraySimulationfrequency 85.6
- Painting the WallshardArrayDynamic Programmingfrequency 85.6
- Step-By-Step Directions From a Binary Tree Node to AnothermediumStringTreeDepth-First SearchBinary Tree+2frequency 85.6
- Throne InheritancemediumHash TableTreeDepth-First SearchDesignfrequency 85.6
- Trapping Rain WaterhardArrayTwo PointersDynamic ProgrammingStack+1frequency 85.6
- Find All Anagrams in a StringmediumHash TableStringSliding Windowfrequency 82.6
- Maximum Profit in Job SchedulinghardArrayBinary SearchDynamic ProgrammingSortingfrequency 82.6
- Count Vowel Substrings of a StringeasyHash TableStringfrequency 80.9
- Maximum Number of Upgradable ServersmediumArrayMathBinary Searchfrequency 77.1
- String TransformationhardMathStringDynamic ProgrammingString Matchingfrequency 74.9
- Course SchedulemediumDepth-First SearchBreadth-First SearchGraph TheoryTopological Sort+1frequency 72.5
- Find the Maximum Length of a Good Subsequence ImediumArrayHash TableDynamic Programmingfrequency 72.5
- Minimum Array Length After Pair RemovalsmediumArrayHash TableTwo PointersBinary Search+2frequency 72.5
- Find the Maximum Length of a Good Subsequence IIhardArrayHash TableDynamic Programmingfrequency 69.8
- Merge k Sorted ListshardLinked ListDivide and ConquerHeap (Priority Queue)Merge Sort+1frequency 69.8
- Minimum Absolute Difference Between Two ValueseasyArrayEnumerationfrequency 69.8
- Number of Ways to Form a Target String Given a DictionaryhardArrayStringDynamic Programmingfrequency 69.8
- Parallel CoursesmediumGraph TheoryTopological SortDirected Acyclic Graphfrequency 69.8
- Max Area of IslandmediumArrayDepth-First SearchBreadth-First SearchUnion-Find+1frequency 66.7
- Simplify PathmediumStringStackfrequency 66.7
- Top K Frequent ElementsmediumArrayHash TableDivide and ConquerSorting+4frequency 66.7
- Two SumeasyArrayHash Tablefrequency 66.7
- Basic CalculatorhardMathStringStackRecursionfrequency 63.2
- Boundary of Binary TreemediumTreeDepth-First SearchBinary Treefrequency 63.2
- Maximum Number of Events That Can Be AttendedmediumArrayGreedySortingHeap (Priority Queue)frequency 63.2
- Shortest Word DistanceeasyArrayStringfrequency 63.2
- Time Based Key-Value StoremediumHash TableStringBinary SearchDesignfrequency 63.2
- Copy List with Random PointermediumHash TableLinked Listfrequency 59.1
- Design Add and Search Words Data StructuremediumStringDepth-First SearchDesignTriefrequency 59.1
- LRU CachemediumHash TableLinked ListDesignDoubly-Linked Listfrequency 59.1
- Maximum Number of Events That Can Be Attended IIhardArrayBinary SearchDynamic ProgrammingSortingfrequency 59.1
- Merge Two Sorted ListseasyLinked ListRecursionfrequency 59.1
- Remove Sub-Folders from the FilesystemmediumArrayStringDepth-First SearchTriefrequency 59.1
- Task SchedulermediumArrayHash TableGreedySorting+2frequency 59.1
- Web CrawlermediumStringDepth-First SearchBreadth-First SearchInteractivefrequency 59.1
- Web Crawler MultithreadedmediumDepth-First SearchBreadth-First SearchConcurrencyfrequency 59.1
- Design HashMapeasyArrayHash TableLinked ListDesign+1frequency 54.0
- Design Hit CountermediumArrayBinary SearchDesignQueue+1frequency 54.0
- Design Log Storage SystemmediumHash TableStringDesignOrdered Setfrequency 54.0
- Insert Delete GetRandom O(1)mediumArrayHash TableMathDesign+1frequency 54.0
- Maximize Distance to Closest PersonmediumArrayfrequency 54.0
- Min StackmediumStackDesignfrequency 54.0
- Single Element in a Sorted ArraymediumArrayBinary Searchfrequency 54.0
- Snapshot ArraymediumArrayHash TableBinary SearchDesign+1frequency 54.0