← Verkada Interview InsightsSoftware Engineer

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

SeniorPrefer not to say
Jun 2026

Summary

System design round at Verkada focused entirely on large-scale IoT monitoring. One meaty question, lots of follow-ups, and I definitely underestimated how deep they wanted to go on the aggregation side.

Questions Asked (1)

Q1

Design a system that monitors 10 million cameras, each sending a heartbeat signal once per minute. The system needs to report healthy vs unhealthy device counts in near real time. Walk through ingestion, storage, how you'd mark a device unhealthy using a sliding window, fault tolerance, and how you'd make aggregation queries fast.

System DesignTechnical Trade-offsData Modeling
Author's notes

I started with the ingestion layer and felt pretty solid there, load balancers feeding into a partitioned message queue sharded by device ID, nothing too surprising.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale (10M devices, 1 heartbeat/min = ~167K writes/sec). Then propose a horizontally scalable ingestion layer (e.g., Kafka) feeding a time-series database or a custom store optimized for writes and sliding-window queries. Finally, detail the sliding-window logic, fault tolerance via replication and partitioning, and aggregation strategies like pre-computed rollups or materialized views.

Pro tip: Emphasize that the system must handle device clock skew and network delays; use event-time processing with watermarks to avoid false positives. Also, discuss cost trade-offs between storing raw heartbeats vs. aggregated state.

1. Clarify Requirements and Scale

Confirm the number of devices, heartbeat frequency, definition of 'unhealthy' (e.g., no heartbeat for 2 minutes), and query patterns (real-time counts, historical trends). Calculate write throughput (~167K/sec) and storage needs.

2. Design Ingestion Pipeline

Propose a scalable, fault-tolerant ingestion layer using a distributed message queue (e.g., Kafka) with partitioning by device ID. Ensure backpressure handling and idempotent writes.

3. Choose Storage and Data Model

Select a time-series database (e.g., InfluxDB, TimescaleDB) or a custom store (e.g., Cassandra) that supports high write throughput and efficient range queries. Model data as (device_id, timestamp) with TTL for raw data and aggregated counters.

4. Implement Sliding Window for Health Status

Use a stream processing framework (e.g., Flink, Kafka Streams) to maintain a sliding window per device (e.g., last 2 minutes). Emit health status changes when a device misses heartbeats, handling out-of-order events with watermarks.

5. Optimize Aggregation Queries and Fault Tolerance

Pre-aggregate healthy/unhealthy counts per time bucket (e.g., every 10 seconds) using a rollup table or materialized view. Ensure fault tolerance via replication, checkpointing, and multi-AZ deployment.

Key Points to Mention

  • Partitioning by device ID to distribute load and enable parallel processing.
  • Using event-time processing with watermarks to handle late/out-of-order heartbeats.
  • Sliding window implementation: maintain per-device last-seen timestamp and evaluate health on a timer or on each heartbeat.
  • Pre-aggregation and caching (e.g., Redis) for fast dashboard queries.
  • Fault tolerance: replication factor, Kafka replication, database replication, and idempotent producers.
  • Trade-offs: cost of raw storage vs. aggregated state, latency vs. accuracy in health detection.

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