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

SeniorPrefer not to say

May 2026

Summary

Snowflake system design round, one question about building a key-value store from scratch. Pretty focused session, they wanted to see how far you'd take the design before they had to prompt you.

Questions Asked (1)

Design an in-memory key-value store with put, get, and delete operations. How would you extend it to support TTL, snapshots, or transactions?

System DesignTechnical Trade-offsData Modeling

Author's notes

I covered the basics pretty fast and then just sat there waiting for them to push me toward the extensions.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and constraints, then design a basic in-memory key-value store using a hash map. For extensions like TTL, snapshots, and transactions, discuss trade-offs and implementation strategies, focusing on concurrency, consistency, and performance.

Pro tip: Demonstrate awareness of concurrency and memory management early, as these are critical for in-memory stores at scale. Also, relate your design to Snowflake's data platform needs, such as handling large datasets and ensuring durability.

1. Clarify Requirements

Ask about expected scale, read/write patterns, consistency needs, and durability requirements to tailor the design.

2. Design Core Operations

Propose a hash map-based store with put, get, and delete, discussing thread-safety and memory management.

3. Extend with TTL

Explain TTL implementation using timestamps and lazy or active expiration, considering trade-offs like memory overhead and CPU usage.

4. Extend with Snapshots

Describe snapshot mechanisms, such as copy-on-write or periodic serialization, and discuss consistency and performance impacts.

5. Extend with Transactions

Outline transaction support using locking, MVCC, or optimistic concurrency, and discuss isolation levels and atomicity.

Key Points to Mention

Concurrency control mechanisms (e.g., locks, MVCC) for thread-safe operations
TTL implementation strategies: lazy vs. active expiration, and their trade-offs
Snapshot techniques: copy-on-write, fork, or serialization, and their impact on performance
Transaction support: ACID properties, isolation levels, and implementation approaches
Memory management: eviction policies (LRU, LFU) and handling memory limits
Durability considerations: write-ahead logging or replication for persistence

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