← Databricks Interview Insights

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

SeniorPrefer not to say
Jun 2026

Summary

Databricks system design round, one big question on distributed key-value stores that went pretty deep. Felt like they wanted to see how far you could push the design before things got hand-wavy.

Questions Asked (1)

Q1

Design a distributed key-value store that supports get, put, and delete on string keys with byte-string values, optional TTL, optional compare-and-swap, horizontal scalability, high availability, configurable consistency, and low tail latency.

System DesignTechnical Trade-offsData Modeling
Author's notes

This one sprawled.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and constraints (scale, latency targets, consistency models) with the interviewer, then propose a high-level architecture using consistent hashing for partitioning and replication for fault tolerance. Dive into the data model, consistency mechanisms (e.g., quorum-based), and optimizations for tail latency, while explicitly discussing trade-offs at each decision point.

Pro tip: Explicitly tie your design choices to Databricks' needs—e.g., how the store could back a feature store or metadata service—and emphasize tail latency mitigation techniques like hedged requests and load shedding, which are critical in large-scale systems.

1. Clarify Requirements and Scope

Ask questions to pin down scale (data size, QPS), latency SLOs (especially p99), consistency requirements (strong vs. eventual), and failure tolerance. This ensures your design targets the right trade-offs.

2. High-Level Architecture

Propose a partitioned, replicated system using consistent hashing for data distribution and a replication protocol (e.g., leader-based or quorum) for availability. Mention a metadata service for cluster membership and failure detection.

3. Data Model and API Semantics

Define how keys map to partitions, how values are stored (e.g., LSM trees for write-heavy workloads), and how TTL and CAS are implemented (e.g., version numbers, timestamps). Discuss atomicity and isolation for CAS.

4. Consistency and Replication

Explain how to achieve configurable consistency (e.g., quorum reads/writes, tunable R+W>N) and handle conflicts (e.g., last-write-wins, vector clocks). Address how CAS works under replication (e.g., consensus per key).

5. Performance and Tail Latency

Detail techniques to reduce tail latency: hedged requests, request prioritization, load shedding, and efficient storage engines. Discuss monitoring and auto-scaling for horizontal scalability.

Key Points to Mention

  • Consistent hashing with virtual nodes for even data distribution and minimal rebalancing.
  • Quorum-based replication (e.g., Dynamo-style) to support configurable consistency levels.
  • LSM-tree storage engine (e.g., RocksDB) for high write throughput and efficient range scans.
  • TTL implementation via expiration timestamps and background compaction or lazy deletion.
  • Compare-and-swap using version numbers or conditional writes with consensus (e.g., Paxos/Raft) for linearizability.
  • Tail latency mitigation: hedged requests, speculative execution, and adaptive timeout/retry policies.

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