← Optiver Interview Insights

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

Senior
May 2026

Summary

System design round at Optiver for a software engineering role, focused entirely on building a pub/sub notification service from scratch. Pretty intense depth of coverage, they wanted everything from class design to scaling to millions of users.

Questions Asked (1)

Q1

Design an object-oriented publish/subscribe notification service that supports user-topic subscriptions. Include APIs for subscribing, unsubscribing, publishing news, and acknowledging delivery. Cover class design, data modeling, concurrency, failure handling, and how you'd scale to millions of users.

System DesignData ModelingTechnical Trade-offs
Author's notes

This was the whole interview basically.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale, then design a clean object-oriented model with core classes and interfaces. Walk through the API design, concurrency handling, failure scenarios, and scaling strategies, emphasizing trade-offs at each step.

Pro tip: Optiver values low-latency and high-throughput systems, so highlight how your design minimizes latency (e.g., in-memory queues, async delivery) and handles backpressure. Also, discuss idempotency and at-least-once delivery semantics to show maturity.

1. Clarify Requirements and Scale

Ask questions to understand expected throughput, latency, delivery guarantees, and user/topic scale. Confirm whether the system is push-based or pull-based, and if acknowledgments are required for all messages.

2. Design Core Classes and Interfaces

Define classes like User, Topic, Subscription, Notification, and interfaces for Publisher, Subscriber, and NotificationService. Specify methods for subscribe, unsubscribe, publish, and acknowledge.

3. Model Data and Storage

Choose data stores for user-topic mappings (e.g., in-memory cache, distributed KV store) and message queues (e.g., Kafka, Redis). Discuss partitioning and indexing for efficient lookups.

4. Address Concurrency and Failure Handling

Explain thread-safety using locks, concurrent data structures, or actor model. Describe retry mechanisms, dead-letter queues, and idempotent acknowledgment to handle failures.

5. Scale to Millions of Users

Propose horizontal scaling with sharding by user/topic, load balancing, and caching. Discuss trade-offs between consistency and availability, and how to handle hot topics.

Key Points to Mention

  • Delivery guarantees: at-least-once vs. exactly-once, and how acknowledgments ensure reliability.
  • Concurrency patterns: thread pools, async I/O, lock-free data structures, or actor-based models.
  • Failure handling: retries with exponential backoff, dead-letter queues, and idempotency keys.
  • Scaling strategies: sharding, partitioning, replication, and use of distributed message brokers.
  • API design: clear separation of concerns, versioning, and rate limiting.
  • Trade-offs: consistency vs. latency, push vs. pull, and cost vs. performance.

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