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

SeniorPrefer not to say

May 2026

Summary

System design round at OpenAI for a backend role. The question was one big compound problem that kept expanding the longer we talked, which I was not fully prepared for.

Questions Asked (1)

Design an in-memory key-value store from scratch. Start with basic get, set, and delete, then extend it to support TTL-based expiry, atomic transactions with commit and rollback, and full snapshot and restore functionality. Walk through your data structure choices, time complexity, and how you'd handle concurrent access.

System DesignAlgorithms & Data StructuresTechnical Trade-offs

Author's notes

I started with a plain hashmap and felt good for about two minutes.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and constraints, then design a layered solution: begin with a simple hash map for basic operations, extend to TTL with a min-heap or timing wheel, implement transactions using a write-ahead log or copy-on-write, and add snapshot/restore via serialization. Throughout, discuss trade-offs in data structures, time complexity, and concurrency control mechanisms like locking or MVCC.

Pro tip: Demonstrate awareness of real-world systems by referencing how Redis handles TTL with lazy and active expiration, and how databases implement transactions with undo logs—this shows you can apply existing patterns thoughtfully.

1. Clarify Requirements and Constraints

Ask about expected scale, read/write ratio, consistency needs, and whether persistence is required. This guides data structure and concurrency choices.

2. Design Core Data Structures

Propose a hash map for O(1) get/set/delete. For TTL, discuss min-heap or timing wheel for efficient expiration, and consider lazy vs. active expiration.

3. Implement Transactions

Use a write-ahead log or copy-on-write to support atomic commit and rollback. Discuss isolation levels and how to handle concurrent transactions.

4. Add Snapshot and Restore

Design serialization of the store to disk or memory, considering consistency during snapshot (e.g., fork or lock). Discuss incremental vs. full snapshots.

5. Address Concurrency and Complexity

Choose locking (fine-grained vs. coarse) or lock-free structures. Analyze time complexity for each operation and discuss trade-offs.

Key Points to Mention

Hash map for O(1) average-case get/set/delete, with collision handling (e.g., chaining or open addressing).
TTL implementation: min-heap for expiration ordering, lazy deletion on access, and active expiration via background thread.
Transactions: write-ahead log for durability and rollback, or copy-on-write for isolation; discuss ACID properties.
Snapshot/restore: serialization formats (e.g., JSON, protobuf), consistency during snapshot (e.g., fork or lock), and incremental snapshots.
Concurrency: reader-writer locks, sharding, or MVCC; trade-offs between simplicity and performance.
Time complexity: O(1) for basic ops, O(log n) for heap-based TTL, O(n) for snapshot; discuss amortized costs.

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