Design a distributed counter service accessed concurrently by many users. The service must provide atomic increment/decrement and read-after-write consistency, scale horizontally, and remain correct under retries and failures. Describe the data model and APIs, the concurrency-control strategy (e.g., optimistic CAS, per-key sharding with single-writer, or distributed locks), and how you handle idempotency, leader election, partition tolerance, clock skew, and exactly-once vs at-least-once semantics. Explain monitoring and rollback strategies for contention hotspots.

This question evaluates expertise in distributed systems architecture, concurrency control, strong consistency models, idempotency under retries, fault tolerance, leader election, and operational monitoring for high-throughput services.

How do I approach System Design interview questions?

System Design questions require understanding of core concepts and practice. PracHub provides solutions with explanations to help you master system design interviews.

What difficulty level is this interview question?

This is a hard difficulty System Design question, commonly asked during Technical Screen rounds at NVIDIA.

What role is this question designed for?

This question is commonly asked for Software Engineer candidates at NVIDIA during technical interviews.

Design a distributed multi-user counter | NVIDIA Interview Question

Design a Horizontally Scalable Distributed Counter Service

Context

You are designing a distributed counter service used concurrently by many clients. A counter is an integer identified by a key (e.g., user:123:likes). The system must support very high throughput, be resilient to failures, and provide strong semantics for updates.

Assume counters fit within signed 64-bit integers, and the service may run across multiple data center racks within a single region.

Requirements

Functional
- Atomic increment and decrement operations per counter key.
- Strong read-after-write consistency for a client immediately after a successful update.
- Idempotent behavior under client retries (no double-apply).
- Optional batch operations for efficiency.
Non-functional
- Horizontal scalability across many nodes.
- High availability within a region; tolerate node and network failures.
- Monitoring to detect contention hotspots and safe rollback/mitigation strategies.

Deliverables

Describe:

Data model and APIs.
Concurrency control strategy (choose and justify among optimistic CAS, per-key sharding with single-writer, or distributed locks). Detail the read and write paths.
How you ensure idempotency and correctness under retries and failures.
Leader election and membership management.
Partition tolerance choices (CAP trade-offs), handling of clock skew, and discussion of exactly-once vs at-least-once semantics.
Monitoring for hotspots, and mitigation/rollback strategies when a single key becomes contended.

Context

Assume counters fit within signed 64-bit integers, and the service may run across multiple data center racks within a single region.

Requirements

Functional

Atomic increment and decrement operations per counter key.
Strong read-after-write consistency for a client immediately after a successful update.
Idempotent behavior under client retries (no double-apply).
Optional batch operations for efficiency.

Non-functional

Horizontal scalability across many nodes.
High availability within a region; tolerate node and network failures.
Monitoring to detect contention hotspots and safe rollback/mitigation strategies.

Deliverables

Describe:

Data model and APIs.

Concurrency control strategy (choose and justify among optimistic CAS, per-key sharding with single-writer, or distributed locks). Detail the read and write paths.

How you ensure idempotency and correctness under retries and failures.

Leader election and membership management.

Partition tolerance choices (CAP trade-offs), handling of clock skew, and discussion of exactly-once vs at-least-once semantics.

Monitoring for hotspots, and mitigation/rollback strategies when a single key becomes contended.

Design a distributed multi-user counter

Quick Overview

Design a Horizontally Scalable Distributed Counter Service

Context

Requirements

Deliverables

Solution

Comments (0)

Design a distributed multi-user counter

Quick Overview

Design a Horizontally Scalable Distributed Counter Service

Context

Requirements

Deliverables

Solution

Comments (0)