Netflix·Software Engineer·Technical Phone Screen·Senior

SeniorPrefer not to say

May 2026Remote

Summary

Netflix SWE interview with a system design coding problem around building a command/undo system. The question had more depth than I expected once the tag-based undo requirement came in.

Questions Asked (1)

Design and implement a command/undo system with two operations: execute(command, tags) which records a command along with a list of tags, and undo(tag=None) which undoes either the most recent command or the most recent command associated with a given tag. Discuss your data structure choices and time complexity for both operations.

Algorithms & Data StructuresSystem DesignTechnical Trade-offs

Author's notes

I started with a plain stack for the no-tag case, which was fine, but the tag-based undo is where things got interesting.

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 supports efficient undo by tag and globally. Walk through the design, analyze time complexity for both operations, and discuss trade-offs between different approaches.

Pro tip: Mention that you would use a doubly linked list for the global undo stack and a hash map from tags to stacks of nodes, allowing O(1) undo by tag and global undo, while handling removal from the global list efficiently with node references.

1. Clarify requirements and constraints

Ask about expected frequency of operations, memory constraints, and whether commands can be undone multiple times or if undo is permanent. Confirm that tags are provided at execution time and that undo(tag) should undo the most recent command with that tag.

2. Design data structures

Propose a doubly linked list to maintain the global order of commands, and a hash map mapping each tag to a stack (or list) of references to nodes in the linked list. Each node stores the command and its tags.

3. Implement execute and undo operations

For execute, append a new node to the global list and push its reference onto the stack for each tag. For undo(tag), pop the most recent node from the tag's stack (or global list if no tag), remove it from the global list, and remove its references from all other tag stacks.

4. Analyze time and space complexity

Execute is O(k) where k is number of tags (for pushing to each tag stack). Undo(tag) is O(1) to find the node, but O(t) to remove its references from other tag stacks, where t is number of tags on that command. Global undo is O(t) for the same reason. Space is O(n * average tags per command).

5. Discuss trade-offs and alternatives

Compare with simpler approaches like a single list with linear search for tag undo (O(n) time). Mention that if tags are few, the overhead of maintaining multiple stacks is acceptable. Also consider lazy deletion or using a balanced tree for ordered operations.

Key Points to Mention

Use of doubly linked list for O(1) removal from global order.
Hash map from tags to stacks of node references for O(1) access to most recent command per tag.
Need to remove node references from all tag stacks when a command is undone, which adds overhead proportional to number of tags.
Time complexity: execute O(k), undo(tag) O(t), undo() O(t), where k is number of tags and t is number of tags on the undone command.
Space complexity: O(n * average tags per command) due to storing references in multiple stacks.
Edge cases: undoing when no commands exist, undoing a tag with no commands, and handling duplicate tags on a command.

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