Stripe·Software Engineer·Technical Phone Screen·Intermediate

Intermediate

Jun 2026

Summary

Stripe coding round, graph traversal problem that builds on a merchant-linking concept with weighted field matching. The twist was bounding the search to 2 hops, which sounds simple but has some edge cases that'll bite you if you're not careful.

Questions Asked (1)

Given a graph of merchants linked by weighted field-match scores, find all merchants reachable from a target merchant within at most 2 hops (directly or indirectly linked). Return the full set.

Algorithms & Data StructuresSystem Design

Author's notes

The weighted scoring part from the base problem was already established, so this was really about layering BFS on top of it and capping depth at 2.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Clarify the graph representation (adjacency list) and whether the graph is directed or undirected. Then perform a bounded BFS from the target merchant up to depth 2, collecting all visited nodes. Return the set of reachable merchants, excluding the target itself if required.

Pro tip: Mention that for depth 2, a simple two-level expansion (neighbors of neighbors) is sufficient and more efficient than a full BFS, but BFS generalizes to any depth. Also discuss handling large graphs with distributed processing if needed.

1. Clarify requirements and assumptions

Ask whether the graph is directed or undirected, if the target merchant should be included in the result, and if there are any constraints on graph size or memory.

2. Choose the right traversal algorithm

Select BFS with a depth limit of 2, as it naturally explores level by level and avoids deep recursion. Alternatively, for exactly 2 hops, you can iterate over direct neighbors and their neighbors.

3. Implement the traversal with a visited set

Use a queue to track nodes and their depth, and a set to avoid revisiting nodes. Stop expanding when depth exceeds 2.

4. Handle edge cases and return the result

Consider isolated nodes, cycles, and self-loops. Return the set of reachable merchants, ensuring no duplicates.

5. Analyze complexity and scalability

Discuss time and space complexity (O(V+E) for BFS, but for depth 2 it's O(deg(target) + sum of degrees of neighbors)). Mention how to scale for large graphs using distributed BFS or graph databases.

Key Points to Mention

Graph representation: adjacency list is efficient for sparse graphs; adjacency matrix for dense graphs.
BFS vs DFS: BFS is preferred for shortest path or level-based traversal; DFS could be used but may be less efficient for depth-limited search.
Depth tracking: either store depth with each node in the queue or process level by level.
Visited set: crucial to avoid infinite loops in cyclic graphs and to prevent duplicate processing.
Complexity: for depth 2, time is O(deg(target) + sum of degrees of neighbors), which is often much less than O(V+E).
Scalability: for very large graphs, consider distributed BFS (e.g., Pregel) or using a graph database with built-in traversal.

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.