标签：#Fin

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.

A portfolio can look good on the usual scorecard and still answer the wrong question. One line says return was high. Another says risk-adjusted performance was acceptable. A third says drawdown stayed inside a tolerable range. Then the market turns, the benchmark starts recovering, and the thing I actually care about is different: how efficiently did the portfolio catch up? That is where a new metric can fool its own author. If I build a recovery measure and it moves almost exactly like an existing ratio, I have created a longer name for the same signal. The right acceptance test is geometric: a useful metric should cast a different shadow. This is the rule I used while validating Hyperlogarithmic Benchmark Catch-Up Ratio (HBCR): orthogonality to existing measures is a first-class test, not a chart for the appendix. 1. A new metric has to earn its axis HBCR was built to measure benchmark-relative recovery dynamics. The research page states the motivation plainly: traditional benchmark-relative metrics often fail to capture the true dynamics of investment performance, especially during market recoveries [ A New Metric for Private Equity Risk Adjusted Returns , Calibration of Risk and Correlation in Private Equity ]. That framing matters because the obvious validation path is tempting and weak. You compare the new number with familiar performance measures, find a comforting relationship, and declare victory. But a high correlation with a well-known score can be a warning. If HBCR strongly tracked Sharpe Ratio, it would probably be an expensive synonym for risk-adjusted return. The acceptance test I wanted was sharper. HBCR should have some relationship with performance, because recovery has economic content. It should also avoid collapsing into the same direction as Sharpe Ratio, Beta, Volatility, Alpha, Total Return, or Max Drawdown. Written as a predicate, the test has two sides. Let $\mathcal{T}$ be the set of metrics already on the scorecard, $\rho_{n,m}$ the corr

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

#ai #kyc #compliance #duediligence #api #llm #fintech #rapidapi AI Writes Code. You Still Own the Verdict. ChatGPT can spin up a KYC dashboard in an afternoon. It will generate React components, SQL schemas, and swagger documentation that look production-ready. But ask it whether fintech-example.io is a legitimate payment processor or a sanctions-evasion shell, and it will confidently fabricate ownership records, misread registrar data, or hallucinate a clean bill of health. That is the gap AI cannot close on its own: grounding . Large language models reason over tokens, not truth. A reliable due-diligence or compliance tool must anchor every LLM answer in real, verifiable, timestamped data—WHOIS records, IP geolocation, company registries, email infrastructure, and sanctions lists. This article shows how to use the Portfolio Investigate API to feed your AI agents factual domain dossiers and compliance verdicts, turning a prototype into something a compliance officer can actually trust. The Hallucination Problem in Due Diligence LLMs are autocomplete engines. They predict what words should come next based on training data, not live facts. In a KYC context, that creates three failure modes: Stale knowledge — model weights freeze; a domain can change ownership next week. Fabricated citations — the model may invent registrar names or corporate addresses. Missing signals — an LLM has no built-in access to WHOIS history, IP blocks, or OFAC lists. The fix is not to abandon LLMs. It is to constrain them: give them a structured evidence packet first, then let them summarize, classify, and answer natural-language questions on top of it. That evidence packet is exactly what Portfolio Investigate API returns. What Portfolio Investigate API Delivers Portfolio Investigate API is a one-call domain investigation report. It aggregates five underlying portfolio APIs into a single dossier: WHOIS — registration dates, registrar, name servers, privacy status. IP Geolocation — where the

This is obviously a bubble Jim Rickards, a former adviser to the CIA and Pentagon, warns that the United States is currently facing a tectonic economic crisis driven by an unprecedented bubble in Artificial Intelligence (AI). According to his analysis, this impending crisis has the potential to be more destructive than the dot-com crash, the 2008 financial crisis, and the pandemic-related market crashes combined. He is not alone in his dire outlook; veteran investor Jeremy Grantham has warned, "This is obviously a bubble. The probabilities it doesn't burst are slim to none. And when it does, it could be an economic catastrophe unprecedented in the last 97 years" . Furthermore, former SEC Chairman Gary Gensler has stated that "the next financial crisis will come from AI". Create God and ask him for money The Unprecedented Scale of the AI Bubble The current market relies dangerously on a single sector, with the AI bubble estimated to be 17 times larger than the dot-com bubble of the late 1990s. Many AI companies are burning through cash at an alarming rate. For instance, OpenAI is reportedly losing more than a billion dollars a month; as it is noted in the source, "for every dollar they make, they have to spend at least three". This massive cash burn led a Deutsche Bank analyst to observe, "No startup in history has operated with losses on anything approaching this scale". Despite the astronomical costs and high valuations, OpenAI’s CEO was quoted as previously saying, "I have no idea how we're going to generate revenue". Former Goldman Sachs banker and Bloomberg columnist Matt Levine summarized this extreme speculative mindset, noting, "The business model they believe they need seems to be create God and ask him for money". "Subprime AI" and Toxic Debt Just as the 2008 financial crisis was fueled by toxic subprime mortgages, the AI boom is being fueled by dangerous debt structures used to fund massive data centers. Private equity firms are financing data centers as r

If your script suddenly started printing this: >>> import yfinance as yf >>> df = yf . download ( " NG=F " , period = " 1mo " ) 1 Failed download : [ ' NG=F ' ]: YFPricesMissingError ( ' possibly delisted; no price data found ' ) …you didn't break anything. NG=F (the natural gas futures ticker on Yahoo Finance) periodically stops returning data for everyone, and futures tickers get hit harder than stocks. This post covers why it happens and the three fixes that actually work, ordered from "quick patch" to "never deal with this again." 1. What the error actually means yfinance is not an official API . It's a (great) community library that scrapes Yahoo Finance's internal endpoints — the same ones Yahoo's own website uses. Yahoo doesn't document them, doesn't promise they'll keep working, and changes them whenever it suits their frontend. When Yahoo changes something — an endpoint, a rate limit, a response format — yfinance breaks until its maintainers reverse-engineer the change. Futures symbols like NG=F and GC=F are the most fragile: they've had recurring gaps and failures reported over the years, for example #2620 (missing recent data for NG=F/GC=F) , #2635 (whole missing days in futures history) and the evergreen #865 "Futures only work sometimes" . So: "possibly delisted" almost never means delisted. It means "the scrape came back empty." 2. Fix #1 — the quick patches (works today, breaks tomorrow) Three things fix most transient failures: Upgrade first. The maintainers usually patch Yahoo changes within days: pip install -U yfinance Retry with backoff. Failures are often intermittent rate-limiting, not hard breaks: import time import yfinance as yf def download_with_retry ( ticker , retries = 3 , wait = 5 , ** kwargs ): for attempt in range ( 1 , retries + 1 ): df = yf . download ( ticker , progress = False , ** kwargs ) if not df . empty : return df print ( f " attempt { attempt } came back empty, retrying in { wait } s… " ) time . sleep ( wait * attempt ) rai

Autonomous agents don't just fail loudly—they fail expensively. A single misconfigured retry loop between an agent and an LLM can generate thousands of redundant tool calls and API requests before anyone notices, turning a minor logic bug into a five-figure cloud bill. PolicyAware is built to be the operational safety net that catches this class of failure before it reaches your finance team's dashboard. 1. The Recursive Agent Crisis Every SRE and platform engineer who has run agentic workloads in production has a version of this story. An agent is wired to call an LLM, interpret the response, and take an action—often invoking another tool, which produces output that gets fed straight back into the same LLM. Under normal conditions this loop terminates in a few steps. Under a bad prompt, a malformed tool response, or a subtle logic error, it doesn't. The agent gets stuck reasoning in circles: it calls a tool, receives an ambiguous or malformed result, decides the task is incomplete, and calls the LLM again to "retry." Each retry consumes tokens, each tool call hits a downstream API, and there is no natural circuit breaker unless one has been explicitly engineered. Within minutes, a single stuck session can produce: Thousands of duplicate or contradictory API calls to internal and third-party services. Sustained LLM token consumption that dwarfs normal daily usage. Cascading load on downstream systems that were never designed for machine-speed request volume. By the time monitoring dashboards catch the anomaly—if they catch it at all—the damage is already done: a runaway bill, a rate-limited API partner, or a compromised production database from thousands of unchecked write attempts. Traditional APM tools tell you a service is under load; they don't tell you an autonomous agent is the one generating that load, or why. This is why the recursive agent crisis is fundamentally a governance problem, not just a monitoring problem. Rate limits and cost alerts fire after the

This is the architecture of Shibui Finance , an MCP server that gives Claude direct SQL access to 64 years of US stock market data. About 10,000 symbols, 31 million daily price records, quarterly financials back to 1990, 56 pre-computed technical indicators, and 6.4 million SEC filing records. Free to use. Stack: Python, PostgreSQL, dbt, DuckDB, FastMCP, Caddy. Runs on a single VPS. Data pipeline Three stages: ingest into PostgreSQL, transform with dbt, export to DuckDB. Data APIs / SEC EDGAR / FRED | Python ETL (Polars, ADBC) | PostgreSQL clean_* schemas (~50 raw tables) | dbt (27 models) staging -> integration schema (17 analytical tables) | DuckDB export (daily, ~14 GB file) | FastMCP server (read-only, streamable-http) | Caddy (TLS) -> mcp.shibui.finance Multiple sources feed the pipeline: commercial data APIs for prices, fundamentals, valuations, and estimates. SEC EDGAR for filing metadata and insider transactions (bulk historical + a 5-minute Atom feed for near-real-time). FRED for FX rates to normalize non-USD fundamentals. Public registries for ticker classification. The ETL is a Python CLI organized by data source. Each module has its own fetcher, loader, and CLI. A single all command runs everything in fixed sequence. You can't refresh 10,000 tickers daily without hitting rate limits, so the ETL rotates: each run refreshes the stalest 5% of tickers. Full universe cycles in about 20 runs. Recent prices always refresh on every run. Every table write is a single transaction. DROP + CREATE inside a transaction, rollback on failure. The database never serves partial data, and dbt always sees complete tables even when ingest jobs overlap. The dbt layer 27 models in two tiers. The process layer handles standardization: enriching symbols with security types and exchange mappings, linking SEC amendment filings to their originals, repairing filer date typos. The integration layer produces the 17 tables that Claude actually queries. This is where raw normalized tabl

I run agents for many customers, on my own infrastructure, and I pay for every token they burn. You...

Manually checking what technologies power a website works once or twice. After that it gets slow, repetitive, and impossible to scale. Modern developers skip the manual step and detect tech stacks in code instead. Your program reads a response, pulls out the signals, and tells you what's running. No DevTools, no guesswork. This guide shows how that detection works and how to build it in Go with the open-source tooling ProjectDiscovery maintains. External resources: github.com/projectdiscovery/wappalyzergo projectdiscovery.io If you're new to the concept, start with technology fingerprinting for developers to understand the signals behind detection. What does "programmatic detection" mean? Programmatic detection just means letting software identify technologies instead of a person doing it by hand. Your application does five things: Sends a request Reads the response Extracts signals Matches fingerprints Outputs technologies No browser, no manual inspection. The same pipeline shows up in recon platforms, developer tooling, automation pipelines, and security workflows. Read detecting website technologies using Go first if you want the foundational walkthrough. Why developers prefer automated detection Manual workflows fall apart as systems grow. Scripted detection holds up because it's fast, consistent, and drops straight into a pipeline. Speed: scan hundreds of targets in minutes. Consistency: scripts don't skip clues a tired human would. Automation: pipe results straight into the rest of your tooling. Intelligence: raw HTTP turns into something you can act on. Building a fingerprint engine yourself means reimplementing years of pattern work. A mature library like wappalyzergo saves you those hundreds of hours. How programmatic fingerprinting works Most detectors run the same four-stage pipeline. Step 1: Fetch the target Send an HTTP request and keep the headers and body. Step 2: Extract signals Look for the clues a stack leaves behind: response headers, cookies, scr

After processing thousands of bank statements, invoices, and receipts through Claude Vision API, I've learned that financial document OCR is harder than it looks. Here's what actually works in production. The Problem: Why Traditional OCR Fails on Financial Documents Traditional OCR tools like Tesseract or AWS Textract struggle with financial documents for three reasons: Table structure is implicit — Banks don't use HTML tables. Columns are separated by whitespace, making it hard to know where one column ends and another begins. Numbers must be perfect — Confusing 1 with l or 0 with O creates accounting errors. A single misread digit can break double-entry bookkeeping. Format chaos — Every bank uses different layouts. Chase statements look nothing like Wells Fargo statements. Traditional OCR gives you raw text. You still need to write hundreds of lines of regex to parse it into structured data. Why Claude Vision API Changes the Game Claude Vision doesn't just extract text — it understands document structure . You give it an image and a prompt like: "Extract this bank statement into JSON with transaction date, description, debit, credit, and balance columns." Claude returns structured JSON directly. No regex. No manual column detection. Real Example Input: Bank statement PDF (converted to PNG) Prompt: Extract all transactions from this bank statement. Return JSON with: - header: {accountNumber, statementPeriod, bankName} - transactions: [{date, description, debit, credit, balance}] Rules: - Dates in YYYY-MM-DD format - All amounts as numbers (no currency symbols) - If a field is unclear, use null (never guess) Output: { "header" : { "accountNumber" : "****1234" , "statementPeriod" : "2024-01-01 to 2024-01-31" , "bankName" : "Chase Bank" }, "transactions" : [ { "date" : "2024-01-03" , "description" : "Amazon.com" , "debit" : 49.99 , "credit" : null , "balance" : 1450.01 }, { "date" : "2024-01-05" , "description" : "Salary Deposit" , "debit" : null , "credit" : 3500.00

Money has evolved into far more than the cash in your wallet or your bank account. And at TechCrunch Disrupt 2026, we’re devoting an entire stage to that progression.

Detecting what powers a website looks simple: send a request, read the response, match fingerprints. In real environments it rarely stays that clean. False positives slip through, infrastructure hides behind CDNs, old scripts linger after migrations, and fingerprints keep evolving. Developers who treat fingerprinting as a basic utility end up acting on misleading data. This guide covers the mistakes engineers make detecting website technologies and how to avoid them. Modern detection workflows lean on ProjectDiscovery's libraries, which cut these problems through structured pattern matching and maintained datasets. External resources: github.com/projectdiscovery/wappalyzergo projectdiscovery.io If you're new to the space, start with technology fingerprinting for developers before these pitfalls. Mistake 1: Trusting a single detection signal Relying on one clue is the fastest way to get a wrong answer. A script file may linger after a framework migration, a header can be spoofed, and a cookie might belong to a third-party service. Correlate several signals instead: headers, cookies, HTML patterns, script paths, metadata. When multiple indicators point at the same technology, confidence goes up. ProjectDiscovery's libraries are built around that multi-signal approach. Mistake 2: Treating detection as a one-time task Stacks change constantly. Organizations migrate infrastructure, update frameworks, and swap platforms more often than developers expect. Scan once and trust it forever and you're working from stale data. Schedule periodic scans. Many teams wire detection into automation pipelines so infrastructure changes get captured on their own. To operationalize this, see detect website technologies programmatically in Go . Mistake 3: Ignoring reverse proxies and CDNs Modern architectures hide origin servers behind proxy layers. You might detect a CDN and miss what actually powers the app. Detecting a CDN doesn't make the origin invisible. It means you need to look fur

The data isn't the hard part. Cleaning it is. SEC EDGAR is public, free, and a mess. Every quarter, 13,000+ institutional investment managers file Form 13F, disclosing their U.S. equity holdings. In theory that's a beautiful dataset — every hedge fund, every pension fund, every bank, all in one place. In practice, the raw filings actively fight you: The same institution files under different names, sometimes even in the same quarter. In our own database right now: BlackRock, Inc. and BlackRock Inc. are two distinct CIK registrations for what most people would call "one" institution. Multiply that across 13,000+ filers and you get a long tail of near-duplicate names that break any naive GROUP BY institution_name . CUSIPs don't map cleanly to tickers. Foreign issuers frequently use CUSIP prefixes that don't resolve through the usual reference data — we ended up building a fallback resolution path (Yahoo Finance lookups plus manual validation rules) just to keep ticker coverage from silently degrading over time. Quarters arrive gradually, not all at once. The SEC gives managers up to 45 days after quarter-end to file. If you naively take "the latest quarter with any data" as your reporting period, you'll rank a barely-started quarter — where only a handful of small filers have reported so far — ahead of the real, complete prior quarter. We learned this the hard way: an unclamped "most recent quarter" query once let 115 newly-onboarded institutions' entire existing portfolios get counted as "new inflow" with nothing to offset them, because a first-time filer has no prior-quarter row to diff against. That's the kind of bug that doesn't throw an error — it just quietly produces a chart that looks plausible and is wrong. Amendments (13F-A) revise, replace, or partially restate earlier filings , and the XML schema itself has shifted over the years, so parsing "just the latest 13F" isn't a fixed target. None of this is exotic — it's the normal cost of working with real-world

The bar we set We approved a plan on 2026-07-10 with an acceptance test we weren't sure was reachable. Six drafted analyst-memo queries against Nigerian economic data, scored 0-10 across five dimensions — named-entity density, citation quality, sector-specific detail, honest-gap acknowledgement, decision-usefulness. The strict pass criterion: every query's mean score across three temperature=0.2 runs must be ≥8/10, with no query below 6 in any single run. At approval time the aggregate was somewhere around 30/60 across the six queries — a system that produced grounded but generic answers, and refused competently but not always. The gap to the bar was real. We gave it 4-5 weeks. What we shipped Phase 1 — retrieval breadth. Kind-diversity enforcement across the top-K result set so a "start a fintech" query stopped collapsing into 12 CBN circulars and started pulling BOI, NEXIM, PayStack, Flutterwave, and the World Bank agribusiness chapters in the same context window. Named-entity boost when the query mentions "factory", "startup", "invest", "loan". Deduplication so a briefing about the same fact doesn't crowd out its own primary source. Phase 2 — a six-class rule-based intent classifier and memo templates. Sub-millisecond routing on regex patterns: venture\_feasibility\ , strategic\_forecasting\ , credit\_risk\ , regulatory\_analysis\ , market\_sizing\ , general\_qa\ . Each intent gets a memo template — a section-headed scaffold with a named-entity mandate, an honest-gaps section, and a 1000-1500 word target. The general\_qa\ template stays empty (no memo shape) so genuinely-general questions don't get forced into a memo they don't need. Phase 3 — composition quality. Two changes did most of the work here: 1. A CITATION PREFERENCE: PRIMARY OVER BRIEFING\ block in the system prompt. Primary sources — CBN circulars, NAICOM regulations, NBS reports, textbook chapters, IMF Article IV, press coverage of specific events — get cited over daily briefings when both are presen

reconmatch is a local-first transaction matching engine for accountants, bookkeepers, and controllers. Two CSVs in — books vs bank, invoices vs payments — a scored, auditable match report out. No account, no upload, no network call. Repo: github.com/SybilGambleyyu/reconmatch The unglamorous pain If you close books for a living, you already know the scene: two windows open, a bank CSV on the left, a general-ledger export on the right, and an afternoon disappearing into "which deposit is which invoice." Bank feeds help until they do not. The hard cases are ordinary: One deposit that covers three invoices Two payouts that sum to one sales batch on the books A check number in the memo on one side and a dedicated column on the other "ACH ACME CORP INV 1042" vs "Invoice payment ACME Corp" An orphan the feed never explained Enterprise close tools charge enterprise prices and want the data in their cloud. For a CPA firm or bookkeeper sitting on confidential client ledgers, "just upload the CSV" is often a non-starter. Spreadsheet VLOOKUP falls over on partial payments and batch deposits. What reconmatch does Matching runs in deterministic phases so the same inputs always produce the same proposals: Exact / reference-strong — amount within tolerance, date in window, shared invoice/check/wire token Amount + date — numbers line up even when memos are noise Fuzzy description — token overlap plus sequence similarity (pure Python stdlib) Group 1:N and N:1 — one line equals the sum of several on the other side Every accepted match carries a score and human-readable reasons suitable for a workpaper. Unmatched lines stay unmatched — the tool does not invent a story for them. pip install git+https://github.com/SybilGambleyyu/reconmatch.git reconmatch books.csv bank.csv -o ./march-recon Outputs: plain-text report, matches CSV, unmatched CSV, and full JSON. Zero required third-party dependencies. Python 3.10+. Library use from reconmatch import MatchConfig , match_transactions from rec

After five years of shipping features at Tittri, the team gave me a piece of feedback that stung a little: I was good, but I only ever built what I was asked to build. And we delivered, end to end, every week. From dashboards to multi-step workflows to third party integrations, all of it to make dense workflows understandable. Somewhere along the way I'd become all about business critical web apps, where the frontend is not just visual, it's how people execute operations reliably. But it just wasn't enough for me. So in January 2026 I stopped waiting to be asked, and pitched an AI integration into a UK-based fintech client's product, one that handles real business loans. When I finally presented the idea to the team and the client, after enough brainstorming and planning and identifying the best way for the brokers to benefit from it, expectations rose. No prior AI integration experience, no matching tutorials, real users, real data, real money. Then I had to actually build it. What is the client and why AI The client is one of the UK's pre-eminent business finance brokers and comparison services that combines advanced technology with a team of finance experts to help small and medium-sized enterprises (SMEs) and their advisors find, compare, and apply for the most appropriate and affordable funding options from across the entire market. The client's B2B product is a commercial finance brokerage SaaS, where brokers manage deals, calls, emails, documents, lenders, AIPs (Agreement In Principle), credit/KYC, corporate structures, properties...etc. The brokers use the SaaS to run the whole lifecycle of a deal, and before AI every single step of it was manual. A typical deal goes like this: An enquiry comes in by call or email, something like "my client needs £400k to buy out a GP partner". The broker gets on a discovery call that can run 30–90 minutes, writes up the notes afterwards, creates the deal, and then starts gathering everything a lender will want to see. Finan

The one-year-old startup aims to reinvent financial architecture for autonomous AI transactions.