标签：#fintech

Less than 24 hours left to apply to host a Side Event during TechCrunch Disrupt 2026 and make your mark in the Silicon Valley scene. Apply before the application closes tonight at midnight PT.

The Builders Stage is returning to TechCrunch Disrupt, bringing together founders, startup operators, and investors for practical conversations on what it takes to build and scale.

The email arrives. "Mercury will not be able to support your business at this time. We will not be able to provide additional details about this decision." You spend the next two weeks building an appeal: residence permit, business plan, tax registration, customer contracts, the whole file. You attach a polite cover letter explaining that you are not in Russia, not a sanctioned individual, fully compliant. Mercury either does not respond or sends the same boilerplate back. By week three you have decided you did something wrong, that your business is somehow tainted, that you will never get a US bank account. None of that is true. The reject was a system response, and once you can see the arithmetic driving it, the next move gets obvious and the spiral stops. The math behind an auto-decline OFAC violation penalties start at roughly $1 million per transaction. The annual revenue from a single diaspora-founder account at Mercury sits somewhere between $50 and $500. On top of that sits reputational risk: one Bloomberg story about "the fintech serving sanctioned Russians" damages the next funding round, strains banking partner relationships, and invites regulatory attention. Run those numbers and an auto-decline on an RU or BY passport signal becomes the rational move for the fintech, even when the overwhelming majority of flagged applications are perfectly legal. The downside of a single miss outweighs the upside of correctly clearing every legal applicant. What you are looking at is a company optimising against an asymmetry: maximum downside, minimal upside, per application. There is no judgement of you anywhere in that calculation. How the decline actually happens A KYC submission includes a passport scan, residence permit, and business documents. The decisioning system flags an RU or BY passport regardless of where you live, how the company is structured, or where the revenue comes from. Human review exists, but it triggers only when the signal-to-noise ratio is exce

The disciplinary action comes two months after the Commodity Futures Trading Commission settled charges against Santos.

The controversial founder of the checkout startup once valued at $11 billion is putting in $5 million of his own money.

Are pigs flying? Walmart has finally caved on its refusal to support Apple Pay and Google Pay.

Ramp has launched its own AI model routing service, dubbed Router, that lets users and companies use and switch between various large language models via an API.

The investment comes amid Navi plans to go public.

Short answer: for a small fintech product that turns reviewer voice notes into structured code findings, start with one synchronous speech-to-text file-upload adapter for MP3 and WAV, but write every upload to a tenant ledger before making the transcription request. That is usually the fastest integration because it keeps the first release small while preserving per-tenant cost visibility and a clean path to regional routing. Choice Shipping effort Tenant attribution Best fit Main constraint Direct file upload Lowest Clear with an internal ledger Short reviewer notes Bound by the selected API's request and duration limits Object storage plus async worker Medium Clear with job records Long or bursty recordings More states to operate Self-hosted transcription Highest Fully internal Strict control requirements or sustained workloads Model serving becomes your job My recommendation is the first row for the initial release. Keep the adapter replaceable, measure billed units rather than guessing from file size, and promote work to a queue only after real upload patterns justify it. The point isn't to find a universally fastest model. It is to ship weekly without losing the tenant-level evidence needed to understand margin. How should a simple speech-to-text API handle MP3 and WAV file uploads? Treat the upload as a business event, not as an anonymous call to an AI endpoint. Before sending any audio, create an internal record with tenantId , changeId , uploadId , media type, byte count, selected processing region, and a start timestamp. After transcription, add the external request identifier when one exists, the terminal status, and the billable unit reported by the selected service. A byte count is useful for capacity planning; it is not a substitute for actual billing data. That distinction matters in a multi-tenant SaaS. One tenant may submit many short WAV notes, while another submits compressed MP3 files with longer conversations. Charging, margin analysis, and abuse

PayPal is still reportedly negotiating a potential sale to Stripe and private equity firm Advent, as the fintech firm's new CEO attempts to turn the company around.

I'm building a small tool that converts bank CSV files into .qbo files for QuickBooks ( qbofile.com ). When a generated file is wrong, QuickBooks rejects it with vague errors and the OFX spec doesn't tell you what QuickBooks actually checks. So I ran some experiments. Notes below, in case someone else hits the same wall. The file is not XML .qbo is Intuit's version of OFX 1.0.2, which is SGML. Leaf tags have no closing tag: <TRNAMT> -42.50 <FITID> 8f3a2b... Only aggregate tags close. The file also needs a 9-line key:value header, then one blank line, then the body. Line endings are CRLF. My first bug was closing every tag like XML. "Missing bid data" means one tag: INTU.BID QuickBooks checks <INTU.BID> against an internal list of banks that pay Intuit for Web Connect. I tested three variants on QuickBooks Desktop for Mac 2024: Variant Result No <FI> block, no <INTU.BID> Rejected: "Missing bid data" Only <INTU.BID> Accepted <FI> block + <INTU.BID> Accepted So the whole <FI> block (bank name, org id) can be dropped, but INTU.BID cannot. I have only tested the Mac version. If you know whether Windows versions behave the same, I'd like to hear. FITID decides duplicates QuickBooks dedupes on FITID, not on date + amount. If a converter generates random FITIDs, re-importing an overlapping date range creates duplicate transactions. I hash account + date + amount + description, so the same transaction always gets the same FITID. Credit card statement cycles never match calendar months, so overlapping imports happen more often than I expected. QuickBooks cannot export .qbo This one surprised me. No version of QuickBooks can produce a .qbo file. The format only goes one direction, from bank to QuickBooks. Every .qbo file in the world came from a bank's download button or from a converter. That's what I have so far. The tool is free for single files and runs fully in the browser, nothing gets uploaded. I have only tested against QuickBooks Desktop — if you use QuickBooks Online

A payment decision has to be exact and repeatable. So in the product I built, the money logic is deterministic code, and the agent only touches the parts where judgement is genuinely open-ended. Every AI demo right now is an agent doing everything. Point it at the problem, let it reason end to end, marvel at the trace. It demos beautifully. Then you try to put it in front of a real workflow with real money and it falls apart, because the thing that makes a demo impressive, the model deciding freely, is exactly the thing you cannot allow when the output is a payment. I spent a while building a procure-to-pay product: a vendor invoice comes in, gets extracted, matched against a purchase order, routed through an approval workflow, and reconciled. It is the kind of thing everyone now wants to put an agent on. So I did, sort of. But the interesting decision, the one that took the longest to get right, was not where to add the agent. It was where to refuse to. The rule: a payment decision must be exact and repeatable A model is a probability distribution. Ask it the same question twice and you can get two answers. That is a feature when the task is fuzzy and a liability when the task is "does this $48,200 invoice match this purchase order". Matching, the approval engine, reconciliation: these have to be exact, auditable, and identical every run. So they are plain deterministic code. No model in the path. If a controller asks why this got approved, the answer is a code path they can read, not "the model felt it was fine". That sounds obvious written down. It is not how most people are building AI features right now. The default has become: agent first, and carve out the deterministic parts only when something breaks. I did the opposite. Deterministic by default, agent only where the trajectory is genuinely open-ended. The three places the agent actually earns its keep Once you hold that line, the places where AI belongs get very clear, because they are exactly the places a

In ledgerloop, a clean invoice under $1,000 posts with no human involved. I built the approval gate, then put a price on it. A company raised $30M last week to take the human out of agent payments. The expected take from someone with my background is a post defending the human. I agree with them, up to a thousand dollars. Two conditions, and nothing else The manager gate fires on two conditions: any exception, or a clean bill over $1,000. Below that, a clean three-way match posts straight through and no one signs. From the seeded scenarios: $730 clean goes straight through. $9,360 clean still stops, because a material bill gets a human whatever the match says. A steel bar invoiced 9% over the PO stops. Invoiced 100 units, received 80, stops. Two things exactly, and they are the load-bearing ones. Below the floor, what posts the invoice is deterministic tested code, not the model: the agent reads, investigates and proposes, it does not decide an amount. And these are seeded demo scenarios, not production traffic. The argument I actually want It is not whether humans should approve payments. It is that "a human approves payments" stops being a control the moment no one wrote down which payments. An unwritten threshold is not a policy, it is a habit, and a habit cannot be audited. The number itself is arguable and probably wrong for your business. Its existence, in code, with a reason next to it, is not. If you run AP: what is your straight-through limit, and who set it? The whole loop, an agent deriving the workflow then a real invoice routed through it, is in the ledgerloop case study . Originally published at dylan.merigaud.com .

Enterprise fintech deals don't die in the demo. They die in week six of onboarding, while someone re-types the customer's approval rules into a canvas. I spent two years inside a procurement fintech and the pattern was consistent: the product demos great, the contract gets signed, and then comes the wall. Setup that drags for weeks. Change requests every single week. Users who don't fully understand what was configured for them, so they ask instead of doing. The three things that cut onboarding time by 90% Integrating end to end with the systems the client already runs. The ERP connection wasn't a checkbox: granular sync per data type, bulk imports, master data flowing both ways. Every field the client doesn't re-enter is a support ticket that never exists. Generating a v1 of their approval workflow instead of handing them a blank canvas : business rules and best practices, applied to the real people pulled from their HRIS. The client reviews and adjusts a draft. Nobody designs from zero. Giving clients simple tools to help themselves , including a chatbot, so "how do I change this?" stopped requiring us. None of it was glamorous. All of it was product engineering aimed at time-to-first-value. A CTO building in this space told me recently that time-to-first-value, not features, is what decides procurement deals. That matches everything I saw from the inside. The workflow was never missing Watch an enterprise onboarding for any workflow product and you'll see the same ritual: a kickoff call, a shared screen, and someone rebuilding the org's approval logic box by box. Who approves above $10k. Who signs off on IT purchases. What happens when the manager is on leave. None of that information is new. It sits in the HRIS (who reports to whom, titles, departments) and in the ERP (vendors, open POs, spend history). The customer is being asked to re-enter reality the software could have read. What the next iteration looks like ledgerloop is that idea taken further. An agent

In the demo, it's three boxes: request, manager, CFO. Everyone nods. Then production shows up with questions the canvas never asked. The questions the canvas never asked The approver left the company last month, and the workflow still points at them. The amount lands exactly on the threshold. Above 10k goes to finance. Is 10k above 10k? The request was approved, then someone edited one line. Does the whole chain re-run, or just the delta? Who decides that? The manager is on leave and delegated their approvals. Does the delegate's own delegation count? Until when? Approval by group: any of the five? All of them? Three out of five? In what order? A condition depends on an answer given two steps earlier. That answer just changed. I spent two years shipping and maintaining an approval workflow engine at a procurement fintech. The three boxes took a sprint. The list above took the rest. How we actually answered it We froze the workflow at init: conditions resolved once at launch, and a running request never re-derived them. Mid-flight edits simply didn't exist. Approval groups came straight from the teams in the HRIS. Vacations earned a proper feature, a replacement approver that applied even to workflows already running, because absence is the one thing you can't freeze. And the approver who had left the company? Fixed by hand, more often than I'd like to admit. Freezing at init isn't a hack. It's the honest trade-off: deterministic, auditable, and it quietly declines half the list above. A workflow builder is a programming language your users never asked to learn Every condition is syntax, every unhandled edge case is a bug they'll file. So my opinion hasn't moved: keep the engine boring, deterministic, tested code, and derive the configuration from the systems that already know the answer, editable in plain language. That is what ledgerloop does with the HRIS, and what the components in approvals-ui model directly: quorum gates, amount thresholds, and a policy lint th

The rise of instant payment networks has changed the way money moves. Transactions that once took hours—or even days—now settle in seconds. Whether it's FedNow, RTP, UPI, or other real-time payment systems, users expect payments to be fast, available 24/7, and completed almost instantly. For developers and fintech teams, however, speed creates a new challenge. When payments settle in real time, there's little opportunity to detect fraud, reverse errors, or manually review suspicious transactions. That makes instant payments risk management one of the most important aspects of building modern payment applications. Real-time payment systems leave only seconds to make fraud, compliance, and operational decisions before settlement becomes final. Why Instant Payments Change Everything Traditional payment systems often include a processing window where transactions can be reviewed before settlement. Instant payments remove that safety net. Once a payment is authorized and processed, the funds are typically transferred immediately. If a fraudulent transaction slips through, recovering the money becomes significantly more difficult. That's why payment platforms must shift from reactive fraud detection to proactive risk prevention. What Is Instant Payments Risk Management? Instant payments risk management is the combination of technologies, policies, and automated decision-making that helps businesses detect and reduce risks before an instant payment is completed. Instead of reviewing transactions after settlement, modern payment systems analyze risk while the payment is being processed. Typical risk management includes: Real-time fraud detection Identity verification Device and behavioral analysis Transaction monitoring Sanctions and compliance screening Velocity and limit controls Continuous risk scoring Every one of these checks must happen within milliseconds without creating noticeable delays for legitimate users. Why Traditional Fraud Rules Are No Longer Enough Older p

Here is how I hardened the browser runtime for a Zero-Knowledge, Non-Custodial FinTech trading terminal. 👇 Client-Side Envelope Encryption: I derive a KEK from the user's password using PBKDF2-SHA256 (310,000 iterations). Then, a secure random 32-byte DEK (AES-256-GCM) encrypts the data. The password NEVER touches the server, and the DEK has a strict 15-min TTL in RAM before a wipe. Secure Enclave Anti-Export Guard: CryptoKeys are generated via crypto.subtle with {extractable: false} . To prevent injected malicious scripts from bypassing the sandbox, I implemented an isolated closure that overrides (monkey-patches) the native browser API: crypto.subtle.exportKey = async function(format, key) { if (isProtectedKey(key)) { _AuditChain.append('EXPORT_ATTEMPT', 'CRITICAL'); throw new Error('Export BLOCKED — unauthorized'); } return _origExport(format, key); }; If our database is breached, hackers find ZERO financial data. If the local session is compromised, runtime gating blocks extraction. Plus, client-side validation rejects API keys with withdrawal permissions enabled (zero custodial risk under MiCA, built for GDPR). The entire architecture runs client-side (WebSocket throttled at 100ms + local AI Advisor), keeping server costs near zero. Where does this runtime isolation logic fail? Why do major SaaS platforms still rely on standard local storage? Let's discuss. 💬

On July 27, 2026, the Caribbean Development Bank announced that it had approved a US$100,000 grant to the CARICOM Private Sector Organization to support the first phase of a study examining the feasibility and possible design of a regional stock exchange for participating states of the CARICOM Single Market and Economy. Together, the Caribbean Development Bank and the Inter-American Development Bank are contributing US$324,700 towards Phase I. [1] The proposed study will examine market demand, legal and regulatory requirements, international exchange models and the needs of public- and private-sector stakeholders. It will also consider how regional capital markets could become more connected, improve liquidity, lower financing costs and expand access to capital for Caribbean businesses. [1] These are important economic goals. However, achieving them would depend heavily on the technology supporting the exchange. More Than a Trading Website When people hear the term “stock exchange”, many may picture a website displaying company names, share prices and complex charts. This mental image is, by no means, incorrect, but it admittable fails to grasp the complex financial infrastructure that must be put in place to support a proper exchange. Behind the website with the complex charts, lies systems which process orders, match buyers to sellers, record and broadcasts trades, protect investor information and maintain an accurate history of every market. The birth of a regional exchange would require a great deal of thought, since it would need to operate across multiple Caribbean jurisdictions. Investors in Guyana, Jamaica, Barbados, Trinidad and Tobago and other participating states should be able to interact with the same market without the barrier of geography. This would require several closely connected systems, including: A high-performance order-matching engine Secure investor and broker portals Real-time market-data services Trade clearing and settlement infrastructu

The legislation lays the groundwork for a potential overhaul of India's zero-merchant-discount-rate regime, under which businesses have not paid fees to accept UPI payments since 2020.

The lost-update bug that quietly corrupts homegrown wallet balances — and the five disciplines we used across PayWithToken to make money movement correct under concurrency. There is a bug that lives in a large share of the world's homegrown wallet systems. It doesn't throw an error. It doesn't show up in tests. It surfaces months later as a balance that is quietly, inexplicably wrong — and in a payments system, a wrong balance is either a customer who has lost money or a company that has given it away. This is the story of that bug, why the "obvious" wallet code causes it, and the handful of disciplines we used across PayWithToken to make money movement correct under concurrency. The bug: lost updates Here is wallet code almost everyone writes first. Credit a user's balance: // DON'T do this $row = $db->query("SELECT balance FROM users WHERE id = $id")->fetch(); $new = $row['balance'] + $amount; $db->exec("UPDATE users SET balance = $new WHERE id = $id"); Read the balance, add to it in PHP, write it back. It works perfectly — until two things happen at the same time. Picture a wallet at ₦1,000. Two credits of ₦500 arrive simultaneously — say a bank webhook and the user tapping "confirm" on their phone: Request A reads balance = 1000. Request B reads balance = 1000 (A hasn't written yet). A computes 1500, writes 1500. B computes 1500, writes 1500. Two credits landed; the balance rose by ₦500. ₦500 vanished. This is a lost update, and it is a race condition, which means it is invisible until you have real concurrent traffic — exactly when you can least afford it. The debit version of the same bug lets a balance go negative or double-spends a token. Fix #1: let the database do the arithmetic The read-modify-write happened in PHP, across three round trips, with a gap where another request could interleave. The fix is to make the update a single atomic statement and let the database's row lock serialise it: // DO this — one atomic statement $db->prepare("UPDATE users SET