Archive
1290 posts · Page 55 of 108. ← Blog
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.
Machine learning runs on data, and the most valuable data is often the most sensitive: medical records, financial transactions, personal messages, location histories. This creates a fundamental tension — the models that could help most need exactly the data we're least willing to expose. Privacy-preserving machine learning is the set of techniques that resolve this dilemma, letting us learn from sensitive data without surrendering it. This series builds those techniques from first principles, starting with why the problem is real and harder than it looks.
ML wants more, centralized, detailed data; privacy wants less, distributed, minimized — and the highest-value ML sits where that tension is sharpest. Why the naive protections fail (anonymization → re-identification; securing data ≠ securing the model), and the four techniques that make privacy an engineered, provable property.
Almost everything interesting in JavaScript is asynchronous — network calls, file reads, timers — and TypeScript types all of it through one generic: `Promise<T>`. But typing async code well means understanding the runtime it describes: the single-threaded event loop that makes non-blocking concurrency work. Types and runtime together are what let you write async code that's both correct and comprehensible.
Almost everything interesting in JavaScript is asynchronous, and TypeScript types all of it through one generic: Promise<T>. But typing async code well means understanding the runtime it describes — the single-threaded event loop that makes non-blocking concurrency work. Types and runtime together let you write async code that's correct and comprehensible.
Being right is not enough to change anything. Every engineer has watched a worse idea win because its advocate was more persuasive, more trusted, or simply better at bringing people along — and concluded, wrongly, that this is unfair politics they want no part of. But influence isn't manipulation; it's the skill of helping good ideas actually happen through other people. In any organization, your impact is bounded not by the quality of your ideas but by your ability to get others to understand, trust, and act on them.
Being right is not enough to change anything. Every engineer has watched a worse idea win because its advocate was more persuasive or trusted. But influence isn't manipulation — it's the skill of helping good ideas actually happen through other people, and your impact is bounded by it.
Treating the prompt as a real engineering artifact — grounded in how a next-token predictor actually works — with roles, specificity, few-shot examples, decomposition, chain-of-thought, grounding, temperature, injection defense, and versioned Go templates you can test.
Prompt engineering as a real engineering discipline: roles, specificity, few-shot, decomposition, chain-of-thought and its cost, grounding, and prompt injection — plus building prompts as versioned, testable Go text/template templates you treat like code.
How to build next-best-action and product recommendations for financial services without crossing privacy or fair-lending lines.
Building next-best-action and recommendations for financial products: signals and feature stores, candidate generation + ranking, suitability/eligibility constraints, and cold-start — without crossing privacy or fair-len…
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 three cryptographically signed mandates turn an agent's purchase into a non-repudiable audit trail.
Google's open Agent Payments Protocol (AP2).
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.