Openai·Software Engineer·Technical Phone Screen·Senior

SeniorPrefer not to say

Apr 2026Remote

Summary

OpenAI SWE coding round, one meaty design-your-own-cache problem that took up the whole session. More open-ended than I expected, with optional extensions that I wasn't sure whether to tackle or skip.

Questions Asked (1)

Implement an in-memory TTL cache with per-key expiration. The cache should support set, get, and delete operations, where get returns None for expired keys. Optional extensions include LRU eviction with a capacity limit, a cleanup method to proactively purge expired entries, and thread safety.

System DesignAlgorithms & Data StructuresTechnical Trade-offs

Author's notes

I started with the basic TTL logic, storing expiry timestamps alongside values, and that part went fine.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and constraints, then design a data structure that combines a hash map for O(1) key access with expiration timestamps. Implement core operations (set, get, delete) with lazy expiration, and discuss optional extensions like LRU eviction, proactive cleanup, and thread safety as trade-offs.

Pro tip: Mention that lazy expiration avoids background overhead but can lead to memory bloat, while proactive cleanup trades CPU for memory—choose based on workload. Also, highlight that thread safety can be achieved with a lock per key or a global lock, but consider contention.

1. Clarify Requirements

Ask about expected workload, key size, TTL granularity, concurrency needs, and whether LRU eviction is required. Confirm that get returns None for expired keys and that expired entries should be removed eventually.

2. Design Core Data Structure

Use a hash map (dictionary) to store key-value pairs along with expiration timestamps. For LRU, combine with a doubly linked list to track access order. For thread safety, consider a lock or concurrent data structure.

3. Implement Core Operations

For set, store value and expiration time (current time + TTL). For get, check if key exists and if expired; if expired, delete and return None. For delete, remove key and update LRU list if applicable.

4. Handle Expiration Strategies

Choose between lazy expiration (check on access) and proactive cleanup (periodic sweep). Discuss trade-offs: lazy is simple but may leave expired entries; proactive uses more CPU but keeps memory bounded.

5. Address Extensions and Trade-offs

If LRU is needed, evict least recently used when capacity exceeded. For thread safety, use locks or concurrent structures, and discuss performance implications. Mention potential optimizations like using a min-heap for expiration.

Key Points to Mention

Time complexity: O(1) for set, get, delete with hash map; O(1) for LRU operations with doubly linked list.
Lazy vs. proactive expiration: lazy avoids background threads but can cause memory bloat; proactive cleanup requires a timer or background thread.
LRU eviction: combine hash map with doubly linked list to track access order and evict least recently used when capacity is reached.
Thread safety: use locks (e.g., threading.Lock in Python) or concurrent data structures; consider lock granularity to reduce contention.
Memory management: expired entries should be removed to free memory; discuss strategies like periodic cleanup or reference counting.
Edge cases: TTL of zero or negative, key not found, concurrent access, and capacity limit of zero.

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