Coinbase·Software Engineer·Technical Phone Screen·Intermediate

Intermediate

Jun 2026

Summary

Coinbase SWE interview built around an in-memory file system problem split into four progressive parts, each unlocking only after you pass all test cases for the previous one. The structure is clever but unforgiving if you paint yourself into a corner early.

Questions Asked (1)

Design and implement an in-memory file system across four progressive parts: starting with basic file and directory creation plus read/write, then directory listing with sorted output and recursive mkdir, then move and delete with correct path semantics, and finally advanced features like hard links, snapshots, permissions, or file-size queries by prefix.

System DesignAlgorithms & Data StructuresTechnical Trade-offs

Author's notes

The gating mechanic tripped me up more than the actual coding.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and constraints for each part, then design a tree-based structure with nodes representing files and directories. Implement incrementally, ensuring each part builds on the previous, and discuss trade-offs (e.g., time vs. space) for advanced features. Test with edge cases like path normalization and concurrent access.

Pro tip: Demonstrate foresight by mentioning how you'd extend the design to support the advanced features from the start (e.g., using inodes for hard links), and proactively discuss trade-offs like using a trie for prefix queries versus a simple list.

1. Clarify Requirements and Constraints

Ask clarifying questions about expected operations, performance requirements, and edge cases (e.g., path formats, concurrency). Confirm whether the system should be thread-safe and what the scale is.

2. Design Core Data Structures

Propose a tree structure where each node represents a file or directory, with attributes like name, content, children, and metadata. For advanced features, consider inodes for hard links and versioning for snapshots.

3. Implement Basic Operations

Implement create, read, write, and mkdir with path resolution. Ensure correct handling of absolute and relative paths, and error cases like non-existent parents.

4. Add Advanced Features Incrementally

For each subsequent part, extend the design: sorted listing (use a sorted data structure or sort on demand), move/delete (update parent-child links), and advanced features (hard links via reference counting, snapshots via copy-on-write or versioning).

5. Analyze Trade-offs and Optimizations

Discuss time/space complexity of operations, potential optimizations (e.g., caching, indexing for prefix queries), and how the design scales. Mention concurrency control if needed.

Key Points to Mention

Path resolution and normalization (handling '.', '..', absolute vs relative paths)
Data structure choices: tree vs. trie vs. hashmap for directories, and their trade-offs
Efficient directory listing with sorting (e.g., maintaining sorted children or sorting on demand)
Hard links implementation using inodes and reference counting
Snapshots using copy-on-write or persistent data structures
Permissions model (e.g., simple owner/group/other bits) and enforcement
File-size queries by prefix: using a trie or sorted list for efficient range queries

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