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

SeniorPrefer not to say

Apr 2026

Summary

System design round at DoorDash focused entirely on a food review feature built on top of their existing order infrastructure. Pretty deep dive, way more moving parts than I expected for what sounds like a 'simple reviews feature'.

Questions Asked (2)

Design a food review system for DoorDash where only users who completed an order for a specific restaurant or dish can submit a review. Walk through the data model, write path, read path, caching strategy, and a thumbs-up counter.

System DesignData ModelingTechnical Trade-offs

Author's notes

I started with the data model which felt safe.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale, then design the data model with entities like User, Order, Review, and ThumbsUp. Walk through the write path ensuring only verified purchasers can review, the read path for fetching reviews efficiently, and a caching strategy to handle high read traffic. Finally, detail the thumbs-up counter implementation with idempotency and scalability in mind.

Pro tip: Emphasize the importance of idempotency and race condition handling in the thumbs-up counter, and discuss how to handle review updates or deletions while maintaining verification integrity.

1. Clarify Requirements and Scale

Ask about expected read/write ratios, number of restaurants, users, and reviews per day. Clarify if reviews are for restaurants, dishes, or both, and whether thumbs-up is per review or per user.

2. Design Data Model

Define entities: User, Restaurant, Dish, Order, OrderItem, Review, and ThumbsUp. Include fields like review text, rating, timestamps, and foreign keys linking reviews to verified orders.

3. Design Write Path

When a user submits a review, validate that they have a completed order for the restaurant or dish. Insert the review into the database and update any relevant counters or caches.

4. Design Read Path and Caching

For reading reviews, query by restaurant or dish with pagination. Use caching (e.g., Redis) to store frequently accessed reviews or aggregates, with appropriate invalidation strategies.

5. Implement Thumbs-Up Counter

Design a scalable counter using a distributed cache or database with atomic increments. Ensure idempotency by tracking user thumbs-ups to prevent duplicate votes.

Key Points to Mention

Verification of completed orders before allowing reviews, possibly using order status and timestamps.
Data model relationships: one-to-many between orders and reviews, and many-to-many for thumbs-ups.
Write path: handling concurrent review submissions and ensuring only one review per order per user.
Read path: efficient querying with indexes on restaurant_id, dish_id, and created_at for pagination.
Caching strategy: cache review lists and thumbs-up counts with TTL and invalidation on new reviews or votes.
Thumbs-up counter: using Redis INCR or database atomic updates, with idempotency via unique user-review pairs.

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

How would you automatically grant a DoorDash credit bonus to a reviewer once their review hits 100 thumbs-ups, and how do you make sure the reward isn't issued more than once?

System DesignAPI & IntegrationsTechnical Trade-offs

Author's notes

This is where things got interesting and not in a good way for me.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Design an event-driven system where a thumbs-up triggers a check against a threshold, and use idempotent processing with a unique constraint to prevent duplicate rewards. Discuss the trade-offs between synchronous and asynchronous processing, and how to handle failures and retries.

Pro tip: Emphasize idempotency and exactly-once semantics: use a database unique constraint on (reviewer_id, reward_type) or a distributed lock to ensure the reward is granted only once, even with concurrent thumbs-ups.

1. Clarify Requirements and Scale

Ask about expected traffic, latency requirements, and whether the reward should be granted in real-time or can be batched. Confirm that the reward is per reviewer per review, not per thumbs-up.

2. Design the Event Flow

Outline how a thumbs-up event is captured (e.g., API call, message queue) and processed. Consider using a stream processor or a background job to check if the review has reached 100 thumbs-ups.

3. Ensure Idempotency

Describe how to prevent duplicate rewards: use a unique constraint in the database, an idempotency key, or a distributed lock. Mention that the reward issuance should be atomic with the check.

4. Handle Failures and Retries

Explain how to handle failures in the reward issuance (e.g., payment service down) with retries and dead-letter queues, ensuring that retries don't cause duplicates.

5. Discuss Trade-offs and Monitoring

Compare synchronous vs. asynchronous approaches, and mention monitoring/alerting for reward issuance and duplicate detection.

Key Points to Mention

Idempotency: using a unique constraint on (reviewer_id, reward_type) or an idempotency key to prevent duplicate rewards.
Event-driven architecture: thumbs-up events published to a message queue (e.g., Kafka) and processed by a consumer.
Atomicity: ensuring the check for 100 thumbs-ups and the reward issuance happen in a single transaction or with a lock.
Exactly-once semantics: using idempotent consumers and deduplication to avoid double processing.
Scalability: handling high throughput of thumbs-up events with partitioning and horizontal scaling.
Monitoring and alerting: tracking reward issuance rates and detecting anomalies like duplicate rewards.

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