Doordash Interview Questions (17+ Questions)

Learn how to create a Bash script that automates connectivity checks for multiple hosts using ping commands. This guide covers reading hostnames from a file, testing reachability, generating status reports, and handling failures gracefully, essential for pre-maintenance validation, network monitoring, and infrastructure health checks in DevOps workflows.

Troubleshoot and fix HPA configuration to enable automatic pod scaling. Resolve metric collection issues, fix deployment references, configure CPU targets correctly, and achieve dynamic scaling based on load. Essential for elastic workloads, cost optimization, handling traffic spikes, and maintaining performance under variable load in production clusters.

Kubernetes Pod Termination Debugging: processor core namespace. Investigate and resolve resources stuck in the 'Terminating' state due to blocking Finalizers and hanging Lifecycle Hooks. Master the use of forced deletion and metadata patching to clear deadlocked objects. Critical troubleshooting for zombie processes, namespace deletion failures, and managing complex resource finalization flows.

Master GitHub Actions reusable workflows (workflow_call). Learn to implement cross-repository promotion pipelines where one workflow triggers another to update GitOps configuration files automatically.

Learn to capture and preserve deployment logs as artifacts only on workflow failure using GitHub Actions conditional artifact uploads with if: failure().

Read and parse a customer CSV file in Python, filter records by status field to find active customers, and write the count to an output text file.

def find_duplicate(nums: list[int]) -> int:
slow, fast = 0, 0

while True:
    slow = nums[slow]
    fast = nums[nums[fast]]
    if slow == fast:
        break
        
slow2 = 0
while True:
    slow = nums[slow]
    slow2 = nums[slow2]
    if slow == slow2:
        return slow

def partition(s: str) -> list[list[str]]:
res = []

def is_palindrome(left, right):
    while left < right:
        if s[left] != s[right]:
            return False
        left += 1
        right -= 1
    return True
    
def dfs(start, current_partition):
    if start >= len(s):
        res.append(current_partition.copy())
        return
        
    for end in range(start, len(s)):
        if is_palindrome(start, end):
            current_partition.append(s[start : end + 1])
            dfs(end + 1, current_partition)
            current_partition.pop()
            
dfs(0, [])
return res

def partition_labels(s: str) -> list[int]:
last_occurrence = {}

for i, char in enumerate(s):
    last_occurrence[char] = i
    
res = []
size = 0
end = 0

for i, char in enumerate(s):
    size += 1
    end = max(end, last_occurrence[char])
    
    if i == end:
        res.append(size)
        size = 0
        
return res

Objective

Retrieve the list of customers who meet both of the following criteria:

1. They are new customers with a monthly spending greater than 1000.
2. They are loyal customers with at least 3 years of membership and have a 'Premium' tier status.

Provide the customer_id and name of these customers, sorted in ascending order by customer_id.

Additional information

Tables Description:

• NewCustomers:

  • customer_id (INTEGER): Unique identifier for each customer.
  • name (VARCHAR): Name of the customer.
  • monthly_spend (INTEGER): Amount spent by the customer monthly.
  • join_date (DATE): Date when the customer joined.

• LoyalCustomers:

  • customer_id (INTEGER): Unique identifier for each customer.
  • name (VARCHAR): Name of the customer.
  • membership_years (INTEGER): Number of years the customer has been a member.
  • tier (VARCHAR): Membership tier of the customer (e.g., 'Premium').

Constraints:

• Each customer appears only once in each table.
• membership_years and monthly_spend are positive integers.
• The tier field contains single-word strings without special characters.

Output Requirements:

• The result should include only the customer_id and name columns.
• The final output must be ordered by customer_id in ascending order.

Read a large CSV file with transaction data, partition it by month using pandas, and save each partition as a separate Parquet file with organized naming.

Practice filtering for NULL values in Snowflake SQL with this movie analytics interview question. You query a movies table to find rows where box office collection data is missing using IS NULL. Covers NULL handling, IS NULL, WHERE clause, and data quality checks in Snowflake. An easy-level question common in analytics interviews at companies like DoorDash.

Practice string manipulation in PySpark. Learn how to use regular expressions (regexp_extract) to extract numeric patterns from alphanumeric string columns.

How to Fetch the Most Recent Event for Each User in SQL

When working with SQL databases, you might encounter scenarios where you need to fetch the most recent event for each user from the events table. This specific task can be efficiently accomplished by crafting an SQL query that leverages window functions or self-joins for optimal performance.

Here is a sample SQL query to achieve this goal:

WITH ranked_events AS (
    SELECT 
        event_name, 
        user_id, 
        event_date, 
        status,
        ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY event_date DESC) AS rn
    FROM events
)
SELECT 
    event_name, 
    user_id, 
    event_date, 
    status
FROM ranked_events
WHERE rn = 1
ORDER BY user_id ASC;

This query uses a common table expression (CTE) to assign row numbers to each event per user, ordered by event_date in descending order. The outer query then filters for the most recent event for each user by selecting only rows where rn = 1 and sorts the result by user_id in ascending order.

This optimized approach ensures that the query performs well even with large datasets, making it ideal for real-world applications where performance is crucial.

Use this optimized query format when preparing for your SQL interview or enhancing your database skills to handle similar data retrieval tasks efficiently.

SELECT
t1.topping_name || ', ' || t2.topping_name || ', ' || t3.topping_name AS pizza,
t1.ingredient_cost + t2.ingredient_cost + t3.ingredient_cost AS total_cost
FROM
pizza_toppings t1
CROSS JOIN pizza_toppings t2
CROSS JOIN pizza_toppings t3
WHERE
t1.topping_name < t2.topping_name
AND t2.topping_name < t3.topping_name
ORDER BY
total_cost DESC,
pizza;

def character_replacement(s: str, k: int) -> int:
count = {}
res = 0
l = 0
max_f = 0

for r in range(len(s)):
    count[s[r]] = 1 + count.get(s[r], 0)
    max_f = max(max_f, count[s[r]])
    
    if (r - l + 1) - max_f > k:
        count[s[l]] -= 1
        l += 1
        
    res = max(res, r - l + 1)
    
return res

Objective

Write a precise SQL query designed to identify orders where the shipping duration significantly exceeds the average shipping duration. Specifically, the query should return orders where the shipping duration is more than 1.5 times the average shipping duration of all orders. The resul...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →