Pure Storage·Software Engineer·Onsite - System Design / Architecture·Senior

SeniorPrefer not to say

May 2026

Summary

Pure Storage system design round, pretty deep on the internals of a timer/scheduler system. The question had more moving parts than I expected and I spent way too long on the heap before they nudged me toward the concurrency angle.

Questions Asked (2)

Design a timer and event-scheduling system with a schedule(eventId, delayMs, callback) API and a cancel(eventId) method. Walk through the internal data structures, how the worker thread operates, and how you'd handle event ordering.

System DesignAlgorithms & Data StructuresTechnical Trade-offs

Author's notes

I went straight to the min-heap keyed on fire time, which was the right call, but I got too deep into heap implementation details before talking about the worker thread at all.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements (single vs multi-threaded, precision, scale) and then propose a min-heap keyed by expiration time for efficient ordering, combined with a hash map for O(1) cancellation. Describe a worker thread that sleeps until the earliest event, wakes to execute due callbacks, and handles new events or cancellations via a condition variable and a lock.

Pro tip: Mention that using a single worker thread avoids concurrency issues but can be a bottleneck; propose a thread pool with consistent hashing or multiple heaps for scalability, and discuss how to handle long-running callbacks without blocking the scheduler.

1. Clarify Requirements and Constraints

Ask about expected scale (number of events, frequency), precision needs, whether callbacks can be long-running, and if the system should be distributed. This shapes data structure and threading choices.

2. Design Core Data Structures

Use a min-heap (priority queue) ordered by expiration time to efficiently find the next event. Maintain a hash map from eventId to heap node (or a wrapper) to support O(1) cancellation and updates.

3. Implement the Worker Thread

A dedicated thread waits on a condition variable until the earliest event's time. It pops due events, executes callbacks, and handles new events or cancellations by re-evaluating the wait time. Use a mutex to protect shared state.

4. Handle Event Ordering and Edge Cases

For events with the same expiration time, use FIFO ordering (e.g., by insertion sequence) or allow a priority field. Handle cancellation by marking nodes as cancelled (lazy deletion) or removing from heap (O(log n)).

5. Discuss Trade-offs and Scalability

Compare single-threaded vs thread pool, heap vs timing wheel, and in-memory vs distributed. Mention how to avoid busy-waiting, handle clock drift, and ensure thread safety.

Key Points to Mention

Min-heap (priority queue) for O(log n) insertion and O(1) peek of next event.
Hash map for O(1) cancellation by eventId, with lazy deletion or direct removal.
Condition variable and mutex to efficiently wait for the next event without busy-waiting.
FIFO ordering for events with identical expiration times, or a secondary priority.
Thread safety: locking around shared data structures and callback execution.
Scalability options: multiple worker threads with partitioned heaps or a timing wheel for high-throughput scenarios.

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

How would you handle time advancement in this system: real wall-clock time versus a simulated tick-based clock? What are the trade-offs and when would you use each?

Technical Trade-offsSystem Design

Author's notes

This was the follow-up I wasn't ready for.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the system's requirements: does it need to model real-world time, or is it a deterministic simulation? Then compare real wall-clock time (simple, but non-deterministic and hard to test) with a simulated tick-based clock (deterministic, controllable, but requires abstraction). Conclude with a recommendation based on use cases like testing, debugging, and production behavior.

Pro tip: Mention that you can abstract time behind an interface (e.g., a Clock interface) so you can swap implementations without changing business logic. This shows you think about testability and maintainability, which is highly valued at Pure Storage.

1. Clarify requirements

Ask about the system's purpose: is it a simulation, a real-time system, or a test environment? Determine if determinism, reproducibility, or real-world accuracy is more important.

2. Define real wall-clock time

Explain that real time uses the system clock (e.g., System.currentTimeMillis()) and is simple but non-deterministic, making tests flaky and debugging hard.

3. Define simulated tick-based clock

Describe a tick-based clock where time advances in discrete steps, often manually controlled. It offers determinism, reproducibility, and easy testing but may not reflect real-world timing.

4. Compare trade-offs

Discuss trade-offs: real time is simple but non-deterministic; simulated time is deterministic but requires abstraction and may not catch real-world timing issues. Consider performance, complexity, and testability.

5. Recommend and abstract

Recommend using an abstraction (e.g., Clock interface) to allow switching between implementations. Use real time in production and simulated time in tests or simulations.

Key Points to Mention

Determinism and reproducibility in testing
Abstraction of time via an interface (e.g., Clock)
Performance implications of each approach
Use cases: simulation, testing, production
Handling timeouts and scheduling
Debugging and logging with timestamps

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