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

SeniorPrefer not to say

Jun 2026

Summary

NVIDIA system design round for a software engineering role. One meaty question about designing a build event ingestion system with top-K query support. The pseudocode-only requirement sounds relaxed until they start asking about complexity and scale.

Questions Asked (1)

Design a system that ingests a stream of build events (each with a target ID and timestamp) and supports two operations: recording a new event, and querying the top-K most-built targets, optionally filtered by a time range.

System DesignAlgorithms & Data StructuresTechnical Trade-offs

Author's notes

I started with the all-time case since that felt simpler: just a hashmap from target ID to count, then a min-heap of size K to get the top results.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements: event rate, latency, consistency, and query patterns. Then propose a scalable architecture using a distributed stream processor and a time-series database, with a two-level index for efficient top-K queries. Discuss trade-offs between exact and approximate counting, and how to handle time-range filters.

Pro tip: Emphasize that top-K queries over sliding windows are best served by a combination of a time-partitioned store and a heap-based aggregation, and mention that approximate algorithms like Count-Min Sketch can reduce memory at the cost of accuracy—showing you understand real-world trade-offs.

1. Clarify Requirements and Scale

Ask about event volume, query frequency, latency SLAs, and whether approximate results are acceptable. Determine if the system needs to handle out-of-order events and how far back queries typically go.

2. High-Level Architecture

Propose a pipeline: ingest via a message queue (e.g., Kafka), process with a stream processor (e.g., Flink) that maintains counts per target, and store aggregated data in a time-series database (e.g., Druid, TimescaleDB) for fast range queries.

3. Data Structures for Top-K

For each time window, maintain a min-heap of size K to track top targets, or use a Count-Min Sketch for approximate counts. Discuss how to merge results across windows for arbitrary time ranges.

4. Query Processing and Optimization

For a time-range query, retrieve pre-aggregated counts from the time-series store, then compute top-K using a heap or by sorting. Consider caching frequent queries and using indexes on target ID and timestamp.

5. Trade-offs and Scalability

Discuss trade-offs: exact vs. approximate counting, memory vs. accuracy, latency vs. consistency. Explain how to scale horizontally by partitioning by target ID or time, and how to handle hot targets.

Key Points to Mention

Use of a distributed message queue (e.g., Kafka) for ingestion to handle high throughput and decouple producers/consumers.
Time-based partitioning of data to efficiently support time-range queries and sliding windows.
Min-heap or priority queue for maintaining top-K targets per window, with O(log K) update cost.
Approximate counting algorithms (e.g., Count-Min Sketch) to reduce memory footprint when exact counts are not required.
Pre-aggregation and materialized views in a time-series database to speed up queries.
Handling out-of-order events using watermarks or event-time processing in stream engines.

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