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

Senior

Apr 2026

Summary

System design round at DoorDash for an EM role. Single question, pretty open-ended, and the scope creep potential was real if you weren't careful about what you were actually being asked to build.

Questions Asked (1)

Design DoorDash's item-level order review and rating system.

System DesignData ModelingTechnical Trade-offs

Author's notes

I spent the first few minutes trying to nail down scope because this thing can balloon fast.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the scope and requirements: item-level ratings, aggregation, scale, and integration with existing order systems. Then design a data model and API that captures individual item reviews, and discuss how to aggregate and serve ratings efficiently at DoorDash's scale. Finally, address trade-offs around consistency, latency, and storage.

Pro tip: Emphasize the importance of idempotency and deduplication in review submission to handle network retries and prevent fake reviews, and discuss how to handle updates to reviews without breaking aggregates.

1. Clarify Requirements and Scope

Ask questions to understand functional and non-functional requirements: who can review (only verified purchasers?), what can be reviewed (individual items, modifiers?), how ratings are displayed (average, distribution), and scale (orders per day, read/write ratio).

2. Design Data Model and API

Define entities: Review (user_id, order_id, item_id, rating, text, timestamp, etc.), ItemRatingAggregate (item_id, average_rating, total_ratings, distribution). Design RESTful APIs for submitting a review, fetching reviews for an item, and fetching aggregates.

3. Plan Storage and Aggregation Strategy

Choose storage: a relational DB for reviews (with sharding by item_id or user_id) and a fast key-value store or cache for aggregates. Discuss aggregation approaches: synchronous update on write vs. asynchronous batch processing (e.g., via Kafka and Spark) to handle high write volume.

4. Address Scalability and Performance

Discuss partitioning, replication, and caching to handle read-heavy traffic. Consider using a CDN for static content and a cache like Redis for hot items. For writes, use a queue to decouple and ensure idempotency.

5. Handle Trade-offs and Edge Cases

Discuss trade-offs: consistency vs. availability for aggregates, latency of synchronous vs. asynchronous updates, and storage cost. Cover edge cases: review updates/deletions, spam prevention, and handling missing data.

Key Points to Mention

Idempotent review submission to handle retries and prevent duplicates
Data model with proper indexing for efficient queries (e.g., by item_id, user_id)
Aggregation strategies: real-time vs. batch, and how to handle updates
Caching and read optimization for high-traffic items
Scalability considerations: sharding, partitioning, and replication
Trade-offs between consistency, latency, and cost

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