PracHub
QuestionsCoachesLearningGuidesInterview Prep
|Home/System Design/Coinbase

Design a bank account ledger

Last updated: Jun 15, 2026

Quick Overview

A complete take-home system-design walkthrough for a bank account ledger service: APIs and data model, an immutable double-entry ledger for auditability, ACID single-account updates and atomic multi-account transfers, idempotency and exactly-once effects, concurrency control, real-time/as-of/historical balance reads, monthly statements, reconciliation with external payment rails, limits, fraud and dispute handling, plus sharding, replicas, recovery, and monitoring strategies for scale.

  • hard
  • Coinbase
  • System Design
  • Software Engineer

Design a bank account ledger

Company: Coinbase

Role: Software Engineer

Category: System Design

Difficulty: hard

Interview Round: Take-home Project

##### Question Design a bank account ledger service for a fintech app. It must support creating accounts, deposits, withdrawals, transfers between accounts, real-time balance queries, historical/as-of balance queries, transaction history, and monthly statements. Build it on an immutable double-entry ledger so the system is fully auditable. Cover the following: 1. **APIs and data model.** Define the core APIs and the underlying schema (accounts, transactions, immutable ledger entries, balance aggregates, holds, idempotency records, outbox events). 2. **ACID semantics and atomicity.** Guarantee ACID for single-account updates and atomic multi-account transfers; either all ledger entries for a transaction commit or none do. 3. **Balance and overdraft rules.** Enforce balance constraints and configurable overdraft limits; distinguish posted balance vs. available balance (net of holds). 4. **Idempotency and exactly-once processing.** Make all write APIs idempotent and ensure exactly-once *effects* for retries, duplicate requests, and inbound rail events. 5. **Concurrency control.** Handle concurrent transfers, race conditions, write skew, and deadlocks (isolation level, lock ordering, optimistic versioning). 6. **Real-time, as-of, and historical reads.** Serve real-time balances with read-your-writes guarantees, compute as-of-timestamp balances from the ledger, and paginate transaction history. 7. **Monthly statements.** Produce statements (opening balance, line items with running balance, totals, closing balance) and reconcile them against the ledger. 8. **Reconciliation with external payment rails.** Integrate ACH/cards/wires with idempotent callbacks, settlement ingestion, returns/chargebacks, and three-way reconciliation. 9. **Limits, fraud checks, and dispute handling.** Apply velocity/amount limits and risk checks synchronously before commit, monitor asynchronously, and model the dispute/chargeback workflow (provisional credit, resolution). 10. **Scale and consistency.** Describe sharding, indexing, read replicas, caching, and multi-region strategy while preserving consistency and auditability. 11. **Failure handling, recovery, and monitoring.** Cover retries, transactional outbox, backups/PITR, balance-rebuild paths, invariant audits, and observability/alerting on financial invariants. Include a concrete data model, core APIs, the transaction flow, failure handling, and how you would monitor correctness.

Quick Answer: A complete take-home system-design walkthrough for a bank account ledger service: APIs and data model, an immutable double-entry ledger for auditability, ACID single-account updates and atomic multi-account transfers, idempotency and exactly-once effects, concurrency control, real-time/as-of/historical balance reads, monthly statements, reconciliation with external payment rails, limits, fraud and dispute handling, plus sharding, replicas, recovery, and monitoring strategies for scale.

Related Interview Questions

  • Design Crypto Order Routing - Coinbase (hard)
  • Design a crypto trading web frontend - Coinbase (hard)
  • Design query pagination for large datasets - Coinbase (medium)
  • Design real-time crypto prices homepage - Coinbase (hard)
  • Design a food delivery system - Coinbase (medium)
|Home/System Design/Coinbase

Design a bank account ledger

Coinbase logo
Coinbase
Sep 6, 2025, 12:00 AM
hardSoftware EngineerTake-home ProjectSystem Design
59
0

Design a Bank Account Ledger

Design a bank account ledger service for a fintech app. The system is built on an immutable, double-entry ledger so it is fully auditable, and it must support:

  • Creating accounts
  • Deposits, withdrawals, and transfers between accounts
  • Real-time balance queries
  • Historical / as-of (point-in-time) balance queries
  • Transaction history
  • Monthly statements

Treat correctness and auditability as first-class constraints — a wrong balance is unacceptable — and design for them before optimizing latency and scale.

Constraints & Assumptions

These anchor the discussion; confirm them with your interviewer and adjust as needed. They do not change the deliverables.

  • Money is exact. Amounts are integer minor units (e.g. cents); no floating-point arithmetic anywhere on the money path.
  • Correctness over latency. A wrong or stale balance is never acceptable; a slightly slower-but-correct read is.
  • Single currency per account to start; cross-currency moves are out of the core scope unless you choose to model them.
  • Mixed read/write workload. Assume balance and history reads substantially outnumber postings, but postings must still be strongly consistent and auditable.
  • External rails are eventually consistent. ACH/card/wire settlement and returns arrive asynchronously (seconds to days), out of order, and possibly more than once.
  • Targets, not hard SLAs: treat any latency/throughput numbers you cite as design targets to anchor capacity and backpressure decisions, and say so explicitly.

Clarifying Questions to Ask

A strong candidate scopes the problem before designing. Reasonable questions include:

  • What is the scale — number of accounts, peak postings/sec, and the read:write ratio for balance vs. history queries?
  • Is this single-currency or multi-currency , and do we need cross-currency (FX) transfers in scope?
  • What durability / availability targets apply (RPO/RTO), and do we need multi-region writes or just multi-region reads?
  • Which payment rails must we integrate (ACH, cards, wires), and what are their settlement, return, and chargeback semantics?
  • What consistency guarantee does a balance read need — strict read-your-writes, or is bounded staleness acceptable for some read paths?
  • Are overdrafts allowed, and if so are limits per-account, per-product, or global?

What a Strong Answer Covers Premium

What to Cover

Address each part below. Per-part hints are click-to-reveal nudges — open them only if you are stuck.

  1. APIs and data model. Define the core APIs and the underlying schema (accounts, transactions, immutable ledger entries, balance aggregates, holds, idempotency records, outbox events).
  1. ACID semantics and atomicity. Guarantee ACID for single-account updates and atomic multi-account transfers; either all ledger entries for a transaction commit or none do.
  1. Balance and overdraft rules. Enforce balance constraints and configurable overdraft limits; distinguish posted balance vs. available balance (net of holds).
  1. Idempotency and exactly-once processing. Make all write APIs idempotent and ensure exactly-once effects for retries, duplicate requests, and inbound rail events.
  1. Concurrency control. Handle concurrent transfers, race conditions, write skew, and deadlocks (isolation level, lock ordering, optimistic versioning).
  1. Real-time, as-of, and historical reads. Serve real-time balances with read-your-writes guarantees, compute as-of-timestamp balances from the ledger, and paginate transaction history.
  1. Monthly statements. Produce statements (opening balance, line items with running balance, totals, closing balance) and reconcile them against the ledger.
  1. Reconciliation with external payment rails. Integrate ACH / cards / wires with idempotent callbacks, settlement ingestion, returns/chargebacks, and three-way reconciliation.
  1. Limits, fraud checks, and dispute handling. Apply velocity/amount limits and risk checks synchronously before commit, monitor asynchronously, and model the dispute/chargeback workflow (provisional credit, resolution).
  1. Scale and consistency. Describe sharding, indexing, read replicas, caching, and multi-region strategy while preserving consistency and auditability.
  1. Failure handling, recovery, and monitoring. Cover retries, transactional outbox, backups/PITR, balance-rebuild paths, invariant audits, and observability/alerting on financial invariants.

Deliverables

Be concrete. Your answer should include:

  • A data model (schema for the key tables)
  • The core APIs
  • The transaction flow (how a posting/transfer commits atomically)
  • Failure handling
  • How you would monitor correctness

Follow-up Questions

Be ready for the interviewer to push deeper:

  • How does this change at 100x write volume? Where is the first bottleneck — the balance aggregate hot row, the double-entry constraint, a single-shard system account, or replica lag — and how do you relieve it?
  • What breaks first under a region failure mid-transfer, and what is your RPO/RTO story for recovery without losing or duplicating a posting?
  • Prove the books are correct after an incident. How would you detect a silent drift between the aggregate and the ledger, and rebuild from the journal?
  • A customer disputes a card charge while an ACH return for the same funds is in flight. How do the two workflows interact without double-counting or creating money?

Submit Your Answer to Earn 20XP

Sign in to leave a comment

Loading comments...

Browse More Questions

More System Design•More Coinbase•More Software Engineer•Coinbase Software Engineer•Coinbase System Design•Software Engineer System Design

Your design canvas — auto-saved

PracHub

Master your tech interviews with 8,000+ real questions from top companies.

Product

  • Questions
  • Learning Tracks
  • Interview Guides
  • Resources
  • Premium
  • For Universities
  • Student Access

Browse

  • By Company
  • By Role
  • By Category
  • Topic Hubs
  • SQL Questions
  • AI Coding Questions
  • Compare Platforms
  • Discord Community

Support

  • support@prachub.com
  • (916) 541-4762

Legal

  • Privacy Policy
  • Terms of Service
  • About Us

© 2026 PracHub. All rights reserved.