Amazon·Software Engineer·Onsite - System Design / Architecture·Senior

Senior

May 2026

Summary

Amazon system design round for a software engineer role, centered entirely on one meaty question about building a real-time top-K product ranking system. Pretty intense for a single question but they went deep on every layer of it.

Questions Asked (1)

Design a class that consumes a stream of product events (each with a timestamp, product ID, and event type like view, add-to-cart, or purchase) and supports querying the current top-K products at any time. Event types have configurable weights. You need to implement update(event) and query_top_k(k), and optionally support queries over a sliding time window. Cover tie-breaking rules, time complexity requirements for both operations, choice of data structures, memory constraints, replay/backfill handling, and thread safety.

System DesignAlgorithms & Data StructuresTechnical Trade-offs

Author's notes

This one sprawled in every direction and I kept second-guessing myself on where to start.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and assumptions, then propose a data structure that efficiently supports updates and top-K queries, such as a hash map for product scores combined with a heap or balanced tree for ordering. Discuss trade-offs for sliding window support, tie-breaking, and concurrency, and analyze time and space complexity for each operation.

Pro tip: Demonstrate awareness of real-world constraints by mentioning how you would handle out-of-order events and late data, and how you would ensure consistency during replay or backfill without blocking queries.

1. Clarify Requirements and Assumptions

Ask about expected event volume, query frequency, K size, window size, and whether events can be out-of-order or late. Confirm tie-breaking rules and thread-safety needs.

2. Design Core Data Structures

Propose a hash map to store product scores and a max-heap or balanced BST to maintain top-K ordering. Explain how updates modify scores and maintain the heap/tree.

3. Address Sliding Window and Replay

For sliding window, suggest a time-bucketed approach or a deque of events with incremental score updates. For replay/backfill, discuss idempotent updates and handling out-of-order events.

4. Analyze Complexity and Trade-offs

State time complexity for update (O(log N) or O(1) with lazy updates) and query_top_k (O(K log N) or O(K)). Discuss memory usage and alternatives like approximate algorithms for large scale.

5. Ensure Thread Safety and Scalability

Mention synchronization mechanisms (locks, concurrent data structures) or partitioning strategies to handle concurrent updates and queries without contention.

Key Points to Mention

Tie-breaking rules: e.g., break ties by product ID or most recent event timestamp.
Time complexity: update should be O(log N) or better; query_top_k should be O(K log N) or O(K) with a heap.
Data structures: hash map for scores, heap or balanced tree for top-K, and time-bucketed queues for sliding window.
Memory constraints: consider bounded memory with approximate algorithms (e.g., count-min sketch) for high-cardinality products.
Replay/backfill: handle out-of-order events using event-time processing and watermarks; ensure idempotent updates.
Thread safety: use read-write locks, concurrent hash maps, or partition by product ID to allow concurrent updates and queries.

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