warp·Software Engineer·Technical Phone Screen·Senior

SeniorPrefer not to say

May 2026

Summary

Interviewed for a software engineer role at Warp and got a design question that felt very on-brand for a terminal app company. The problem was more involved than it looked at first glance.

Questions Asked (1)

Design a data structure that models a terminal application with multiple tabs and split panels. Each tab should contain a panel layout modeled as a tree, where splits create child nodes. Implement methods to create tabs, split panels, serialize the full state, and deserialize it back. Write a test that creates tabs, does nested splits, serializes, deserializes, and verifies the result matches the original.

Algorithms & Data StructuresSystem DesignData Modeling

Author's notes

The tree structure for panels clicked pretty fast since split panes are basically recursive by nature.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and defining the core data model: a TerminalState containing a list of Tabs, each with a root Panel that is either a Leaf (terminal) or a Split (with orientation and children). Then implement the operations (createTab, splitPanel, serialize, deserialize) with a focus on recursive tree traversal and a versioned JSON schema. Finally, write a test that builds a nested layout, serializes it, deserializes it, and asserts structural and content equality.

Pro tip: Mention that you'd version the serialization format and include a round-trip test with deep equality to catch subtle bugs—this shows you think about backward compatibility and correctness in production systems.

1. Clarify requirements and constraints

Ask about the expected operations, whether panels can be resized, if serialization must be human-readable, and any performance or persistence requirements. This ensures you design the right abstraction.

2. Define the data model

Model TerminalState as a list of Tab objects; each Tab has an id, title, and a root Panel. Panel is an abstract type with two concrete subclasses: Leaf (terminal session) and Split (orientation: horizontal/vertical, children: list of Panels).

3. Implement operations

Implement createTab (adds a new tab with a default leaf panel), splitPanel (replaces a target leaf with a split node containing the original leaf and a new leaf), and recursive serialize/deserialize methods that convert the tree to/from a JSON-like structure.

4. Design serialization format

Use a tagged union (e.g., {type: 'leaf', ...} or {type: 'split', ...}) to distinguish node types. Include a version field for future compatibility. Ensure deserialization reconstructs the exact tree structure.

5. Write and explain the test

Create a test that builds a terminal state with multiple tabs and nested splits, serializes it, deserializes it, and asserts deep equality. Discuss edge cases like empty tabs or single-leaf tabs.

Key Points to Mention

Use a recursive tree structure with a tagged union for Panel (Leaf vs Split) to enable polymorphic serialization.
Include a version field in the serialized format to support future schema evolution.
Implement splitPanel by replacing a leaf node with a new split node, preserving the original leaf as one child.
Ensure serialization is deterministic (e.g., stable ordering of children) for reliable round-trip testing.
Write a test that verifies both structural equality (tree shape) and content equality (e.g., terminal session IDs).
Consider performance implications: serialization should be O(n) in the number of panels, and deserialization should avoid deep recursion limits for very large trees.

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