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

SeniorPrefer not to say

Apr 2026

Summary

Netflix system design round for a software engineer role. The whole thing was basically one meaty cache design problem that took up the entire session. Felt like it went okay but there were definitely parts I fumbled through.

Questions Asked (1)

Design a weighted cache with a fixed total weight capacity. Each item has a key, value, and positive weight. Support get (with recency update) and put (with eviction of heaviest items when over capacity, breaking ties by least-recently-used).

Algorithms & Data StructuresSystem DesignTechnical Trade-offs

Author's notes

I knew LRU cache cold so my first instinct was to just reach for a doubly linked list plus a hashmap and call it a day.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and edge cases, then propose a data structure that combines a hash map for O(1) key lookup with a balanced structure for weight-based eviction and recency tracking. Discuss trade-offs between different implementations (e.g., heap vs. balanced tree) and explain how to handle tie-breaking by LRU efficiently.

Pro tip: Mention that eviction should be triggered only when total weight exceeds capacity, and that you can optimize by evicting multiple items in one put if necessary. Also, highlight that using a doubly linked list for recency within weight buckets can achieve O(1) updates for get and O(log n) for eviction.

1. Clarify Requirements and Edge Cases

Ask about expected operations, weight limits, tie-breaking rules, and concurrency needs. Confirm whether weights are positive and if capacity is fixed.

2. Choose Core Data Structures

Propose a hash map for key-value lookup and a structure for ordering by weight and recency, such as a balanced BST (e.g., TreeMap) or a heap combined with a linked list.

3. Design Eviction Logic

Explain how to find and remove the heaviest items when over capacity, breaking ties by least-recently-used. Detail how to update total weight and maintain recency on get/put.

4. Analyze Complexity and Trade-offs

Discuss time and space complexity for get and put, and compare alternative approaches (e.g., heap vs. balanced tree) in terms of performance and implementation complexity.

5. Consider Optimizations and Extensions

Mention potential improvements like lazy eviction, batch eviction, or concurrency handling, and how the design scales for large datasets.

Key Points to Mention

Use a hash map for O(1) key lookup and a balanced BST (or heap) for weight-based ordering.
Maintain a doubly linked list for recency within each weight to achieve O(1) LRU updates.
Evict the heaviest items first; if multiple items have the same weight, evict the least recently used among them.
Update total weight on every put and get (if weight changes? no, weight is fixed per item).
Time complexity: get O(1) or O(log n) depending on structure; put O(log n) for eviction.
Discuss trade-offs: heap gives O(log n) eviction but O(n) for LRU tie-breaking; balanced tree gives O(log n) for both.

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