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

SeniorPrefer not to say

Apr 2026

Summary

System design round at OpenAI focused on a classic distributed systems problem. The question felt deceptively simple at first but the concurrent duplicate request angle is where things got interesting.

Questions Asked (1)

A client accidentally sends the same network request more than once, due to a double-click, a retry after timeout, or network-level duplication. Design a system to prevent the operation from being processed twice, covering both client-side and server-side approaches, and explain how your design handles duplicate requests arriving at the same time.

System DesignTechnical Trade-offsAPI & Integrations

Author's notes

I started on the client side because that felt easier, debouncing the button, disabling it after the first click, that kind of thing.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the requirements and constraints, then propose a layered solution that combines client-side idempotency keys with server-side deduplication using a unique constraint or distributed lock. Explain how concurrent duplicate requests are handled atomically, and discuss trade-offs like storage overhead, latency, and failure modes.

Pro tip: Emphasize that idempotency keys should be generated on the client and stored server-side with a TTL, and that the server must return the same response for duplicates to ensure consistency. Mention that handling concurrent duplicates requires atomic operations, such as a database unique index or a distributed lock with a fast-fail mechanism.

1. Clarify requirements and scope

Ask questions to understand the operation's criticality, expected request volume, latency requirements, and whether the client can be modified. This shapes the choice of client-side vs. server-side mechanisms.

2. Design client-side prevention

Propose generating a unique idempotency key per logical operation on the client, disabling buttons after click, and using exponential backoff with jitter for retries. Ensure the key is sent with every retry.

3. Design server-side deduplication

Describe storing idempotency keys with a unique constraint in a fast data store (e.g., Redis or database) and returning the cached response for duplicates. Include TTL and cleanup policies.

4. Handle concurrent duplicates

Explain atomic operations: use a unique index or SETNX in Redis to ensure only one request proceeds; others either wait for the result or receive a conflict response. Discuss distributed locks with timeouts and idempotent processing.

5. Discuss trade-offs and failure modes

Cover storage overhead, latency impact, key collision risks, and what happens if the idempotency store fails. Mention monitoring and alerting for duplicate attempts.

Key Points to Mention

Idempotency keys: client-generated unique identifiers (e.g., UUID) sent with each request.
Server-side storage: use a database unique constraint or Redis SETNX with TTL to track processed keys.
Atomicity: ensure check-and-set is atomic to handle concurrent duplicates, e.g., via transactions or Lua scripts.
Response caching: store and return the original response for duplicate requests to maintain consistency.
Client-side techniques: disable UI elements, use request cancellation, and implement retry logic with idempotency.
Trade-offs: storage cost, latency, key expiration, and handling of partial failures.

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