Articles about Financial Systems — exploring patterns, best practices, and real-world implementations in production systems.
122 posts tagged with financial systems. ← All posts
How a single issuer event fans out into thousands of entitlements, why deadlines are terminal, and what the calculation engine actually has to get right.
The announcement to ex-date to record-date to payment lifecycle for mandatory and voluntary corporate actions, and the entitlement/election engine behind it.
How to model the card payment as a two-phase auth-then-capture flow plus a clearing tail — handling incremental auths, partial captures, reversals, expiry, and the auth-vs-settled reconciliation that trips up every ledger.
Teaches how to model the card transaction as a two-phase (auth then capture) plus clearing/settlement state machine, handling partial captures, incremental auths, auth expiry/reversal, and the auth-vs-settled amount reconciliation.
Wiring the 3DS Server, Directory Server, and issuer ACS into a handshake that produces a cryptogram your authorization message can carry.
Teaches how to integrate 3-D Secure 2: the 3DS Server, Directory Server and issuer ACS handshake, frictionless vs challenge decisioning, device data collection, and liability-shift outcomes feeding the authorization.
How a token vault and scheme-issued network tokens push the raw PAN out of your application systems, so most of your services fall out of PCI-DSS scope entirely.
Teaches how a token vault and network tokens (TR-31/EMV payment tokens) remove PAN from application systems, cutting PCI-DSS scope, and how token provisioning, cryptograms, and detokenization boundaries are architected.
How a buy-side smart order router turns one parent order into dozens of child orders, scores venues in real time, and then proves it did the right thing.
How a buy-side SOR splits a parent order across venues, scores liquidity/fees/latency, and proves best execution with TCA.
How to engineer SEPA SCT and SDD flows: mandate lifecycle storage, pre-notification timing, FIRST/RCUR sequence types, and the R-transaction taxonomy modeled as an explicit state machine.
Teaches how to engineer SEPA SCT and SDD flows: mandate lifecycle storage, pre-notification timing, FIRST/RCUR sequence types, and the R-transaction taxonomy (reject/return/refund/reversal/revocation) as a state machine.
How to parse legacy MT103/MT202 fields, map them to MX pacs equivalents during coexistence, and thread a gpi UETR end-to-end so a cross-border payment stays trackable across correspondent hops.
Teaches how to parse legacy MT103/MT202 fields, map them to MX pacs equivalents during coexistence, and thread a gpi UETR end-to-end so a cross-border payment is trackable across correspondent hops.
How to engineer for 24x7 irrevocable instant credit — synchronous ISO 20022 messaging, request-for-payment flows, and idempotent liquidity checks with no batch cutoff.
Teaches how to build for 24x7 irrevocable instant credit: synchronous ISO 20022 request/response, request-for-payment (RfP) flows, credit-transfer timeouts, and idempotent liquidity checks at the rail with no batch cutoff.
The 40-year-old tag=value protocol still carrying most of the world's equity orders — and how to build an engine that survives a dropped connection.
How FIX session layer (logon, heartbeat, sequence-number gap-fill, resend) and application layer (NewOrderSingle, ExecutionReport) actually work, and how to build a resilient FIX engine.
How AI agents that discover, choose, and pay on your behalf break the assumptions baked into every checkout, and the protocol stack rushing in to fix them.
What agentic commerce is: AI agents that discover, select, and pay on a user's behalf.
How to treat pain, pacs, and camt as one typed, schema-driven domain instead of a pile of XML you concatenate by hand.
Teaches how to model, validate, and generate ISO 20022 XML payment messages (pain.001 initiation, pacs.008 interbank, camt.053 statements) with schema-driven typing, structured references, and idempotent message identifiers.
A field-by-field guide to decoding bitmaps, data elements, and MTI so a raw TCP frame becomes a typed auth request you can trust.
Teaches how to build a byte-level ISO 8583 encoder/decoder: primary/secondary bitmaps, data-element (DE) field definitions, MTI parsing, and stan/RRN correlation for card authorization messaging.
Model the fixed-width record hierarchy, warehouse entries until their effective date, and turn R-series returns into automated re-presentment.
Teaches how to build a NACHA file processor: fixed-width file/batch/entry/addenda record hierarchy, hash totals, effective-entry-date windows, and handling R-series return/NOC codes with automated re-presentment logic.
The last mile of a financial system isn't code — it's who can do what, who approves it, and how you prove the whole thing is correct.
The last mile isn't code — it's who can do what, who approves it, and how you prove it's correct. Segregation of duties, four-eyes, an auditable change trail, and property tests that assert ledger invariants over thousands of scenarios.
Two systems will drift. The transactional outbox stops you losing events; reconciliation is how you find the truth when they disagree anyway.
You can't atomically update your database and publish a message. The transactional outbox (or CDC) stops you losing events; reconciliation is how you find and classify the breaks when two systems drift anyway.
Talking to a payment rail is the least reliable part of your system. Treat every outbound call as fallible and every inbound webhook as hostile.
Talking to a payment rail is the least reliable part of your system. Treat every outbound call as fallible and reconcile on ambiguity; treat every inbound webhook as hostile — verify, dedupe, ack fast, and go read the truth.
The network will time out mid-transfer. The only safe assumption is that every request runs zero, one, or many times — so make "many" behave like "one."
The network times out ambiguously, so every request runs zero, one, or many times. Idempotency keys make many behave like one; full resumability lets a crashed money flow resume from its last committed step.
A transfer is a state machine with money on the line. Model the states explicitly, reserve funds before you commit, and decide up front what an overdraft even means.
A transfer is a state machine with money on the line. Model the states explicitly, reserve funds before you commit, enforce invariants at every transition, and decide up front what an overdraft even means.
In finance you never update and never delete — you only append. Event sourcing gives you a perfect audit trail; the right to be forgotten is where it fights back.
In finance you append, never update or delete. Event sourcing gives a perfect audit trail; the right to be forgotten is where it fights back — and crypto-shredding is how you reconcile the two.
Every movement of money touches at least two accounts, and the entries always sum to zero. That one invariant is the backbone of a correct financial system.
Every transaction is balanced postings that sum to zero — enforce it at write time. The ledger is append-only, and booking, value, and settlement time are three different clocks you must not conflate.
The first decision in any financial system, and the one people get wrong most often: never store money in a floating-point number.
Never store money in a float. Use integer minor units or fixed-scale decimals, round half-even, allocate so splits sum exactly, and treat currency and the FX rate you used as first-class, auditable data.
How the two Basel liquidity ratios are computed from raw positions, and why the hard part is a data pipeline, not a formula.
How the Liquidity Coverage Ratio and Net Stable Funding Ratio are computed: HQLA classification, outflow factors, and the reporting pipeline.
How a trade turns into a regulator-ready report — eligibility, enrichment, validation, submission, and the break management loop that keeps you compliant.
The trade/transaction reporting pipeline: eligibility, enrichment (LEI/UPI/UTI), validation, submission to the ARM/TR, and break management.
How passive device and behavior signals become a trust score for auth and fraud — without turning into a surveillance liability.
How device signals and behavioral biometrics build a trust signal for auth and fraud, with privacy and false-positive trade-offs.
Turning geography, product, channel, and behavior into a single defensible number — and a due-diligence tier a regulator can follow.
Building a customer risk-rating model: risk factors, weighting, thresholds to due-diligence tiers, and explainability for regulators.
Retiring the calendar-driven refresh and rebuilding customer due diligence as an event-driven state machine with regulator-grade audit evidence.
Moving from periodic review to event-driven pKYC: trigger events, risk re-scoring, refresh workflows, and audit evidence.
Why per-transaction scoring misses organized fraud, and how modeling accounts, devices, cards, addresses, and IPs as a graph catches the whole ring.
Modeling accounts/devices/payments as a graph, connected-component and community detection, shared-attribute linking, and analyst review.
Treating fraud, credit, and risk models as governed assets with a lifecycle, an inventory, and an audit trail regulators can actually read.
Development, independent validation, approval, monitoring, and retirement of risk/fraud/credit models under SR 11-7-style governance.
Modeling borrower hardship as an explicit state machine, so relief, delinquency, and accounting never disagree.
Modeling hardship: payment holidays, term extensions, re-aging, and how restructuring interacts with delinquency and accounting.
Lay out a two-tier retail CBDC — central-bank ledger, intermediaries, retail wallets, and the offline mode that makes engineers nervous.
Lay out a two-tier retail CBDC: central-bank ledger, intermediaries, retail wallets, and offline modes.
Instrument auth rate, settlement lag, and decline-reason breakdowns instead of raw uptime.
Instrument the payment SLOs that actually matter: auth rate, settlement lag, and decline-reason breakdowns.
Protect PINs with DUKPT key-per-transaction derivation and point-to-point encryption all the way to the HSM.
Protect PINs with DUKPT key-per-transaction derivation and point-to-point encryption to the HSM.
How a single loan payment is split across fees, interest, and principal — and why the engine that does it has to be deterministic, auditable, and safe to run twice.
How a loan payment is split across fees, penalties, accrued interest, and principal, with configurable waterfalls and partial-payment rules.
Design MPC / threshold-signature custody so no single party or HSM holds a whole key.
Design MPC / threshold-signature custody so no single party or HSM holds a whole key.
Solving the sending-side reliability problem — nonce sequencing, fee estimation, and replacing a transaction that gets stuck in the mempool.
Solve the sending-side reliability problem: nonce sequencing and gas/fee estimation, including stuck-transaction replacement.
Cluster and risk-score blockchain addresses for on-chain AML and sanctions exposure.
Cluster and risk-score blockchain addresses for on-chain AML and sanctions exposure.
How a custodial exchange hands every user a unique deposit address from a single seed, then safely consolidates the funds into treasury.
BIP-32/44 hierarchical-deterministic address derivation, per-user deposit addresses, detection/confirmation, and sweeping to cold storage.
Settle securities delivery-versus-payment on T+2 through a central securities depository — the securities analog to FX PvP.
Settle securities delivery-versus-payment on T+2 through a central securities depository — the securities analog to FX PvP.
Book and revalue FX forward contracts and swaps for hedging — the part of treasury that lives well beyond spot conversion.
Book and revalue FX forward contracts and swaps for hedging, beyond spot conversion.
Project liquidity positions from known and predicted flows to drive funding decisions.
Project liquidity positions from known and predicted flows to drive funding decisions.
How a custodian proves it holds what it owes, what the cryptography actually guarantees, and where the guarantee stops.
How a custodian proves it holds customer assets: Merkle tree of liabilities, on-chain reserve attestation, and the limits of PoR.
Modeling limit/market/stop and GTC/IOC/FOK semantics as a lifecycle instead of a pile of flags.
Model order-type and time-in-force semantics (limit/market/stop; GTC/IOC/FOK) as a lifecycle.
Handle a live market-data feed the way an engineer must: sequence checking, gap recovery, and snapshot-plus-delta order-book reconstruction.
Handle a market-data feed: sequence checking, gap recovery, and snapshot-plus-delta order-book reconstruction.
Enforce pre-trade risk limits and keep real-time positions and mark-to-market P&L without stalling the order path.
Enforce pre-trade risk limits and keep real-time positions and mark-to-market P&L.
Turning raw blocks and logs into queryable app state that survives reorgs, backfills, and finality.
Building an indexer: block ingestion, log decoding, reorg-safe writes, backfills, and serving queryable balances/history to the app.
Deciding low-value, TRA, and trusted-beneficiary exemptions so low-risk payments stay frictionless while genuine risk gets challenged via 3DS.
Decide PSD2 SCA exemptions (low-value, TRA, allowlist) to keep low-risk payments frictionless around 3DS.
Turn ICT asset and third-party risk, incident classification, and reporting into a system you can actually run — with a resilience-testing loop that keeps it honest.
Engineer DORA operational resilience: ICT asset/third-party risk, incident classification, reporting, and resilience testing.
Classify account tax residency and generate withholding and FATCA/CRS reporting files.
Classify account tax residency and generate withholding and FATCA/CRS reporting files.
How a rating engine turns raw usage and transactions into charges — and why the hard part is making that transformation deterministic, replayable, and idempotent.
How a rating engine turns usage/transactions into charges via pricing plans, tiers, and promos, then produces invoices and fee postings.
Modeling post-delinquency treatment paths — reminders, restructuring, settlement offers, and the charge-off handoff — as a state machine you can reason about.
Model post-delinquency treatment paths: reminders, restructuring, settlement offers, and charge-off/agency handoff.
A document and liveness pipeline that emits a graded pass, refer, or fail instead of a coin-flip yes/no.
Build a document + liveness/biometric identity-verification pipeline that returns a graded decision.
Turn AML alerts into investigated cases and filed SAR/STR reports, complementing rule-based monitoring.
Turn AML alerts into investigated cases and filed SAR/STR reports, complementing rule-based monitoring.
Why tax lots, not positions, are the real unit of a brokerage ledger — and how to make disposal deterministic.
Tracking tax lots across buys/sells for securities and crypto, FIFO/LIFO/specific-identification, wash sales, and realized/unrealized gain.
Checkout-time soft credit checks, upfront merchant settlement, and the installment collection loop that carries the real risk.
Engineer a 4-installment BNPL flow: checkout-time soft credit check, upfront merchant settlement, and installment collection.
Design a loan origination pipeline from application through underwriting, offer, and disbursal.
Design a loan origination pipeline from application through underwriting, offer, and disbursal.
Track collateral valuation, loan-to-value, margin calls, and liquidation triggers as one auditable state machine.
Track collateral valuation, loan-to-value, margin calls, and liquidation triggers.
Why fintechs keep a transaction-grain subledger separate from the accounting general ledger, and how the posting, aggregation, and tie-out actually work.
Why fintechs keep a high-volume subledger separate from the GL, posting rules, summarization/aggregation, and period-close handoff.
Model variable recurring payments and metered/subscription billing with proration, treating the mandate — not the retry loop — as the object that actually has state.
Model variable recurring payments and metered/subscription billing with proration, distinct from retry logic.
From BIN and program configuration through card production, HSM-backed PIN generation, and the real-time authorization controls engine.
Build the issuer side: BIN/program config, card production, PIN generation via HSM, and real-time authorization controls.
One reference model of every party in a card transaction — cardholder, merchant, gateway, acquirer/processor, scheme, and issuer — and the settlement path that moves the real money back the other way.
One reference map of who does what in a card payment: cardholder, merchant, gateway, acquirer/processor, scheme, issuer, and the settlement return path.
How a captured card transaction turns into money in a merchant's bank account — batching, gross-to-net fees, reserves, adjustments, and the T+N funding file.
From captured transactions to merchant bank account: batching, interchange/scheme-fee deduction, reserves/holdbacks, and T+N funding files.
Route a payment across multiple providers to maximize auth rate, with health-aware routing, failover, and normalized webhooks.
Route a payment across multiple PSPs to maximize auth rate, with health-aware routing, failover, and normalized webhooks.
Name-match the beneficiary before a push payment to stop authorized-push-payment (APP) fraud.
Name-match the beneficiary before a push payment to stop authorized-push-payment (APP) fraud.
Encode and decode EMVCo QR payloads (static vs dynamic), handle expiry, and reconcile QR-initiated payments.
Encode and decode EMVCo QR payloads (static vs dynamic), handle expiry, and reconcile QR-initiated payments.
How a foreign cardholder is offered payment in their home currency, who earns the FX margin, and how the choice threads through authorization and clearing.
How DCC offers a cardholder their home currency at point of sale, the FX markup and disclosure rules, and settlement implications.
Building a matching engine across the internal ledger, the processor report, and the bank statement — with tolerances, break classification, aging, and auto-resolution rules for the items nobody wants to touch.
Teaches how to build a three-way reconciliation engine (internal ledger vs processor vs bank statement): matching keys and tolerances, break classification, aging, and auto-resolution rules for the long tail.
How split knowledge, dual control, and a layered key hierarchy keep a working key from ever appearing in the clear.
Teaches how to run cryptographic key management for payments: HSM-backed key hierarchies (LMK/ZMK/ZPK), key ceremonies with split knowledge and dual control, rotation, and PIN-block translation.
Securing bank-to-bank and scheme connectivity with mutual TLS, detached JWS signatures for non-repudiation, and replay protection built from nonces and timestamps.
Teaches how to secure bank-to-bank and scheme connectivity: mutual TLS with certificate pinning/rotation, detached JWS/XML message signing for non-repudiation, and replay protection with nonces and timestamps.
How R2P flips the pull model into a request-and-approve flow, and the engineering behind mandates, consent, and reconciliation.
How Request to Pay (R2P) messaging works, the standing-mandate lifecycle, consent, and variable recurring payment authorization.
How to coordinate a multi-step payment as an orchestrated saga: compensating actions for partial failures, idempotent steps, and a guarantee that money is never left stranded.
Teaches how to coordinate a multi-step payment across services without distributed transactions: orchestrated saga steps, compensating actions for partial failures, and guaranteeing money is never stranded.
How to safely credit on-chain deposits and finalize settlement: confirmation-depth thresholds, mempool tracking, chain-reorg detection with balance rollback, and idempotent handling of replaced transactions.
Teaches how to safely credit crypto deposits and finalize settlement: confirmation-depth thresholds, mempool/pending tracking, chain-reorg detection and balance rollback, and idempotent handling of replaced transactions.
How to engineer a fiat-backed stablecoin: mint-on-deposit and burn-on-redeem flows tied to a reserve ledger, a 1:1 reserve invariant, and continuous reconciliation between on-chain supply and off-chain custody balances.
Teaches how to engineer a fiat-backed stablecoin: mint-on-deposit / burn-on-redeem flows tied to a reserve ledger, 1:1 reserve invariant checks, and reconciliation between on-chain supply and off-chain custody balances.
Designing a closed-loop wallet from the ledger up: double-entry balances, the money lifecycle, safeguarding client funds 1:1, and the engineering that keeps top-ups, holds, and reconciliation honest.
Designing a closed-loop wallet: top-up, hold, spend, refund, safeguarding of e-money, and the double-entry ledger behind a balance.
How to aggregate balances, compute target-vs-actual, and fire cutoff-aware sweeps that keep settlement accounts solvent without stranding idle cash.
Teaches how to engineer treasury liquidity: multi-account balance aggregation, target-balance and zero-balance sweep rules, cutoff-aware transfers, and intraday funding checks to keep settlement accounts solvent.
How price-time priority, a single-threaded sequencer, and gap-free event streaming combine into an exchange core you can replay byte-for-byte.
Teaches how to build a deterministic matching engine: price-time priority order book, limit/market/IOC/FOK order types, single-threaded sequencer for determinism, and gap-free trade/execution event streaming.
How to architect wallet tiers, HD-derived deposit addresses, HSM/MPC signing quorums, and sweep flows so no one key, and no one person, can move funds.
Teaches how to architect custody: hot/warm/cold wallet tiers, HSM or MPC key custody, withdrawal approval quorum, address derivation (HD wallets), and sweep flows from deposit to cold storage.
How Original Credit Transactions move money onto a card in near real time — and why pushing is a different animal from pulling.
How OCT/push-to-card (Visa Direct, Mastercard Send) moves money to a card in near real time, eligibility/limits, and reversal handling.
A clear-eyed look at trust models, who signs what, rails, credential handling, and settlement — and why these four overlap more than they compete.
A clear-eyed comparison across trust model, who signs what, payment rails supported, credential handling, settlement, and best-fit use cases.
How to combine a deterministic rules engine with an ML risk model in a single decision: rule precedence, score bands, shadow mode, and champion/challenger evaluation with feedback labels.
Teaches how to combine a deterministic rules engine with an ML risk model in one decision path: rule-precedence and overrides, model score bands, shadow mode, and champion/challenger evaluation with feedback labels.
How a risk-driven layer escalates from silent approval to OTP, biometric, or 3DS challenge — holding a pending-challenge state and resuming the original transaction once the customer clears it.
Teaches how to build risk-based step-up auth: an orchestration layer that escalates from silent to OTP/biometric/3DS challenge based on risk signals, with pending-challenge state and resumable transaction context.
How to ingest many rate feeds, derive a trustworthy mid, defend against stale prices, and quote a locked customer rate that survives a settlement failure.
Teaches how to build an FX pricing service: ingesting multiple rate feeds, mid-rate derivation, staleness/circuit-breaker handling, per-segment spread/markup, and rate-lock quotes with expiry for customer conversions.
How Visa Account Updater and Mastercard Automatic Billing Updater keep stored credentials alive when cards get reissued, expire, or change numbers.
How VAU/ABU keep stored credentials current, credential-on-file mandates, and reducing involuntary churn from expired/reissued cards.
How to build PSD2-grade open-banking APIs — strong customer authentication and its exemptions, the consent grant and its revocation, and the hard boundary between account-information and payment-initiation scopes.
Teaches how to build open-banking APIs: strong customer authentication and exemptions, consent grant/lifecycle, account-information vs payment-initiation scopes, and TPP authorization with token/consent revocation.
How to turn a book of exposures into risk-weighted assets and a capital ratio with a deterministic, auditable pipeline
Teaches the engineering of a risk-weighted-asset calculator: exposure classification, risk-weight lookup (standardized approach), credit-conversion factors for off-balance items, and capital-ratio aggregation for regulatory reporting.
Building low-latency sliding-window counters, entity-keyed aggregates, and an online feature store that stays consistent with its batch-computed twin.
Teaches how to build low-latency velocity checks: sliding-window counters and aggregates in an online feature store, entity keys (card/device/IP), and consistency between real-time and batch-computed features.
Why "authorize then capture" is a lie, and how to model a hold that grows, shrinks, expires, and reconciles against a moving available balance.
Pre-auth vs estimated vs incremental authorization (hotels, fuel, delivery), partial approvals, and reconciling holds against final capture.
The surface a store must expose when the buyer is an AI agent, not a browser — and why it is the fintech reliability playbook wearing a new hat.
What a store must expose to sell to agents: a machine-readable product feed/catalog, agentic checkout endpoints, acceptance of delegated payment tokens, idempotency keys for retried agent calls, webhooks for async status…
Typology rules, sliding-window aggregation, alert scoring, and case management that feeds STR/SAR filing — treated as a streaming systems problem, not a compliance checkbox.
Teaches how to build AML transaction monitoring: typology rules (structuring, rapid movement, layering), sliding-window aggregation, alert scoring and deduplication, and case management feeding STR/SAR filing.
How to exchange originator and beneficiary data between crypto services before a transfer settles: counterparty discovery, IVMS101 payloads, and pre-transfer verification that gates the on-chain send.
Teaches how to implement the FATF Travel Rule between VASPs: originator/beneficiary PII exchange protocols (IVMS101, TRP/OpenVASP), counterparty VASP discovery, and pre-transfer verification before on-chain send.
Model corporate ownership as a graph, propagate percentages through the chains, handle the cycles that break naive traversal, and surface every natural person who controls more than 25 percent — with the evidence path attached.
Teaches how to compute ultimate beneficial ownership: modeling ownership as a graph, percentage-through-chain calculation, control vs ownership thresholds, and cycle handling to surface >25% beneficial owners.
How a network authorizes on the issuer's behalf when the issuer host is unreachable — and how the books get squared afterward.
How the network authorizes on the issuer's behalf during downtime using stand-in rules and limits, then reconciles advices when the issuer returns.
Model days-past-due transitions, SMA/NPA classification, provisioning triggers, and cure logic as one deterministic engine driven by time and repayment events.
Teaches how to model delinquency as a state machine: days-past-due bucket transitions, SMA/NPA classification rules, provisioning triggers, and cure/roll-forward/roll-back logic driven by repayment events.
How to assemble features from bureau, bank, and alt data, serve a scorecard or model, apply policy cutoffs, and emit adverse-action reason codes with a full audit trail.
Teaches how to build a decisioning engine: feature assembly from bureau/bank/alt data, scorecard vs ML model serving, policy rules and cutoffs, and adverse-action reason-code generation with an audit trail.
How to ingest watchlists, match names across scripts and spellings, and turn a fuzzy score into an auditable clear, alert, or block.
Teaches how to build sanctions/watchlist screening: list ingestion (OFAC/UN/EU), transliteration and fuzzy name matching, scoring thresholds, whitelisting, and rescreening on list deltas to control false positives.
How a chip card proves it is genuine on every single transaction — and why a cloned magstripe never could.
How the chip generates an ARQC, the issuer validates it and returns an ARPC, plus offline data authentication (SDA/DDA/CDA) and terminal risk management.
How an AI agent turns a shopper's intent into a settled purchase, and where ACP and AP2 plug into the same eight-stage skeleton.
A complete walkthrough: product discovery via an AI surface → cart assembly → user approval/mandate → delegated payment token → merchant checkout → authorization → fulfillment → receipts/webhooks.
How decline-code classification, backoff scheduling, retry budgets, and network-token refresh recover subscription revenue without hammering the rails.
Teaches how to build a smart retry/dunning system: decline-code classification (hard vs soft), backoff and retry-window scheduling, retry-budget limits, and network-token refresh to recover subscription revenue.
Computing loan amortization you can reproduce to the cent — annuity math, day-count conventions, the per-installment principal/interest split, and prepayment recomputation.
Teaches how to compute loan amortization deterministically: EMI/annuity vs reducing-balance formulas, day-count conventions, principal/interest split per installment, and prepayment/rescheduling recalculation.
How to compute interest that earns every day, tracks the accrued-but-unbilled balance, survives mid-period rate changes, and posts to the ledger with idempotent replay-safe jobs.
Teaches how to build a daily interest accrual engine: accrual basis and compounding, accrued-but-unbilled tracking, rate changes mid-period, and idempotent daily accrual jobs that post to the ledger.
How a custodian actually safekeeps client assets — account structures, the custody network, settlement instructions, and the books-and-records engine that keeps it all honest.
How a custodian holds assets in omnibus vs segregated accounts, the CSD/sub-custodian network, settlement instructions, and asset-servicing (income, proxy, tax).
Architecting platform balances, commission splits, delayed payouts, and negative-balance recovery without ever losing a cent.
Teaches how to architect marketplace money movement: platform vs connected-account balances, fee/commission splits, delayed payouts, negative-balance handling, and merchant-of-record vs facilitator models.
How to turn contracts into performance obligations, recognition schedules, and ledger journals — and why billing is never the same event as revenue.
Teaches how to build a rev-rec engine: performance obligations, deferred-vs-recognized schedules, ratable recognition over time, and how billing events differ from recognition events in the ledger.
How to build escrow and conditional hold/release — segregated ledger accounts, release conditions and approvals, partial releases, and expiry auto-refund that never strand money.
Teaches how to build escrow and conditional hold/release: segregated escrow ledger accounts, release conditions/approvals, partial releases, and expiry auto-refund with double-entry safety.
Two ways to borrow against securities — a lending fee or a repo rate — and the daily collateral servicing that keeps both alive.
Loan vs repo mechanics, collateral schedules and haircuts, daily mark-to-market and margin, recalls, and rehypothecation risk.
Designing an account hierarchy, dimensions, and posting rules that turn product events into balanced journal entries.
Teaches how to design a chart of accounts and sub-ledger-to-GL posting model: account hierarchy, dimensions/segments, contra accounts, and how product events map to balanced journal entries.
How to keep books in more than one currency — transaction-date versus settlement-date rates, unrealized and realized FX gain/loss, and the period-end revaluation run that keeps the balance sheet honest.
Teaches how to keep books in multiple currencies with a functional/reporting currency: transaction-date vs settlement-date rates, unrealized/realized FX gain-loss postings, and period-end revaluation runs.
Turning ledger cutoff, accruals, trial-balance assembly, and out-of-balance detection into a controlled, repeatable pipeline instead of a month-end fire drill.
Teaches how to automate the financial close: ledger cutoff/freeze, accrual and reversing entries, trial-balance assembly, out-of-balance detection, and soft-close vs hard-close controls.
How a central counterparty turns a web of bilateral trades into a single, mutualized book of risk — and what your clearing systems must do to survive the margin cycle.
Novation to a central counterparty, initial vs variation margin, margin calls, and the default waterfall (margin, default fund, skin-in-the-game).
Two ways to move interbank money, and the engineering tradeoff that decides which one you build: settle every payment gross and pay in liquidity, or net at a window and carry settlement risk.
Teaches the engineering tradeoffs between gross real-time settlement and deferred net settlement: liquidity vs finality, queue/gridlock resolution in RTGS, and settlement-risk windows in DNS.
Reconciling correspondent-bank balances with mirror-account bookkeeping, camt.053 matching, value-date breaks, and unreconciled-item aging.
Teaches how to reconcile correspondent-bank nostro/vostro balances: mirror-account bookkeeping, expected-vs-actual statement (camt.053) matching, value-date breaks, and unreconciled-item aging.
How matched-leg submission, net pay-in scheduling, and conditional simultaneous settlement remove Herstatt risk from cross-currency trades.
Teaches how payment-versus-payment settlement eliminates Herstatt (principal) risk in FX: matched trade submission, pay-in schedules, simultaneous conditional settlement, and pay-out with net funding.
How a fund turns positions, prices, cash, and accruals into one defensible number every day — and the controls that keep it honest.
How a fund's NAV is struck daily: position keeping, pricing/valuation, accruals, expense amortization, and the striking/publishing pipeline with tolerance checks.
How Stripe and OpenAI turned "buy it for me" into an open standard — product feeds, delegated payment tokens, and OAuth consent.
The Agentic Commerce Protocol co-developed by Stripe and OpenAI that powers Instant Checkout in ChatGPT.
Turn card transaction attributes into interchange, scheme, and markup lines that reconcile to the cent.
Teaches how to build a deterministic fee engine that classifies each transaction into an interchange category (regulated debit, rewards, CPS qualification) and computes interchange + scheme + acquirer markup for merchant statements.
How to turn thousands of gross obligations into the fewest net positions per counterparty — with deterministic cutoff snapshots, netting cycles, and net-debit-cap enforcement.
Teaches how to build a netting engine that collapses many gross obligations into minimal net settlement positions per counterparty, handling netting cycles, cutoff snapshots, and net-debit-cap enforcement.
Modeling the full card dispute lifecycle with reason codes, evidence deadlines, representment, arbitration, and provisional-credit ledger entries at every transition.
Teaches how to model the full card dispute lifecycle as a state machine with reason codes, evidence deadlines, representment, pre-arbitration and arbitration, and provisional-credit ledger entries at each transition.
5K+ loans per month. Three credit bureaus. Multiple payment gateways. The thing that has to be right is the ledger. Notes on what invariants the database enforces vs what the application enforces.
Every one of the 26 RBI FREE-AI recommendations, mapped to a specific file in a working multi-agent platform. What's ✅ done, what's 🟡 partial, what's ⚪ honest gap.
UPI, IMPS, NEFT, RTGS — which rail depends on amount, urgency, and success history. A deterministic chooser with a HITL gate for high-value transactions.
PAN check-digit validation, Aadhaar offline KYC, DigiLocker, PEP/sanctions — all in Go code, not in a prompt. The LLM's job is to translate the verdict into something a human can read.
UPI is the most popular payment rail in India. The spec is precise. The implementation guides are not. Notes on the integration details that ate weeks the first time.
Two KYC pathways an Indian fintech has to support. The Master Direction (Video KYC, etc.) and Aadhaar Offline KYC. Different speeds, different evidence requirements, different audit shapes.
All posts on this site are written by Pratik Dhanave, an Agentic AI Architect with 7+ years building production distributed systems, multi-agent AI platforms, and cloud-native infrastructure. About the author → Each article includes working code, architecture diagrams, and references to the specific frameworks and standards discussed. Browse all posts or explore related topics using the tag cloud above.