Netflix·Software Engineer·Technical Phone Screen·Senior

SeniorPrefer not to say

Jun 2026

Summary

Netflix SWE interview with a coding round centered on a custom cache variant. The problem had enough wrinkles to keep you busy for the whole session and the edge cases were where things got interesting.

Questions Asked (1)

Design and implement a weighted cache that supports get(key), put(key, value, weight), enforces a maximum total weight limit instead of a max entry count, and evicts entries in LRU order when adding a new entry would exceed that limit. If a single entry's weight exceeds the total cap, reject the put entirely.

Algorithms & Data StructuresSystem DesignTechnical Trade-offs

Author's notes

Knew the LRU cache pattern cold so the base structure came quickly, hashmap plus doubly linked list.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and edge cases, then propose a design using a hash map for O(1) key lookup and a doubly linked list to maintain LRU order. Explain how to track total weight and handle evictions, including the rejection of overweight entries, and discuss trade-offs and potential optimizations.

Pro tip: Emphasize the importance of thread safety and concurrency, as Netflix operates at scale; mention how you would handle concurrent access with locks or lock-free structures.

1. Clarify Requirements and Edge Cases

Ask questions to confirm assumptions: Is the cache expected to be thread-safe? What is the expected read/write ratio? How should weight be interpreted (e.g., memory size, cost)? What happens when an entry's weight is updated? Confirm that eviction is strictly LRU and that a single overweight entry is rejected.

2. Design Data Structures

Propose using a hash map (dictionary) for O(1) key lookup and a doubly linked list to maintain access order. Each node stores key, value, weight, and pointers to prev/next. Maintain a running total weight.

3. Implement Core Operations

For get(key): if key exists, move node to the front of the list (most recently used) and return value. For put(key, value, weight): if weight > maxWeight, reject. If key exists, update value and weight, adjust total weight, and move to front. If new key, check if total weight + weight > maxWeight; if so, evict from the tail (least recently used) until enough space, then insert new node at front. Update total weight accordingly.

4. Handle Edge Cases and Concurrency

Discuss handling of zero or negative weights (if allowed), updating weight of existing key, and thread safety. For concurrency, suggest using a mutex or read-write lock, or sharding the cache to reduce contention.

5. Analyze Complexity and Trade-offs

State that both get and put are O(1) time complexity. Discuss trade-offs: memory overhead of linked list nodes, potential for frequent evictions if weights vary widely, and alternative eviction policies (e.g., LFU) if access patterns are skewed.

Key Points to Mention

Use of hash map and doubly linked list for O(1) operations
Maintaining total weight and updating it on insert, update, and eviction
Eviction loop: remove from tail until enough capacity
Rejection of entries with weight > maxWeight
Thread safety considerations (locks, sharding, or concurrent data structures)
Time and space complexity analysis

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