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

SeniorPrefer not to say

Jun 2026

Summary

Snowflake system design round for a software engineering role. The whole thing was one meaty design problem about real-time trending search, and they pushed pretty hard on the tradeoffs once you got past the surface-level answer.

Questions Asked (1)

Design a system that returns the top-K trending search terms within a sliding time window, where repeated searches of the same word by the same user count only once.

System DesignAlgorithms & Data StructuresTechnical Trade-offs

Author's notes

This one took me a minute to even scope correctly.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements (K, window size, definition of 'trending', scale, latency). Then propose a high-level architecture using a streaming pipeline with per-user deduplication, windowed aggregation, and a top-K data structure, discussing trade-offs between accuracy and efficiency.

Pro tip: Mention that exact top-K with sliding windows is expensive, so consider approximate algorithms like Count-Min Sketch with a heap, and discuss how to handle late data and out-of-order events.

1. Clarify Requirements

Ask about K, window size (e.g., 5 minutes), sliding vs tumbling, scale (QPS, unique users), latency, and whether exact or approximate results are acceptable.

2. High-Level Architecture

Propose a streaming pipeline: ingest searches, deduplicate per user per window, aggregate counts, and compute top-K. Use a distributed stream processor like Flink or Kafka Streams.

3. Deduplication Strategy

For each user, track the set of search terms seen in the current window (e.g., using a Redis set or in-memory state with TTL) to count each term only once per user per window.

4. Windowed Aggregation and Top-K

Maintain counts per term in the window using a sliding window aggregation. For top-K, use a min-heap of size K or approximate sketches (Count-Min Sketch) for scalability.

5. Trade-offs and Optimizations

Discuss trade-offs: exact vs approximate, memory vs accuracy, handling late data, and scaling via sharding by term or user. Mention eviction policies and periodic recomputation.

Key Points to Mention

Sliding window semantics: window size, slide interval, and how to handle out-of-order events (watermarks).
Per-user deduplication: using a set with TTL or a Bloom filter for memory efficiency.
Top-K algorithms: min-heap for exact top-K, Count-Min Sketch + heap for approximate, or Space-Saving algorithm.
Scalability: partitioning by search term or user, using distributed stream processing (e.g., Flink, Spark Streaming).
Trade-offs: exact vs approximate, latency vs accuracy, memory vs throughput.
Fault tolerance and state management: checkpointing, exactly-once processing, and recovery.

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