Databricks interview notes, page 12 of 22

Large Enterprises

Most of these Databricks write-ups come from Software Engineers (192), then Machine Learning Engineers (9) and Data Scientists (8). The most reported rounds are the technical phone screen (136), the system design round (57), the behavioral / leadership round (9) and the onsite coding round (6).

216 interview notes · updated Jul 2026

Databricks·Backend Engineer·Technical Phone Screen

May 2026

Databricks backend screen, pretty focused on string algorithms. One coding problem with a follow-up on scaling, nothing too wild but the scale discussion is where it got interesting.

Given a string and a pattern, find the first substring in the string that is an anagram of the pattern.
How would you scale your solution if the input string were extremely large, say distributed across multiple machines?

“Basically a sliding window problem.”

View Post

Databricks·Software Engineer·Technical Phone Screen

May 2026

Databricks coding screen focused entirely on run-length encoding, both directions. Pretty standard on the surface but they pushed hard on edge cases and the conversation got more interesting than I expected.

Implement a run-length encoder that compresses consecutive identical characters into the character followed by its count, always including the count even for single characters (e.g. 'aaabbc' becomes 'a3b2c1').
Implement the decode function that inverts the encoding, assuming the input alphabet contains no digits.
What edge cases should be handled, and how would the design change if the input alphabet could contain digits?

“Got the basic loop working fine, track current char and a counter, flush when it changes.”

View Post

Databricks·Software Engineer·Technical Phone Screen

May 2026

Databricks coding round, one problem the whole time. File system tree traversal, nothing too wild, but the setup took a minute to wrap my head around.

You're given a file system modeled as a tree. Directory nodes can have children (other directories or files), and file nodes have an is_encrypted flag. Write a function that recursively traverses the tree from a given directory and returns a tuple of (encrypted_count, unencrypted_count).

“Pretty clean once I stopped second-guessing the base case.”

View Post

Databricks·Software Engineer·Technical Phone Screen

May 2026

Databricks software engineer interview with a classic tic-tac-toe design problem, scaled up to n x n. Pretty standard coding round but the follow-up on optimization kept things interesting.

Design and implement a class that supports an n x n Tic-Tac-Toe game for two players. After each move, return which player won (or 0 if nobody has yet).

“My first instinct was to just scan the whole board after every move, which works but felt lazy.”

View Post

Databricks·Software Engineer·Onsite - System Design / Architecture

May 2026

System design round at Databricks focused entirely on building a durable in-memory key-value cache with a Write-Ahead Log. Pretty deep dive, more than I expected for a single question.

Design an in-memory key-value cache that uses a Write-Ahead Log for durability and crash recovery. Walk through the write path, read path, recovery mechanism, WAL management, and the trade-offs between durability and write latency.

“This one sprawled in a way I wasn't fully prepared for.”

View Post

Databricks·Software Engineer·Technical Phone Screen

May 2026

Databricks SWE interview with a grid-based algorithm problem that sounds deceptively clean on the surface but has enough moving parts to trip you up if you're not careful about how you handle multiple transportation modes and their separate BFS traversals.

You have an m x n grid representing a city, and an array of transportation modes where each mode has its own movement rules, passable cells, step sizes, and costs. For each mode, run a BFS from start to destination, then return the minimum cost across all modes. Implement this and walk through the time complexity in terms of m, n, and the number of modes.

“The BFS part wasn't the hard bit.”

View Post

Databricks·Software Engineer·Technical Phone Screen

May 2026

Databricks technical screen focused on a data structure design problem that sounds deceptively simple until you're actually in it. The question was meaty enough that I was still thinking about edge cases after the call ended.

Design a 'lazy array' data structure that supports set(i, v), get(i), and a range update like fill(l, r, v) or addRange(l, r, v). Point queries must return the correct value accounting for all pending updates. Discuss the technique you'd use (lazy propagation on a segment tree, or layered diff arrays) and the time complexity of each operation.

“I started with the diff array approach because it felt simpler to explain, but then the interviewer pushed on what happens when you mix set() calls with range updates and suddenly my clean O(1) range update story falls apart.”

View Post

Databricks·Software Engineer·Technical Phone Screen

May 2026

Databricks coding interview centered on a single IP filtering problem using CIDR notation. The interviewer walked through the concept before diving in, which was a nice touch, but the resolution policy discussion is where things got interesting.

Given a list of CIDR rules each labeled as approve or reject, and a query IP address, determine whether the IP is approved or rejected.

“The parsing part was fine, converting each CIDR block to a network and prefix length or a start/end interval isn't that bad.”

View Post

Databricks·Software Engineer·Technical Phone Screen

May 2026

Databricks coding round with a simulation problem that looked straightforward until the follow-up hit. The core question was fine but the extension tripped me up a bit.

Given a falling Tetris-style block, an array representing the environment with column heights and obstacles, and a horizontal offset for where the block enters, compute how many steps the block falls before it lands. Follow-up: update and print the environment state after the block settles.

“The falling simulation part I handled okay.”

View Post

Databricks·Software Engineer·Onsite - Coding / Algorithms

May 2026

Databricks software engineering interview with three back-to-back technical problems covering graph algorithms, dynamic programming, and interval manipulation. The questions were solid and felt like they were testing whether you actually think about edge cases rather than just pattern-match to a known solution.

You have a directed weighted graph where each edge has a travel time and a transport mode (walk, bus, subway, bike). Given a source, destination, and a set of allowed modes, find the minimum-time path using only edges whose mode is in the allowed set. Describe your algorithm and analyze complexity. Follow-up: if all modes are allowed, what changes?
Given n non-negative integers representing cash in houses arranged in a circle, find the maximum amount you can steal if you cannot rob two adjacent houses and the first and last houses count as adjacent.
Given a sorted list of non-overlapping half-open intervals, implement a function that deletes a given interval from the list, splitting existing intervals as needed. Follow-up: how would you handle a high-throughput stream of delete operations efficiently with bounded memory?

“Pretty much Dijkstra with a pre-filter step.”

View Post