Financial ledger requirements checklist

The requirements to settle before choosing a ledger for balances and transfers, how to verify each one, and the questions that separate TigerBeetle, Blnk and other options.

On this page

How to use a ledger requirements checklist before choosing a platform

A fintech or regulated lender whose balances sit in spreadsheets or an application database needs to settle requirements before comparing any ledger. The requirements come first, then the scoring. Scoring TigerBeetle, Blnk or a hand-built PostgreSQL design against a vague brief produces a preference, not a decision. This section explains how to use the checklist on this page: fix each requirement in writing, weight the few that decide the outcome, and then test the candidates against them. The rest of the page covers the individual requirement areas.

Start with the requirements that act as hard gates. Transaction volume and peak latency set the throughput the ledger must sustain, and they should be measured from your current payment and transfer logs, not estimated. Idempotency behavior decides whether a retried payment can post twice, so write down which identifiers your payment providers send and how duplicates must be rejected. Availability targets, recovery point and recovery time, and the audit access your examiners or auditors will need should be stated as numbers and named owners. If a candidate cannot meet a gate, it should drop out before any feature comparison begins.

Then test each claim rather than accepting it. The research supplied for this page does not establish ledger-specific behavior for TigerBeetle or Blnk, so confirm every capability on the checklist (pending transfers, multi-currency accounts, balance snapshots, reconciliation rules, license terms for the features you need) against the current vendor documentation and the license text. Then run your own tests: replay a sample of real transactions, inject duplicate and failed requests, and time a month-end reconciliation. Record the results next to each requirement so the decision can be defended later to a regulator, auditor or board.

Functional requirements every ledger must meet and how to verify them

This table pairs each core ledger requirement with why it matters and a concrete check you can run before selecting a platform. Use it as a test plan: if a candidate cannot pass a check in a staging environment, treat that gap as a finding rather than a footnote. The main takeaway is that correctness claims are only as good as the replay, rebuild and reconciliation tests behind them.

RequirementWhy it mattersHow to verify it
Transaction volume and latencyPeak posting rates and tail latency decide the hardware, replica layout and whether payment flows can wait on the ledger. Averages hide the bursts that cause failed payments.Load test against your documented peak, including month-end and payout batches. Record p99 posting latency and confirm the target with the vendor or your own benchmark, not a brochure figure.
Account modelCustomer wallets, operating accounts, fee accounts and suspense accounts need different balance rules, such as whether an account may go negative. Retrofitting account types later is costly.Write the account catalog as a table of account types, allowed balance direction and owner. Post a test set covering each type and confirm the platform enforces the rules instead of relying on application code.
Multi-currencyEach currency needs its own balances, rounding and minor-unit handling. Cross-currency transfers need an agreed conversion record so totals still balance per currency.Post transfers in every currency you support, including zero-decimal and three-decimal currencies. Confirm that each currency's debits and credits net to zero and that FX legs carry the rate and timestamp used.
Pending and posted transfersAuthorizations, holds and escrow require funds to be reserved, then posted or voided. Errors here create phantom available balances.Test the full lifecycle: create pending, partially post, void, expire and post after timeout. Confirm available balance excludes pending amounts at every step and that voided amounts return exactly.
IdempotencyNetwork retries and client timeouts are normal. Without idempotency keys, one payment can post twice.Replay the same request with the same key many times, including concurrent replays and replays after a simulated timeout. Expect one posted transfer and an identical response each time. Also test that a reused key with a different payload is rejected.
History and snapshotsBalances must be explainable from the entries that produced them. Snapshots speed up reads but must never become the source of truth.Delete or corrupt a cached balance in a test copy, then rebuild every affected balance from the immutable entry history. Compare the rebuilt values with the originals and keep the comparison as evidence.
ReconciliationInternal balances must match bank statements and processor settlements, with timing differences tracked rather than hidden. Unmatched items need an owner and an age.Load a sample bank file and processor export with planted timing differences, duplicates and missing items. Confirm matches, exceptions and aging are produced, and that the month-end totals agree with the ledger.
Correcting entriesReversals and adjustments should be new entries that reference the original, so history stays intact for auditors.Post a refund, chargeback and manual adjustment in test. Confirm the original entry is unchanged, the correction links to it and the net balance matches the expected outcome.

How transaction volume and latency decide the architecture

The first architecture decision is whether a purpose-built ledger is needed at all, and that depends on three measurements: peak write rate, sustained write rate and the latency the payment flow can tolerate before a customer sees a delay or a payment provider times out. A relational database handles double-entry postings well at moderate volume. The question is whether your peak, not your daily average, stays within what your chosen design can commit while holding the consistency guarantees your balances require. Measure peak per second and per minute over at least one full business cycle that includes month end, payroll runs and promotional spikes, and keep those numbers separate from the average transactions per day in your business case.

Hot accounts are the variable that most often breaks assumptions. A settlement account, a fee account, or a single merchant wallet that receives thousands of credits in a short window serializes every write that touches it, no matter how many nodes you add. Map the top accounts by write frequency for your busiest hour, and count how many transfers would contend on the same balance. Ask each candidate platform how it handles contention on a single account, whether it batches or sequences those writes, and what throughput a single hot account can sustain. Ask vendors for the benchmark conditions behind any published throughput figure, including record size, transfer type, replica count, durability settings, network topology and whether the test used a single account or spread load across many. A headline number without those conditions cannot be compared with your workload.

Finally, confirm the latency budget with the teams that own the payment flow, not only with the ledger team. Identify whether the ledger sits on the synchronous path of an authorization, a transfer confirmation or only on an asynchronous posting step, and record the timeout values set by payment providers and internal services. A ledger that commits in a few milliseconds on a benchmark can still fail the flow if replication across sites adds round trips that your recovery objectives require. Plan a load test that replays your own peak profile, including the hot-account pattern and a failover event, and record latency at the 99th percentile, not only the median. The results decide whether a relational build, a purpose-built ledger or a managed service fits the volume you actually expect.

Security requirements a ledger must satisfy before go-live

A ledger holds customer balances and money movement, so the controls around it are as important as its posting logic. The cards below map the security requirements most likely to apply to a fintech ledger, drawn from the FTC Safeguards Rule and the practices assessors commonly test. Each card names what to verify before go-live, so the checklist can be turned into evidence.

Encryption in transit and at rest

The FTC Safeguards Rule at 16 CFR 314.4 requires covered institutions to encrypt customer information in transit over external networks and at rest. For a ledger, this covers client connections, replication traffic between nodes or sites, backups and snapshots. Verify every data path, including the replication and backup paths that are easy to miss. Ask the vendor or your team to document cipher suites, key lengths and where keys are stored, and test that unencrypted connections are refused.

Multi-factor authentication for all access

The Safeguards Rule requires multi-factor authentication for any individual accessing any information system. For a ledger, this applies to operators, developers with production access, support staff and service accounts that have an interactive path. Verify that MFA is enforced at the identity provider and at any administrative console, not only at the VPN. Test that a password alone cannot open an administrative session.

Logging of authorized user activity

The Safeguards Rule requires institutions to log the activity of authorized users. For a ledger, logs should record who viewed or changed balances, who ran reversals, who altered posting configuration and who accessed backups. Verify that logs are shipped off the ledger host, are tamper-evident and are retained long enough for your reviewers. Run a test transaction and confirm that the trail shows the operator, the time and the action.

Change management for posting logic

The Safeguards Rule requires change management procedures. In a ledger, a change to posting rules, account templates or transfer validation can alter balances without touching any stored record. Verify that these changes go through a documented review, are tested against reference transactions and are traceable to an approver. Confirm that emergency changes follow a defined path and are reviewed afterward.

Key and secret handling

Encryption keys, database credentials and connector API tokens are the keys to the ledger. Verify where each secret lives, who can read it, and how it is rotated after staff changes or suspected exposure. Confirm that payment connector credentials are not stored in configuration files or code repositories. Ask for the procedure for revoking a key, and rehearse it before go-live.

Least-privilege operator access

Operators need enough access to investigate and correct entries, but few people should be able to post or reverse at scale. Verify that roles separate read access, correcting entries and administrative changes, and that break-glass access is time-limited and logged. Review role assignments against the account list before go-live and again on a set schedule. Confirm that no shared administrative accounts exist.

Penetration testing without continuous monitoring

Under 16 CFR 314.4(d)(2), an institution without effective continuous monitoring must run annual penetration testing and vulnerability assessments at least every six months. For a ledger, scope the test to the API, the operator console, the replication network and the connector paths to payment providers. Verify that findings are tracked to closure and that retests confirm the fix. If you rely on continuous monitoring instead, document how it meets the rule.

Network segmentation from payment connectors

Payment connectors hold card data, bank credentials or tokens and call external networks, so they widen the attack surface around the ledger. Verify that the ledger accepts traffic only from the named connector and operator networks, and that connectors cannot reach the ledger's replication ports or database directly. Test the boundary with a scan from the connector segment, and confirm that outbound connector traffic is restricted to the processors you contract with.

How license terms and deployment model change the requirements

With a self-hosted core, the license grants the right to run, modify and redistribute the code inside your own infrastructure, and no vendor sits between your ledger and your data. Permissive licenses such as Apache-2.0 generally allow commercial use and modification without requiring you to publish your changes, while copyleft licenses such as AGPL-3.0 can require source disclosure if you offer a modified version to users over a network. Apache-2.0 is the license used by Apache Fineract and Hyperswitch, and AGPL-3.0 by SuiteCRM, so these are useful examples of how to read terms, not statements about any ledger.

  • Patch ownership: Your team or a contracted partner applies security fixes, dependency updates and upgrades, and you carry the cost of testing each release against your posting logic.
  • Keys and data: Encryption keys, replica placement and backups stay under your control, which is the main reason regulated buyers choose this model.
  • Modification rights: Confirm whether your changes to posting rules or reconciliation logic trigger any disclosure duty under the exact license.
  • Exit: Your data is in a format you can export, but confirm the schema, the ledger's internal identifiers and the tooling you would need to move balances elsewhere.
  • Support: Community support exists for many projects, so confirm what response commitments, if any, you would need from a commercial party.

Before you commit, read the license file for the specific ledger you are evaluating, including any notices on dependencies and optional modules.

What audit access and record retention require from the ledger

Auditors need a complete, immutable history of every balance movement, and the ledger has to prove that history was never silently rewritten. In practice this means every posted transfer is kept, corrections are made by new linked entries rather than edits or deletes, and each entry carries the identifiers that let an auditor trace it back to its originating payment, instruction or adjustment. Before you select a platform, confirm how the candidate stores committed transfers, whether it allows any form of update or deletion on posted data, and what the operator can do with direct database access. Ask each vendor or implementation partner to show you a worked example of reversing a posted transfer and the resulting trail.

Auditors also ask who changed the posting logic and when. The ledger's account types, transfer templates, fee rules and balance-check conditions are effectively financial controls, so their changes need the same change management and access review as application code. Decide early which roles can create accounts, alter rules and read full history, and whether those roles are separated. Make sure the chosen design exports immutable logs of administrative actions to a system the ledger operators cannot edit.

For retention, the closest supplied baseline is the SEC's Rule 17a-4(b), which requires broker-dealers to preserve certain records, including bills receivable or payable and bank statements, for not less than three years, with the first two years in an easily accessible place. That rule governs broker-dealers, and other entities should not assume it applies to them. Confirm your own retention periods, storage format and retrieval expectations with counsel and your external auditors, then write the retention requirement into the ledger design as a testable requirement, including how long archived partitions must remain readable.

What buyers ask before hiring help to choose a ledger

How much does it cost to select and implement a ledger?

The cost depends on the written scope, not on a standard rate, and DeployOpen does not publish a price list. The main cost components are the selection work (requirements, platform comparison, correctness and failure-mode review), the implementation work (deployment in your infrastructure, integration with payment providers and the general ledger, reconciliation setup), and the testing and evidence work that your auditors will ask for. Costs that recur include infrastructure, monitoring, backups, upgrades and any support retainer. Scope rises with the number of currencies, the number of upstream and downstream systems, the volume and latency targets, and the number of compliance regimes in play. Ask any firm for a quote that lists each deliverable, what is one-time, what recurs, and which items the client provides.

How long does a ledger selection project take?

Duration is set by how settled your requirements are and how many decisions depend on the outcome. A selection that starts from a documented list of volumes, latency targets, account models and audit needs moves faster than one that discovers those needs during vendor evaluation. Timelines also depend on the access your team can give to environments, data samples and decision makers, and on how many stakeholders must sign off on the platform and the operating model. Implementation timing is set separately once the platform is chosen. Ask for a timeline in the written scope with named milestones and the client dependencies behind each one.

What does the internal team need to provide for a ledger project?

Your team supplies the decisions and the facts that no outside party can supply. In practice this means:

  • Transaction volumes, peak rates and the latency each product or payment flow can tolerate
  • The account model, currencies and the rules for pending, posted and voided transfers
  • Reconciliation sources such as bank statements and processor exports, with sample files
  • Availability targets, recovery objectives and the people who approve incident handling
  • Audit access requirements, identity provider details and change approval roles
  • Licensing review of the chosen platform by your legal and procurement teams

The team also needs one named owner for the ledger's posting logic and one for infrastructure. Without these, the selection stalls on questions that only your organization can answer.

Can our own engineers run a ledger selection without outside help?

Yes, a capable internal team can run a selection, provided it has engineers who understand double-entry accounting, idempotent request handling and database failure modes, and finance staff who can judge reconciliation output. The risks are less about the comparison itself and more about the testing that follows. Teams often underestimate how long it takes to prove correctness under concurrent load, partial failures and retries. Outside help is most useful for an independent review of the requirements, a structured test plan, and evidence that an auditor or regulator can follow. Confirm your internal capacity against the full list of requirements before deciding who runs each step.

What questions separate one ledger platform from another?

Ask questions that expose how the platform behaves when things go wrong. Useful checks include how it enforces idempotency on retried requests, how it represents pending and posted transfers, how corrections are recorded instead of edited, how balances are queried at a past point in time, and what happens during node or site failure. Also ask how the platform is licensed, which parts are open source, and which features sit behind a commercial edition, since a ledger's operational tooling is often outside the core license. Check the release cadence and security advisory process in the project's own repository and documentation. Confirm each answer by a test in your environment, not only by the vendor's description.

How do you test ledger correctness before go-live?

Correctness testing combines functional checks with failure testing. Functional checks confirm that each transfer posts both sides, that balances match the expected totals, and that duplicate requests with the same idempotency key do not post twice. Failure testing injects timeouts, restarts, lost acknowledgments and concurrent writes against the same accounts, then compares the ledger with the source records. Reconciliation runs against bank and processor files are the final control. Record each test, its expected result, the actual result and the person who approved it, because that record is the evidence auditors and regulators will request. Plan the scope of testing as part of the written engagement, and ask the partner to show how the test evidence is stored and reproduced.

How do you migrate a ledger to a different platform later?

Migration is easier when the ledger design keeps history immutable and records every balance change as a transfer with a stable identifier. Migration plans usually cover three elements: an export of accounts, balances and transfer history with checksums, a cutover window in which new postings are paused or dual-written, and a reconciliation that proves the new system matches the old one at the cutover point. Plan for running both systems in parallel for a period, and for keeping the old ledger readable for the retention period your regulators require. Ask any partner how they would verify completeness and how rollback would work before a cutover begins.

Operational requirements and how to verify each one

This table pairs each operational requirement for a self-hosted ledger with the evidence to collect and the verification step that proves it works. Read each row as a question to put to your team or implementation partner before choosing a platform. The main takeaway is that a stated target means little until a timed restore drill, a reconciliation break test or a failover exercise has demonstrated it.

RequirementWhat to settleHow to verify
Backup and restore testingScope of backups covering ledger state, configuration, posting logic and keys, plus who owns the backup scheduleTimed restore drill into an isolated environment, followed by a balance comparison against pre-backup totals
Recovery time and recovery point targetsMaximum tolerable downtime and maximum tolerable data loss, set by the business owner of each balance typeRecord the measured restore duration and last committed transfer in each drill and compare them with the agreed targets
Monitoring and alerting on balance integrityAlerts for failed postings, unbalanced batches, stalled reconciliation and balances outside agreed limitsInject a controlled mismatch in a test environment and confirm the alert reaches the on-call channel within the agreed window
Upgrade and patch processRelease tracking for the chosen ledger and its database, staging environment, rollback plan and change approvalApply a release to staging, replay a sample of production transfers and confirm balances match before approval
Incident evidenceLog retention, timeline capture, root cause records and correcting-entry approvals for each incidentRun a tabletop exercise and check that logs, approvals and affected-balance reports can be produced without ad hoc queries
Capacity planningPeak transfer rate, growth forecast, storage growth for history and snapshots, and headroom for reconciliation jobsRun a load test at projected peak plus a margin you define, and record latency and resource use at each step
On-call ownershipNamed primary and secondary owners for ledger service, database, integrations and finance escalationTest the escalation path with a scheduled page and confirm each owner acknowledges and has access to runbooks
Reconciliation break testExpected handling for unmatched items, timing differences and processor settlement gapsInject known breaks into a copy of the data and confirm they appear in the exception queue with correct ageing

Questions that separate ledger platforms in a vendor evaluation

This sequence turns a written ledger requirements list into comparable evidence from each candidate platform. By the end, you hold tested answers on correctness, recovery, licensing and reconciliation rather than marketing claims.

  1. Send the written requirements to each candidate

    Send the completed requirements checklist to every shortlisted platform and its implementation partner, covering transaction volume and latency, account model, multi-currency handling, pending transfers, idempotency, history and snapshots, availability targets, audit access and license terms. Ask each vendor to answer line by line, marking each item as supported, supported with configuration, custom work or not supported. The output is a written response per candidate that you can compare side by side, with any gap stated in the vendor's own words.

  2. Run a reference test on your transaction patterns

    Give each candidate a test script built from your own transaction patterns, including peak batch windows, transfer chains, multi-currency postings and reversals, and ask for measured throughput and latency on hardware that matches your planned topology. Confirm whether the test runs in your environment or the vendor's, because results from a different topology do not carry over. The output is a dated test report with the inputs, configuration and raw results attached, so your engineers can rerun it.

  3. Ask how duplicate requests and partial failures behave

    Ask each vendor to explain, in writing and then in a live test, what happens when the same transfer request is sent twice, when a client times out after the ledger has committed, and when a multi-leg transfer fails partway. Check how idempotency keys are scoped, how long they are retained, and whether a retried request returns the original result. The output is a set of test cases with expected and observed outcomes, signed off by your engineering lead.

  4. Ask for the immutability and correction model

    Request the vendor's written description of how posted entries are protected from edit or deletion, how corrections are recorded as new entries, and who can perform administrative actions on stored data. Ask for an example of a correcting entry for a refund and for a chargeback, traced through the history view. The output is a documented model that your audit and risk teams can review before any integration work starts.

  5. Request evidence of recovery testing

    Ask for recent recovery test records, including the scenarios covered, such as node loss, site loss and restore from snapshot, the recovery time and recovery point observed, and any open findings. Confirm which parts of the test the vendor runs and which your team or a partner must run in your own infrastructure. The output is a set of test records you can file as evidence, along with a list of tests you still need to perform yourself.

  6. Review the license and support terms

    Have legal and procurement read the license for the exact edition under consideration, paying attention to restrictions on hosting, modification, redistribution and any features held under a separate commercial license. Ask the vendor or partner to state which support, upgrade and security patch commitments are included, how they are priced, and who is responsible for each. The output is a written summary of license obligations and support scope that is signed off before shortlisting ends.

  7. Run a reconciliation trial with real processor exports

    Load a sample of recent bank statement and payment processor exports, with the timing differences and exceptions your finance team actually sees, into a trial instance and check how the platform matches entries, flags unmatched items and produces the month-end reports finance needs. Measure how many items need manual handling and whether each exception can be traced to its source record. The output is a reconciliation report from your own data that finance signs off on as the basis for the final decision.

What to confirm with vendors and your own environment

Several ledger-specific capabilities decide whether a platform fits your requirements, and the supplied research does not describe them. Replication topology, the number of replicas and sites a deployment supports, reconciliation rule support, and how idempotency keys are accepted, scoped and retained are all points you must confirm directly with the vendor. Ask for the current documentation, the versions it covers, and any known limits on throughput or account counts. Treat a verbal answer as unconfirmed until it appears in writing with a version number attached.

Vendor answers are only half the evidence. Check each claimed behavior in your own environment with a proof of concept that uses your transaction shapes, including duplicate submissions, partial failures during a replica restart, and a pending transfer that expires before it is posted. Confirm that the platform runs on the infrastructure you intend to use, whether that is your cloud account, a data center or an air-gapped network, and record which team operates each component. A test that passes on a vendor demo cluster does not establish that your own network, storage and identity setup behave the same way.

Record every answer, the document or test that supports it, the date, and the name of the person who confirmed it in the requirements document. Mark any item still open as a decision with an owner, because an unresolved replication or idempotency question will otherwise surface during go-live or an audit. Ask the vendor to state its license terms for the features you need, since some capabilities may sit under a different license or edition than the core product. Keep this record current as the requirements change, so the platform choice can be traced back to the evidence behind it.

How DeployOpen scopes and delivers ledger selection and implementation

DeployOpen works on the financial ledger requirements checklist as a written, fixed-scope engagement inside your own infrastructure. We turn the open questions on volume, account model, idempotency, reconciliation, availability and license terms into a documented decision and a delivery plan you can review before work starts.

How we scope

  • Written scope covers each checklist item: volume, latency, account model, currencies and pending transfers.
  • We document availability targets, recovery expectations and the audit access your evaluators will need.
  • Scope also records license terms review and which ledger candidate is being evaluated against your requirements.

How we build

  • We stand up a test environment in your cloud account or data center to measure throughput against your stated targets.
  • Idempotency, transfer lifecycle and reconciliation behavior are tested with scenarios written from your business rules.
  • Hardening, access control and logging settings are configured to match the evidence your compliance team has requested.

How we hand over

  • Deliverables include the signed requirements record, architecture notes, test results and an operations runbook.
  • Evidence packs map configuration and test outputs to the controls your assessors ask about, without claiming any certification.
  • Handover sessions walk your engineering, finance and security teams through the system and its open decisions.

How we support

  • Ongoing support, upgrades and continuous testing are available as a retainer after handover.
  • Retainer scope, response expectations and upgrade cadence are agreed in writing before the retainer begins.
  • Changes to posting logic or integrations can be reviewed and tested again under the same documented process.

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.