← Snap Interview InsightsSoftware Engineer

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

SeniorPrefer not to say
Jun 2026

Summary

Snapchat system design round, one big question that sprawled across basically every infrastructure topic I'd ever read about. Felt like they wanted to see how far you could go before you started hand-waving, and I definitely hit that ceiling a few times.

Questions Asked (1)

Q1

Design a metrics platform that handles ingestion from many services, stores data efficiently for real-time and historical use, supports configurable alerting with low latency, and can answer product-level queries like daily active users alongside low-level system metrics. Walk through the ingestion pipeline, storage choices with rollups, alerting evaluation, and whether product and infrastructure metrics should share the same pipeline.

System DesignTechnical Trade-offsProduct Analytics & Metrics
Author's notes

This question kept growing.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale, then walk through the end-to-end pipeline from ingestion to query, explicitly addressing trade-offs at each stage. Emphasize how you'd separate or unify product and infrastructure metrics based on their distinct characteristics, and justify your storage and alerting choices with latency and cost considerations.

Pro tip: At Snapchat's scale, the volume and cardinality of product metrics (e.g., DAU) are enormous, so consider a dedicated columnar store like Druid or ClickHouse for product analytics, while using a time-series database like Prometheus or M3 for infrastructure metrics—this avoids forcing one system to do everything poorly.

1. Clarify Requirements and Scale

Ask about data volume, ingestion rate, query latency SLAs, retention periods, and the number of services and metrics. This ensures your design targets the right constraints.

2. Design Ingestion Pipeline

Propose a scalable ingestion layer using a message queue (e.g., Kafka) to decouple producers from consumers, handle backpressure, and enable multiple downstream consumers for real-time and batch processing.

3. Choose Storage and Rollup Strategy

Select storage engines based on access patterns: time-series DB for infrastructure metrics, columnar store for product analytics. Implement rollups (e.g., 1m, 1h, 1d) to balance query speed and storage cost.

4. Implement Alerting Evaluation

Design a low-latency alerting system that evaluates rules on streaming data (e.g., using Flink or a stream processor) and supports configurable thresholds, with deduplication and notification channels.

5. Decide on Unified vs. Separate Pipelines

Compare trade-offs: a unified pipeline simplifies operations but may not optimize for both high-cardinality product metrics and high-frequency infrastructure metrics. Recommend a hybrid approach with shared ingestion but specialized storage/query layers.

Key Points to Mention

  • Use of Kafka or similar for ingestion to handle high throughput and enable real-time and batch consumers.
  • Time-series databases (e.g., Prometheus, M3) for infrastructure metrics with downsampling and retention policies.
  • Columnar stores (e.g., Druid, ClickHouse) for product analytics to support fast aggregations over high-cardinality dimensions.
  • Rollup strategies (pre-aggregation) to reduce query latency and storage costs for historical data.
  • Stream processing (e.g., Flink, Kafka Streams) for low-latency alert evaluation and anomaly detection.
  • Trade-offs between unified and separate pipelines: operational simplicity vs. performance optimization and cost.

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