Interview concept

Concurrency Control For In-Memory Financial State

Asked of: Software Engineer

Last updated

What's being tested

This topic tests whether you can preserve financial invariants when multiple threads or requests update shared in-memory state concurrently. The interviewer is probing your understanding of linearizability, lock and atomic-operation semantics, race-condition diagnosis, and the tradeoffs among mutexes, optimistic concurrency, and serialized ownership. Ramp handles balances, card limits, reimbursements, and authorization decisions where a rare lost update or double spend is a correctness failure, not merely a performance defect.

Core knowledge

  • Define invariants before choosing synchronization. For an account, a typical invariant is balance >= 0; for a transfer, total money is conserved: Ba′+Bb′=Ba+BbB_a' + B_b' = B_a + B_b. State exactly which intermediate states may be observed.

  • Linearizability means each operation appears to take effect atomically at one instant between invocation and response. A correct withdraw(account, amount) must validate the balance and apply the decrement within the same synchronization boundary.

  • A mutex protects a critical section containing both the read and write. lock → check invariant → mutate → unlock is correct; locking only the assignment is not. Always release with defer/finally or an RAII guard.

  • Atomic operations such as compare-and-swap, fetch_add, and increment protect individual machine-level updates, but they do not automatically protect compound logic. “Check balance, then subtract” requires a CAS loop or a lock because the check and mutation must be one logical operation.

  • Optimistic concurrency stores a version with the value and updates only when the version is unchanged: CAS((balance, v), (balance - amount, v + 1)). Retry on contention, but bound retries or fall back to locking under hot-key contention.

  • Choose lock granularity deliberately. A single global lock is easiest to prove correct but serializes unrelated accounts; one lock per account improves throughput but makes multi-account transfers require deterministic lock ordering to avoid deadlocks.

  • A read-write lock helps only when reads substantially outnumber writes and read snapshots need protection. It does not make a multi-object operation atomic, and writer starvation or lock-upgrade behavior can create correctness and latency problems.

  • Actor-style ownership gives each account or shard one event loop and processes mutations sequentially. It avoids shared-memory races, but cross-account transfers require a protocol, ordering rule, or coordinator; mailbox ordering alone does not provide global atomicity.

  • For transfers, synchronize the complete operation across both accounts or use a consistent ownership strategy. Lock accounts in ascending stable ID order, validate both balances, mutate both, and publish the result only after the invariant is restored.

  • Idempotency protects against retries, not simultaneous threads by itself. Store a request or transaction identifier with the applied result, and atomically check-and-record it with the state change; otherwise a timeout retry can debit twice.

  • In-memory synchronization does not provide durability or cross-process safety. A process crash loses state, and two service replicas have independent locks. If correctness spans replicas, use an authoritative transactional store, a single writer, or a distributed coordination design.

  • Use integer minor units such as cents, not binary floating point, for money. Validate positive amounts, overflow, account identity, currency, and authorization before mutation; reject malformed or duplicated operations without partially changing state.

Worked example: Design concurrency control for an in-memory account balance

A strong candidate would first clarify whether the process is single-instance, whether operations include transfers, what consistency guarantee is required, and whether state must survive crashes. They would declare an assumption such as: multiple request threads share one process, withdrawals must be linearizable, and no account may become negative. The answer would be organized around the invariant, synchronization boundary, contention strategy, and failure/idempotency behavior. For a simple implementation, they would use a per-account mutex and perform the balance check and decrement while holding it. For transfers, they would acquire both account locks in ascending account-ID order, validate both accounts, mutate both, and release them safely. The explicit tradeoff is that per-account locks improve unrelated-account throughput but require careful ordering and complicate lock lifecycle management, whereas one global mutex is easier to prove but limits concurrency. They would mention metrics such as lock wait time, rejected withdrawals, retry counts, and p99 operation latency. If they had more time, they would also discuss crash recovery, multi-process ownership, and durable transaction records.

A second angle: Prevent double spending across concurrent authorization requests

Here the central framing shifts from protecting a mutable object to guaranteeing that multiple authorization attempts consume one shared spending limit correctly. Ask whether authorizations are reservations, whether they expire, and whether the limit is per card, employee, merchant, or billing period. A strong design uses an atomic conditional update—such as limit_remaining >= amount followed by decrement—or serializes all mutations for that limit owner. It must also attach an idempotency key so a retried authorization does not consume the limit twice. If several replicas can process requests, an in-process mutex is insufficient; the authority must move to a transactional datastore or a single-owner partition.

Common pitfalls

Pitfall: Saying “use an atomic integer” while performing a separate balance check and decrement. An atomic write prevents torn updates, but it does not make the entire conditional operation atomic; use a mutex or CAS loop.

Pitfall: Ignoring the scope of the lock. A correct per-thread or per-object lock does nothing if requests can reach multiple processes or hosts; explicitly identify the shared-state boundary and the system that owns it.

Pitfall: Jumping directly to distributed locks without first stating the invariant and required consistency. Interviewers want a simple design that can be proven correct, followed by justified scaling extensions—not unexplained infrastructure complexity.

Connections

An interviewer may pivot to database transactions, serializable isolation, idempotency keys, deadlock detection, or event sourcing. They may also ask how a single-process design evolves into sharded ownership across service instances while preserving per-account ordering.

Further reading

Related concepts