Stripe·Software Engineer·Technical Phone Screen·Senior

SeniorPrefer not to say

May 2026

Summary

Stripe technical phone screen for a software engineering role. One meaty algorithmic problem that looked like a simple matching exercise until the follow-up questions started piling on.

Questions Asked (1)

Given a list of payments, a list of invoices, and a numeric tolerance value, implement a matching algorithm that applies three layered rules: first match by invoice ID, then by exact amount (earliest date wins), then by amount within the tolerance range (again earliest date wins). Return matched pairs and any unmatched items. Also discuss data structures for efficient range lookups on amount and how processing order affects results.

Algorithms & Data StructuresSystem DesignTechnical Trade-offs

Author's notes

I got the first two layers down pretty quickly, the id lookup is just a hashmap and the exact-amount fallback is another map keyed by amount.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the problem requirements and edge cases, then outline a layered matching algorithm that processes rules in order, using appropriate data structures for efficient lookups. Discuss the impact of processing order on matching outcomes and justify your design choices with trade-offs.

Pro tip: Emphasize the importance of deterministic tie-breaking (e.g., earliest date) and consider using a balanced BST or sorted list for range queries to achieve O(log n) lookups, which is crucial for large datasets.

1. Clarify Requirements and Edge Cases

Ask about input sizes, data formats, tolerance inclusivity, and whether matches should be one-to-one. Confirm if multiple matches are possible and how to handle ties.

2. Design Layered Matching Algorithm

Process rules sequentially: first match by invoice ID, then by exact amount (earliest date), then by amount within tolerance (earliest date). Ensure each payment/invoice is matched at most once.

3. Choose Efficient Data Structures

For invoice ID matching, use a hash map. For amount-based matching, use a balanced BST or sorted list to support range queries and earliest date retrieval efficiently.

4. Analyze Processing Order Impact

Explain how the order of processing payments or invoices can affect which items get matched, especially when multiple candidates exist. Discuss strategies to ensure fairness or optimize matches.

5. Discuss Trade-offs and Complexity

Compare time/space complexity of different approaches (e.g., sorting vs. BST) and justify your choices based on expected data size and performance requirements.

Key Points to Mention

Use a hash map for O(1) invoice ID lookups.
For amount range queries, a balanced BST (e.g., TreeMap) or sorted array with binary search enables O(log n) lookups.
Tie-breaking by earliest date requires storing dates and comparing when multiple matches exist.
Processing order can lead to different matchings; consider sorting by date or using a greedy approach with priority queues.
Ensure each payment and invoice is matched at most once; track matched items to avoid duplicates.
Discuss time complexity: O(n log n) for sorting, O(n log n) for BST operations, and overall O(n log n) for the algorithm.

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