Ziprecruiter·Software Engineer·Technical Phone Screen·Intermediate

IntermediatePrefer not to say

May 2026Remote

Summary

Ziprecruiter SWE interview had me building an in-memory key-value store with nested fields from scratch. Decent problem, more design-heavy than I expected for a coding round.

Questions Asked (1)

Design and implement an in-memory key-value store class that supports nested fields under each key, with operations for set, get, setAndCompare, and setAndDelete.

System DesignAlgorithms & Data StructuresTechnical Trade-offs

Author's notes

The basic set/get part felt fine, dict of dicts is pretty much the obvious move.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the requirements: nested fields, operations (set, get, setAndCompare, setAndDelete), and expected performance. Then propose a data structure like a trie or nested hash maps to represent the hierarchy, and discuss trade-offs between simplicity and efficiency. Finally, outline the implementation details for each operation, including edge cases and concurrency considerations.

Pro tip: Demonstrate awareness of real-world usage by mentioning thread-safety and memory management, and suggest how you would test the implementation with unit tests covering nested paths and concurrent access.

1. Clarify Requirements

Ask questions to understand the expected scale, concurrency needs, and whether fields are hierarchical with delimiters or arbitrary nesting. Confirm the exact semantics of setAndCompare and setAndDelete.

2. Choose Data Structure

Propose a nested hash map or trie to represent the key-value store with nested fields. Discuss trade-offs: hash maps offer O(1) average access but may use more memory; tries are efficient for prefix operations but more complex.

3. Design Operations

Define how each operation works: set stores a value at a nested path, get retrieves it, setAndCompare updates only if current value matches expected, setAndDelete removes a field. Handle edge cases like missing paths and type mismatches.

4. Address Concurrency and Memory

Discuss thread-safety using locks or concurrent data structures, and memory management strategies like reference counting or garbage collection for deleted nested fields.

5. Test and Optimize

Outline a testing plan with unit tests for each operation, including nested paths and concurrent scenarios. Mention potential optimizations like path compression or caching frequently accessed fields.

Key Points to Mention

Choice of data structure (nested hash maps vs. trie) and its impact on time/space complexity
Handling of nested paths: parsing delimiters, creating intermediate nodes, and avoiding orphaned fields
Atomicity and thread-safety for setAndCompare and setAndDelete operations
Memory management: garbage collection of empty nested maps and preventing memory leaks
Error handling: invalid paths, type mismatches, and concurrent modification exceptions
Testing strategy: unit tests for each operation, edge cases, and performance benchmarks

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