HN Debrief

Fintech Engineering Handbook

  • Fintech
  • Programming
  • Infrastructure
  • Developer Tools

The post is a short handbook for engineers entering fintech. It lays out common patterns for handling money safely, including integer or decimal amount types instead of floats, immutable records, idempotency keys, append-only logs, retries, webhooks, and auditability. Most readers agreed it is a solid primer for people who have not yet learned these lessons the hard way. The pushback was not that the core advice is wrong. It was that the hardest parts of fintech live in the exceptions and the interfaces. The biggest fight was over money representation. Plenty of people defended the handbook’s default stance that amounts should usually be stored as integers in a smallest unit or in decimal types, especially across databases and APIs. But experienced readers kept stressing that there is no universal internal format that survives every case. FX, crypto, stablecoins, fee calculations, fractional pricing, and partner integrations all break simplistic "just use cents" thinking. The consensus that emerged was sharper than the handbook itself: internal math can vary by use case, but boundary formats must be explicit, and rounding rules must be documented and enforced at every boundary where data is parsed, transformed, stored, or compared. JSON got special attention because its "number" type is underspecified in practice and often gets funneled through JavaScript-style double precision. Several readers argued that if you expose amounts in JSON, strings or explicit amount-plus-scale formats are often safer than naked numbers. Outside the amount-format fight, the strongest additions were operational. People called out that event sourcing is not mandatory everywhere, but append-only audit trails are. Exactly-once delivery is fantasy, effectively-once processing is the real goal. Store inbound and outbound payloads. Preserve data lineage so you can replay a past computation with the exact vendor inputs that existed at the time. And do not confuse available-balance checks with settlement certainty, especially in ACH. A few readers thought the handbook overreached on regulation-sensitive topics like separating personally identifiable information from financial history for deletion purposes, arguing that real retention and know-your-customer obligations are jurisdiction-specific and need legal review. That landed as a broader warning: this is useful engineering guidance, but fintech architecture is constrained as much by counterparties, settlement mechanics, and compliance regimes as by code.

Treat this as onboarding material, not a spec. If you build anything that moves money, lock down your amount formats, rounding rules, audit trail, and compliance assumptions at system boundaries before you write much code.

Discussion mood

Mostly positive and pragmatic. Readers liked it as a compact starter guide, but experienced fintech engineers immediately stress-tested the weak spots, especially money representation, rounding, and where generic software advice stops being enough in regulated financial systems.

Key insights

  1. 01

    Append-only beats full event sourcing

    An append-only audit trail often gets you the immutability and traceability you need without the pain of rebuilding current state from a full event-sourced system. The sharper requirement is not "event source everything" but "never lose the raw facts," including external requests, responses, and internal transformations that explain how a result was produced.

    If you are early in a fintech stack, start with an append-only audit log before you commit to system-wide event sourcing. Make replay and forensic reconstruction cheap from day one.

      Attribution:
    • belmarca #1
  2. 02

    API amounts need explicit scale

    The important failure mode is not just float precision. It is hidden assumptions about decimal places. A bare integer in an API is dangerous when partners, vendors, or assets disagree on implied scale. Several readers converged on the same fix in different forms: expose scale as data, whether through a decimal string or an amount-plus-decimals structure, so the representation itself warns integrators that precision is part of the contract.

    For external APIs, do not rely on "minor units" being inferred. Include currency and scale explicitly, and test partner integrations for silent 10x or 100x mistakes.

      Attribution:
    • lxgr #1 #2
    • noitpmeder #1
    • jameshart #1
  3. 03

    Silent amount bugs are the real threat

    The strongest argument against clever compact representations was not theoretical purity. It was incident history. Engineers described the dangerous class of bugs as scale mismatches that do not throw errors, pass through ETL jobs and one-off scripts, and only surface later as large notional mistakes. That changes the tradeoff. Readability and explicitness are worth real overhead when money values cross teams and systems.

    Design amount formats for the worst day, not the happy path. Assume somebody will bypass your ideal adapter during an incident and make the unsafe path hard to take.

      Attribution:
    • gib444 #1
    • lxgr #1
    • andylynch #1
  4. 04

    Most advice is really distributed systems

    Retries, idempotency, ordering, webhooks, and audit trails are not uniquely fintech ideas. They are distributed systems basics with harsher consequences because the payload is money. Readers wanted more material on what is actually finance-specific, especially ledger design, accounting rules, market structure, and compliance-driven architecture.

    If you already run reliable distributed systems, the new work is not learning retries again. It is learning accounting, settlement, and regulatory constraints deeply enough to know where generic patterns stop being sufficient.

      Attribution:
    • benashford #1
    • dapperdrake #1
    • jappgar #1
  5. 05

    Balance checks do not predict ACH success

    A bank balance snapshot is only a hint, not a commitment. Funds can disappear before an Automated Clearing House debit settles through other debits, wires, checks, or card activity. This is a concrete example of why fintech systems fail when they confuse observed state with final settlement state.

    Do not underwrite payment risk off a single balance check. Build products and fraud controls around settlement uncertainty, returns, and overdraft behavior.

      Attribution:
    • morpheuskafka #1
    • m00x #1
    • krackers #1
  6. 06

    Better primers exist for adjacent topics

    Several useful follow-on resources surfaced for the areas the handbook only sketches. Readers pointed newcomers to Designing Data-Intensive Applications for system design, Modern Treasury’s accounting and ledger guides for ledger basics, and market-structure books like Trading and Exchanges and Pricing Money for capital markets context.

    Use the handbook as a map, then assign deeper reading by role. Engineers touching ledgers need accounting material, and engineers moving into trading need market-structure resources, not just payment API patterns.

      Attribution:
    • charlieirish #1
    • cirrhosis #1
    • mhh__ #1 #2

Against the grain

  1. 01

    Doubles are workable in some finance

    The absolutist "never use floats" line drew credible pushback from people working in risk, pricing, and other domains where the outputs are modeled values rather than settled ledger entries. They argued that doubles are widely used, can be perfectly adequate within known precision limits, and are often the practical substrate behind tools people already trust, from Excel to quantitative libraries.

    Separate ledger storage from analytical computation in your design reviews. The right numeric type for settled balances may be wrong for simulations, pricing, or risk models.

      Attribution:
    • fvdessen #1
    • oddthink #1
  2. 02

    Compliance dominates architecture sooner than code

    One hardline view rejected the handbook as a source of truth for production practice because retention, customer identification, anti-money-laundering, and reporting obligations vary by jurisdiction and counterparty. The useful part of that critique is not "never read outside material." It is that regulated workflows can invalidate otherwise sensible engineering patterns if legal retention or traceability requirements say otherwise.

    Before you adopt patterns like data deletion, retention splits, or workflow automation, get the compliance constraints written down in your actual operating jurisdictions. Do not let a clean architecture drift ahead of the legal model.

      Attribution:
    • traceroute66 #1 #2 #3

In plain english

ACH
Automated Clearing House, a US network used for bank-to-bank electronic payments that often settle with delay.
ETL
Extract, transform, load, a process for moving and reshaping data between systems.
FX
Foreign exchange, the trading or conversion of one currency into another.
JSON
JavaScript Object Notation, a common text format for exchanging data between systems.

Reference links

Engineering and systems books

  • Designing Data-Intensive Applications
    A reader compared the handbook’s style and message to this systems-writing resource, and another recommended Kleppmann’s book by name in the same vein.
  • Trading and Exchanges
    Capital markets readers asked for learning resources, and this was cited alongside another classic as a starting point for listed markets and market structure.

Fintech and accounting guides

Protocol and data format references

Author provenance and source history