Pinterest·Data Scientist·Technical Phone Screen·Senior

SeniorPrefer not to say

Jul 2026

Summary

Pinterest Data Scientist interview with a system design flavored coding question around streaming data. The problem was well-scoped but the follow-up on distribution is where things got interesting.

Questions Asked (1)

Design a data structure that continuously ingests a stream of integers and can return the top-K largest values seen so far at any point. How would you scale this for very large K or across distributed data streams?

Algorithms & Data StructuresSystem DesignTechnical Trade-offs

Author's notes

Started with a min-heap of size K which felt right, and they seemed fine with that.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the problem constraints (e.g., stream rate, memory limits, exact vs approximate top-K, distributed setup). Then propose a min-heap of size K for the single-stream case, analyzing time and space complexity. Finally, discuss scaling strategies such as approximate algorithms (Count-Min Sketch, Space-Saving) for large K and distributed aggregation (e.g., mergeable summaries, MapReduce) for multiple streams.

Pro tip: Mention that for very large K, exact top-K may be infeasible due to memory, so approximate algorithms with probabilistic guarantees are often preferred in production systems like Pinterest. Also, highlight the trade-off between accuracy and resource usage, and how to handle skewed data distributions.

1. Clarify Requirements and Constraints

Ask about stream characteristics (rate, volume), K size, memory limits, exact vs approximate results, and whether the system is distributed. This ensures your solution aligns with practical needs.

2. Design Single-Stream Solution

Propose a min-heap of size K to maintain the top-K elements. Explain insertion logic: if heap size < K, add; else if new element > heap root, replace root and heapify. Analyze time complexity O(log K) per element and space O(K).

3. Address Scaling for Large K

Discuss that when K is very large, exact heap may not fit in memory. Introduce approximate algorithms like Count-Min Sketch with a heap, or Space-Saving algorithm, which use sub-linear space and provide probabilistic guarantees.

4. Scale Across Distributed Streams

For distributed data, propose merging local top-K summaries from each node. Use a coordinator to merge heaps or sketches, or employ MapReduce with combiners. Mention challenges like communication overhead and synchronization.

5. Evaluate Trade-offs and Optimizations

Compare exact vs approximate, memory vs accuracy, and centralized vs distributed. Suggest optimizations like batching, sampling, or using specialized data structures (e.g., Fibonacci heap for faster decrease-key).

Key Points to Mention

Min-heap of size K for exact top-K with O(log K) insertion and O(1) retrieval of top-K.
Approximate algorithms (Count-Min Sketch, Space-Saving) for large K with sub-linear space and error bounds.
Distributed aggregation: merge local top-K heaps or sketches, using MapReduce or stream processing frameworks (e.g., Apache Flink, Spark Streaming).
Trade-offs: exact vs approximate, memory vs accuracy, latency vs throughput.
Handling skewed data: use algorithms robust to heavy hitters (e.g., Misra-Gries, Frequent).
Real-world considerations: fault tolerance, scalability, and integration with existing systems (e.g., Pinterest's data pipeline).

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