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

SeniorPrefer not to say

Apr 2026

Summary

Databricks system design round, and they went straight for a full chat server implementation. Not just high-level architecture either, they wanted to get into threading models, synchronization, scaling, the works. Left feeling like I'd only scratched the surface on a few of the deeper topics.

Questions Asked (1)

Design and implement a multi-threaded chat server that supports both 1:1 and group messaging, tracks online presence, and persists message history. Walk through your thread model choices, how you'd handle shared state, back-pressure, and scaling across multiple processes.

System DesignTechnical Trade-offs

Author's notes

This sprawled in a way I wasn't ready for.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale, then propose a thread-per-connection model with a thread pool for message processing, using concurrent data structures for shared state. Discuss trade-offs between consistency and availability, and outline a scaling strategy using a message broker and sharding.

Pro tip: Emphasize that back-pressure and failure handling are as important as the happy path; mention using bounded queues and circuit breakers to prevent cascading failures.

1. Clarify Requirements and Scale

Ask about expected number of concurrent users, message throughput, latency requirements, and consistency needs. This shapes all subsequent design decisions.

2. Design Thread Model and Shared State

Propose a thread-per-connection model with a thread pool for message processing. Use concurrent collections (e.g., ConcurrentHashMap) for online presence and message queues, and discuss locking strategies for group membership.

3. Handle Back-pressure and Reliability

Describe bounded queues per connection to apply back-pressure, and discuss how to handle slow consumers (e.g., disconnect or drop messages). Mention persistence via write-ahead logs or a database with batching.

4. Scale Across Processes

Introduce a message broker (e.g., Kafka) for inter-process communication, shard users across servers, and use a distributed cache (e.g., Redis) for presence. Discuss consistency trade-offs and failure recovery.

5. Summarize Trade-offs and Alternatives

Conclude by comparing your choices (e.g., thread-per-connection vs. event loop) and justify based on requirements. Mention potential bottlenecks and how to monitor them.

Key Points to Mention

Thread-per-connection vs. event-driven (e.g., Netty) and when to choose each
Concurrent data structures (ConcurrentHashMap, ConcurrentLinkedQueue) for shared state
Back-pressure mechanisms: bounded queues, blocking vs. dropping, and flow control
Persistence strategies: write-ahead log, database batching, and message durability
Scaling with message brokers (Kafka) and sharding for horizontal scalability
Presence tracking with distributed caches (Redis) and heartbeat mechanisms

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