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

SeniorPrefer not to say

Jul 2026

Summary

Bloomberg system design round, one big question that basically ate the whole session. They wanted a full Kafka-style distributed messaging system and did not let you stay surface-level for long.

Questions Asked (1)

Design a distributed messaging system similar to Apache Kafka. Walk through the producer and consumer APIs, topic and partition model, broker cluster, replication and leader election, consumer groups with offset tracking, message ordering, at-least-once and exactly-once delivery semantics, throughput and latency targets, retention and log compaction, and how you'd scale to millions of messages per second across many topics.

System DesignTechnical Trade-offsAPI & Integrations

Author's notes

This is basically a full hour of design packed into one prompt.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale, then present a high-level architecture covering the log abstraction, partitioning, replication, and consumer groups. Dive into trade-offs for delivery semantics, ordering, and performance, and conclude with scaling strategies and monitoring.

Pro tip: Emphasize how design choices impact operational simplicity and cost; for example, choosing partition count affects parallelism, ordering, and rebalancing overhead. Show awareness of real-world constraints like network partitions and disk I/O.

1. Clarify Requirements and Scale

Ask about expected throughput, latency, durability, ordering guarantees, and geographic distribution to tailor the design.

2. High-Level Architecture

Describe topics, partitions, brokers, producers, consumers, and ZooKeeper/KRaft for metadata, explaining how they interact.

3. Core Components Deep Dive

Detail producer/consumer APIs, replication and leader election, consumer groups with offset tracking, and message ordering guarantees.

4. Delivery Semantics and Trade-offs

Explain at-least-once, at-most-once, and exactly-once semantics, and the trade-offs between them in terms of complexity and performance.

5. Scaling and Operational Considerations

Discuss scaling to millions of messages per second, retention policies, log compaction, monitoring, and failure handling.

Key Points to Mention

Partitioning strategy and its impact on ordering, parallelism, and load balancing
Replication factor, ISR (in-sync replicas), and leader election for fault tolerance
Consumer group coordination and offset commit strategies (auto vs manual)
Exactly-once semantics via idempotent producers and transactional messaging
Throughput optimization: batching, compression, zero-copy, and page cache
Retention policies: time-based, size-based, and log compaction for key-based retention

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