Stripe·Software Engineer·Technical Phone Screen·Senior

SeniorPrefer not to say

May 2026Remote

Summary

Stripe coding round, backend-flavored design question about extending a scheduler class. Pretty niche problem that felt more like a systems design warmup than a pure leetcode grind. Left feeling okay about it but not confident I nailed the data structure discussion.

Questions Asked (1)

You're given an AccountScheduler class with methods to check availability and lock accounts for a duration. Add an overload of the acquire method that auto-selects an available account using an LRU policy, and explain what data structures you'd use to make this efficient. Also, what should happen if no account is available at the requested time?

Algorithms & Data StructuresSystem DesignTechnical Trade-offs

Author's notes

The LRU part tripped me up more than I expected.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the requirements and constraints of the AccountScheduler, then propose an efficient data structure like a doubly linked list combined with a hash map to maintain LRU order. Discuss how to handle the case when no account is available, considering options like waiting, throwing an exception, or returning a failure, and justify your choice based on system design principles.

Pro tip: Mention that the LRU policy should be based on the last time an account was acquired, not just its position in a list, and consider thread-safety if the scheduler is used concurrently. Also, discuss how to handle time-based availability efficiently, perhaps using a priority queue or time wheel.

1. Clarify requirements and constraints

Ask questions to understand the expected behavior: Is the scheduler single-threaded or concurrent? What is the granularity of time? Should the LRU be based on last acquisition time or last release time? What are the expected failure modes?

2. Design the data structures

Propose using a doubly linked list to maintain LRU order and a hash map for O(1) access to accounts. For time-based availability, consider a priority queue (min-heap) of accounts sorted by next available time, or a time wheel for efficient scheduling.

3. Implement the acquire overload

Describe the algorithm: check if any account is available at the requested time; if so, select the least recently used one, update its availability, and move it to the front of the LRU list. If not, handle the no-availability case.

4. Handle no availability

Discuss options: throw an exception, return null/optional, block until an account becomes available, or enqueue the request. Choose based on system requirements and explain trade-offs (e.g., blocking vs. non-blocking, fairness).

5. Analyze complexity and trade-offs

Explain the time complexity of operations (O(1) for LRU operations, O(log n) for heap operations) and discuss trade-offs between different data structures (e.g., heap vs. sorted list) and concurrency considerations.

Key Points to Mention

Use a doubly linked list + hash map for O(1) LRU operations.
Consider using a priority queue (min-heap) to efficiently find accounts available at a given time.
LRU should be based on the last time an account was acquired, not just its position.
Handle no availability by throwing an exception, returning an optional, or blocking with a condition variable.
Discuss thread-safety: use locks or concurrent data structures if the scheduler is shared.
Analyze time complexity: O(1) for LRU updates, O(log n) for heap operations, and O(1) for hash map lookups.

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