← DoorDash Interview InsightsSoftware Engineer

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

Senior
Jun 2026

Summary

DoorDash system design round focused on payment infrastructure. The whole session was basically a deep dive into storage layer decisions, which I wasn't expecting to go quite that granular.

Questions Asked (1)

Q1

You've designed a payment system at a high level. Now walk through the storage layer specifically: what data lives where, which database technology do you pick for each piece, and what are the trade-offs?

System DesignTechnical Trade-offsData Modeling
Author's notes

This is where I fumbled a bit.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by identifying the core entities in a payment system (transactions, accounts, ledgers, idempotency keys) and map each to a storage technology based on access patterns and consistency needs. Then justify each choice by discussing trade-offs around consistency, latency, scalability, and cost, tying them back to DoorDash's high-throughput, low-latency requirements.

Pro tip: Emphasize idempotency and exactly-once processing—interviewers at DoorDash care deeply about preventing duplicate charges, so highlight how you'd use a unique constraint or a dedicated idempotency store to guarantee it.

1. Identify core data entities

List the main data types: transactions, payment methods, ledger entries, idempotency keys, and audit logs. Clarify their access patterns (read/write ratio, latency requirements) and consistency needs.

2. Map entities to storage technologies

For each entity, propose a suitable database (e.g., relational for transactions, key-value for idempotency, append-only log for ledger) and briefly explain why it fits the access pattern.

3. Discuss trade-offs per choice

For each technology, articulate the trade-offs: consistency vs. availability, latency vs. durability, cost, operational complexity, and scalability limits.

4. Address cross-cutting concerns

Cover how data flows between stores (e.g., change data capture, outbox pattern), how you ensure atomicity across stores (sagas, 2PC), and how you handle failures and retries.

5. Summarize and tie back to requirements

Recap the storage architecture and explicitly connect each choice to DoorDash's needs: high throughput, low latency, strong consistency for financial data, and horizontal scalability.

Key Points to Mention

  • Use a relational database (e.g., PostgreSQL) for transactions and ledger entries to ensure ACID compliance and strong consistency.
  • Store idempotency keys in a low-latency key-value store (e.g., Redis or DynamoDB) with TTL to prevent duplicate charges.
  • Consider an append-only ledger (e.g., using a log-structured store like Kafka or a ledger database) for auditability and immutability.
  • Sharding strategy: shard by user ID or merchant ID to distribute load, but be aware of hot partitions and cross-shard queries.
  • Trade-off between strong consistency (CP) and high availability (AP): financial data typically requires CP, but some read paths can be eventually consistent.
  • Use change data capture (CDC) or an outbox pattern to propagate updates to other systems without dual writes.

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