← Applied intuition Interview Insights

Applied intuition·Software Engineer·Onsite - System Design / Architecture·Senior

Senior
Jul 2026

Summary

System design round at Applied Intuition for a software engineer role. The whole thing was one big deep-dive into building a transactional key-value store, and they really pushed on the distributed systems tradeoffs rather than letting me stay at a surface level.

Questions Asked (1)

Q1

Design a key-value store that supports transactional operations including begin, commit, rollback, and nested transactions. Walk through your choices around isolation levels, concurrency control, durability, and how you'd scale it.

System DesignTechnical Trade-offsData Modeling
Author's notes

This is a lot to unpack in one question.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scope, then propose a high-level architecture that separates storage, transaction management, and concurrency control. Discuss trade-offs for isolation levels, durability mechanisms, and scaling strategies, and explain how nested transactions are handled via savepoints.

Pro tip: Emphasize that nested transactions are typically implemented as savepoints within a single top-level transaction, and that true distributed transactions require consensus protocols like Raft or Paxos, which impact latency and complexity.

1. Clarify Requirements and Scope

Ask about expected scale, consistency needs, latency requirements, and whether the store is single-node or distributed. This shapes choices around isolation, durability, and scaling.

2. Design Core Architecture

Propose a layered design: a storage engine (e.g., LSM-tree or B-tree), a transaction manager, and a concurrency control module. Explain how they interact.

3. Choose Isolation and Concurrency Control

Select an isolation level (e.g., snapshot isolation) and a concurrency control method (e.g., MVCC with optimistic or pessimistic locking). Justify based on trade-offs.

4. Implement Transactions and Nested Support

Describe how begin, commit, rollback work, and how nested transactions are implemented using savepoints. Discuss logging for atomicity and durability.

5. Address Durability and Scaling

Explain write-ahead logging, replication, and partitioning/sharding strategies. Discuss how to maintain consistency across shards (e.g., 2PC or consensus).

Key Points to Mention

  • Isolation levels (read committed, snapshot isolation, serializable) and their trade-offs
  • Concurrency control mechanisms: MVCC, 2PL, optimistic vs pessimistic locking
  • Durability via write-ahead logging (WAL) and fsync policies
  • Nested transactions as savepoints, not independent transactions
  • Scaling through sharding, replication, and consensus protocols (Raft/Paxos) for distributed transactions
  • Handling failures: rollback, recovery, and idempotency

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