Stripe·Software Engineer·Technical Phone Screen·Intermediate

Intermediate

May 2026

Summary

Stripe coding screen, felt more like a design discussion than a pure coding problem. The question was straightforward on the surface but the edge case conversation took up most of the time.

Questions Asked (1)

Implement an AccountScheduler class that tracks whether a given account is currently locked at a specific timestamp, given a list of known account ids and a mapping of account ids to their lock expiry timestamps.

API & IntegrationsSystem DesignTechnical Trade-offs

Author's notes

The core implementation wasn't the hard part, just a dict lookup and a comparison.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the requirements and constraints, such as the expected operations, data volume, and concurrency needs. Then design a class that uses a hash map to store account lock expiry timestamps, and for each query, check if the account exists and if the current timestamp is before the expiry. Discuss trade-offs between different data structures and consider edge cases like expired locks and unknown accounts.

Pro tip: Mention that you would use a concurrent data structure or synchronization to handle concurrent access, as Stripe's systems are highly concurrent. Also, discuss how you might extend the design to support distributed locking if the scheduler needs to scale across multiple instances.

1. Clarify Requirements

Ask questions to understand the expected operations (e.g., lock, unlock, isLocked), input formats, and performance requirements. Confirm whether the scheduler needs to be thread-safe and if it should handle distributed scenarios.

2. Design Data Model

Choose a data structure to store account lock information. A hash map mapping account IDs to expiry timestamps is efficient for O(1) lookups. Consider whether to store all known accounts or only locked ones.

3. Implement Core Logic

Implement the isLocked method: check if the account exists in the map and if the current timestamp is before the expiry. Handle edge cases like expired locks (which should be considered unlocked) and unknown accounts.

4. Address Concurrency and Scalability

Discuss how to make the class thread-safe (e.g., using ConcurrentHashMap or synchronized methods) and how the design could be extended for distributed systems (e.g., using Redis with TTL).

5. Test and Validate

Outline test cases: locked account before expiry, after expiry, unknown account, and concurrent access. Mention the importance of unit tests and possibly property-based testing.

Key Points to Mention

Use a hash map for O(1) lookup of lock expiry timestamps.
Handle expired locks by treating them as unlocked (e.g., by comparing timestamps).
Consider thread safety with concurrent data structures or synchronization.
Discuss scalability and distributed locking (e.g., Redis with TTL) for production systems.
Clarify requirements upfront: operations, performance, concurrency, and persistence.
Edge cases: unknown accounts, null inputs, clock skew, and time zone handling.

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