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

Senior

Apr 2026

Summary

DoorDash system design round for a software engineering role. The question was a meaty distributed-systems problem about fan-out HTTP calls, and it went pretty deep pretty fast.

Questions Asked (1)

Design a service with a single endpoint that calls three external HTTP APIs in parallel, aggregates the results, and returns a combined JSON response. Your design needs to cover per-call and overall timeouts, a configurable wait-all vs fail-fast policy, retries with capped exponential backoff and jitter using a reusable wrapper around a callable, partial failure handling with default fallback values, structured logging, and metrics.

System DesignAPI & IntegrationsTechnical Trade-offs

Author's notes

This one covered a lot of ground and I kept feeling like I was one step behind.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and constraints, then outline a high-level architecture with a single endpoint that fans out to three external APIs concurrently. Dive into the critical components: timeout handling, retry logic with backoff and jitter, configurable wait-all vs fail-fast policy, partial failure fallbacks, structured logging, and metrics. Conclude by discussing trade-offs and how you would test and monitor the service.

Pro tip: Emphasize idempotency and the use of a reusable retry wrapper that can be applied to any callable, showing you think about code reuse and maintainability. Also, mention that you would use a circuit breaker to prevent cascading failures and that you would make the wait-all vs fail-fast policy configurable per request or via feature flags for flexibility.

1. Clarify Requirements and Constraints

Ask about expected latency, error rates, and whether the three APIs are independent. Confirm if the response should include partial results or fail entirely, and discuss the need for configurability.

2. High-Level Architecture

Describe a service with a single endpoint that uses an async HTTP client to call the three APIs in parallel. Use a thread pool or event loop to manage concurrency, and aggregate results into a combined JSON.

3. Timeout and Retry Strategy

Define per-call timeouts and an overall request timeout. Implement retries with capped exponential backoff and jitter using a reusable wrapper around a callable. Discuss how to handle retries for non-idempotent operations.

4. Failure Handling and Policy

Explain the configurable wait-all vs fail-fast policy. For partial failures, use default fallback values. Discuss how to propagate errors and when to return partial results.

5. Observability and Testing

Cover structured logging with correlation IDs and metrics (latency, success/failure counts, retry counts). Discuss testing strategies: unit tests for retry logic, integration tests with mocked APIs, and chaos testing.

Key Points to Mention

Per-call and overall timeouts to prevent hanging requests
Retry logic with capped exponential backoff and jitter to avoid thundering herd
Configurable wait-all vs fail-fast policy, possibly per request or via feature flags
Partial failure handling with default fallback values to ensure graceful degradation
Structured logging with correlation IDs for traceability across services
Metrics for monitoring: latency, error rates, retry counts, and circuit breaker state

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