Doordash Interviews

My DoorDash virtual onsite interview has been approved, and the difficulty level was average. The hiring manager was very nice and kept asking follow-up questions about the impact. In the branding round, I worked on a file system and had to implement a Trie tree. I talked a bit about OOP fundamentals. I managed to write the solution with some difficulty — the codebase was quite large and I didn’t write tests. Follow-up questions: how to handle multithreading, and how to serialize.

The system design round dug deep into my recent project. The system design topic was messaging. They asked follow-up questions about the schema and how messages are sent.

The debugging round was also a high-frequency question (felt like this was the question). The follow-ups didn’t seem to have a single standard answer — I talked about multithreading, edge cases, and monitoring.

I had my interview experience with Doordash, encompassing both a phone screen and a virtual onsite for a 2025 role.

During the Phone Screen, I encountered a question that required me to build an adjacency map for a given tree structure. Following that, I had to determine the time it would take to 'flood' the entire tree, which was an interesting graph traversal problem.

The Virtual Onsite was quite comprehensive, broken down into several distinct rounds:

• Code Craft: This session involved a coding question centered around dasher pay. I was tasked with structuring the code to effectively solve the problem and then demonstrate its execution.
• Debugging: I was presented with a scenario involving a broken round robin network router. My challenge was to identify and fix the issues to ensure all the test cases ran successfully.
• System Design and Domain Knowledge: This combined session had two parts. For Domain Knowledge (DK), I discussed a significant project I had worked on previously. In the System Design (SD) portion, I was asked to design a food review application from scratch.
• Hiring Manager Chat: This was a discussion-based round where I answered questions about my past professional experiences and the key deliverables I was responsible for in previous roles.

I recently went through an onsite interview with DoorDash, which was structured around a debugging exercise. The session began with a 5-minute introduction, followed by a 50-minute hands-on debugging task, and concluded with 5 minutes for Q&A. My primary task was to analyze a main.py file that contained the business logic for a mock Dasher Assignment Service, designed to assign dashers to deliveries. The goal was to pinpoint logic bugs, identify bad design and coding practices, and then improve the codebase, with a strong emphasis on resolving logic issues first. I was provided with several interfaces: User, Dasher, RemoteDeliveryRecordingService (a stubbed logging service), and DeliveryAssignmentService. The DeliveryAssignmentService was the central piece, containing functions like addDasher, pickKey, adjustMap, and pickDasher, which all had subtle but critical logic flaws. After successfully identifying and rectifying these bugs, the interviewer engaged me in a follow-up discussion about additional test cases and how I might further optimize my corrected solution beyond the initial broken implementation.

I recently had my Codecraft round for a Midlevel SWE position at DoorDash. This wasn't a typical LeetCode-style problem; instead, it was a collaborative coding exercise with the interviewer. I found the discussion incredibly engaging, and the interviewer was genuinely present and interested in my thought process, which I really appreciated. I successfully passed this round.

My interview with Doordash focused on a challenging system design problem. I was asked to design a comprehensive system for customers to submit reviews on ordered food items and a mechanism to reward them based on the quality of their contributions. During the discussion, I outlined the high-level architecture, including user-facing components, backend services for review submission and processing, and a sophisticated system for evaluating review quality to disburse monetary rewards. I considered various aspects like data storage for reviews, user profiles, and reward transactions, along with API design for different functionalities. We also touched upon scalability considerations for handling a large volume of reviews and ensuring the fairness and accuracy of the reward system. It was an insightful and engaging session.

During my recent interview with Doordash, I encountered an interesting algorithmic challenge. The main problem revolved around a city map represented as a grid, where I had to determine the shortest distance from various given locations to their closest DashMart. This required careful consideration of open and blocked roads, suggesting a graph traversal algorithm like Breadth-First Search (BFS). A follow-up then extended this by introducing customers and asking to find the DashMart that would serve the maximum number of customers based on proximity. This entire scenario tested my ability to model real-world problems using data structures and algorithms.

I recently went through the DoorDash interview process for a backend role and wanted to share my experience. Unfortunately, I was rejected after completing all rounds.

Round 1: System Design + Domain Knowledge

Round 2: Hiring Manager Discussion

Round 3: Debugging

Round 4: Code Craft

Closest DashMart

Problem Statement A DashMart is a warehouse run by DoorDash that houses items found in convenience stores, grocery stores, and restaurants. We have a city with open roads, blocked-off roads, and DashMarts.

City planners want you to identify how far a location is from its closest DashMart.

You can only travel over open roads (up, down, left, right).

Locations are given in [row, col] format.

Example 1 [

0 1 2 3 4 5 6 7 8

['X', ' ', ' ', 'D', ' ', ' ', 'X', ' ', 'X'], # 0
['X', ' ', 'X', 'X', ' ', ' ', ' ', ' ', 'X'], # 1
[' ', ' ', ' ', 'D', 'X', 'X', ' ', 'X', ' '], # 2
[' ', ' ', ' ', 'D', ' ', 'X', ' ', ' ', ' '], # 3
[' ', ' ', ' ', ' ', ' ', 'X', ' ', ' ', 'X'], # 4
[' ', ' ', ' ', ' ', 'X', ' ', ' ', 'X', 'X']  # 5

]

' ' represents an open road that you can travel over in any direction (up, down, left, or right). 'X' represents an blocked road that you cannot travel through. 'D' represents a DashMart.

list of pairs [row, col]

locations = [ [200, 200], [1, 4], [0, 3], [5, 8], [1, 8], [5, 5]
]

answer = [-1, 2, 0, -1, 6, 9]

Provided:

• city: char[][]
• locations: int[][2]

Return:

• answer: int[] Return a list of the distances from a given point to its closest DashMart.

Maximize calories when calories and dollar amounts were given. Dollar amount cannot exceed given Allowed amount.

Hi all, I had my phone screen recently with Doordash.

Question: https://leetcode.com/problems/binary-tree-maximum-path-sum/description/

He called leaf nodes "live nodes" and wanted the maximum sum of a path that starts and ends at a live node. I solved it but missed a corner case.

I had to run my code so make sure you know syntax for setting up a running environment, like create a TreeNode, and set the left and right nodes etc.

Got rejected in the end

Modification of LRU cache.

Alice, an engineer, notices that a database for dasher assignments is slowing down due to the number of dashers and entries in the database. She notices that recently assigned dashers are more likely to be looked up and would like to cache these dashers so that lookup is faster.

This database stores the most recent delivery that a dasher made (looking up a dasher returns a single delivery id that they were last assigned). Specifically, she would like the cache to support the following functions:

put(dasher_id: Int, delivery_id: Int). Adds the delivery that a dasher is working into the cache. If the dasher exists in the cache, then the delivery is updated (and this key, value pair is now the most recently used pair)

get(dasher_id: Int). Gets the most recent delivery for a dasher. Returns -1 if the dasher_id is not in the cache

The server only has space to store capacity dasher’s information in the cache. Alice decides that only the most recently updated dashers should be stored in the cache (ones that had put called most recently). When the cache goes above capacity, the oldest entry is removed from the cache. The cache is initialized with the following function:

init(capacity: Int). Initializes the cache with specified capacity

Phone Screen

My interview journey with DoorDash for a Staff Software Engineer position began in February 2024 with a phone screen. The problem presented was a variation on the LeetCode problem 'Swim in Rising Water'. I managed to successfully navigate this round.

Virtual Onsite

Round 1: Data Structures & Algorithms

The first onsite round involved a problem asking for the maximum path sum, with the specific constraint that the path must connect only leaf nodes. I chose an iterative approach, as I often find formulating recursive solutions challenging. Although my iterative code was about twice the length, it passed all test cases. The interviewer then posed a follow-up: evaluating the path between any two 'active' nodes, where nodes would be flagged as active during creation. Unfortunately, I was unable to solve this follow-up question correctly.

Round 2: Data Structures & Algorithms

The second round featured a problem conceptually similar to 'Making A Large Island'. I initially solved it correctly using a Breadth-First Search (BFS) approach. The interviewer then requested a Depth-First Search (DFS) solution, which I also provided successfully.

Round 3: System Design

This round was focused on designing an online coding platform. I made sure to clarify all requirements thoroughly, discussed various tradeoffs, and maintained clear communication throughout the design process. I was pleasantly surprised when the interviewer expressed satisfaction with my design and commended my approach at the end, which gave me a nice confidence boost.

Round 4: Behavioral

The final round was a behavioral interview, primarily using the STAR (Situation, Task, Action, Result) pattern. It turned out to be a very engaging conversation, largely because the manager had extensive prior experience in my specific domain and showed genuine interest in my background and career path.

Result & Reflection

Despite my efforts, I received a rejection. The feedback explicitly mentioned the follow-up question from Round 1 that I couldn't solve, which was incredibly frustrating. It feels truly disheartening that one challenging follow-up question can negate weeks of intense preparation and effort.

As an average software engineer, I've consistently found interviews to be tough, regardless of how much I prepare. Over the last decade, I've interviewed with 67 different companies and only managed to succeed three times. My current job situation, marked by unfulfilled promises and a difficult work environment, combined with the pressures of family responsibilities, makes this ongoing job search particularly grueling. I'm also on a visa, which limits my options. A recent disappointing performance review without a raise was the final straw that propelled me back into intense interview preparation. My nights and weekends have blurred into endless study, and my social life has vanished. However, I am not giving up until I find a better opportunity; I strongly believe I deserve more, and my hard work will eventually pay off.