The author

Ben Archer

Lead Consultant

View profile
News & Views / Fraud-risk architecture as a driver of growth in open-finance models
19 November 2026

Fraud-risk architecture as a driver of growth in open-finance models

Open-finance ecosystems are expanding fast. Bank transaction data sharing, BNPL, and fintech platforms are pulling more players into every lending decision than ever before. But every new connection into that ecosystem is also a new route in for fraud. That risk is distributed and layered in ways most firms haven't built for yet.

That tension between integration and exposure sits at the centre of the outcomes-focused growth conversation regulators are having with the sector. Attacks on financial-services web and API applications reached over 742 million in the first half of 2025 alone, a rise of 51% on the year before. So the firms that build fraud-risk architecture as a real design discipline are the ones best placed to keep growing without that growth becoming the reason they stop.

Here's where that exposure sits, and what it takes to scale safely. 

Key takeaways

  • The real bypass routes run through third-party libraries and client-side SDKs, not core banking systems.
  • Latency timeouts push orchestration engines toward a silent "soft pass," bypassing checks entirely.
  • Waterfall-style checks (cheap first, expensive only if flagged) create a predictable path fraudsters can map and exploit.
  • Fraud-risk visibility needs to move from static assessment to a live API gateway plus event-driven graph database.
  • Short-lived, regularly cleaned-up tokens stop a single partner breach from becoming a mass account takeover.

Where fraud exposure really sits in open finance 

It's tempting to assume the risk lives in the core banking systems or the customer-facing layer. It doesn't. The real bypassing routes through a bank's security tend to run through third-party libraries and client-side SDKs.

Most open-finance platforms rely on multiple layers of data providers stacked on top of each other:

  • One vendor for account aggregation
  • Another for identity verification
  • A third for credit decisioning

That stacking creates a web of secondary and tertiary data transfers that most fraud teams have never fully mapped. Legacy APIs often stay live too, supporting older integrations long after they should have been retired. Attackers actively seek these older endpoints out, because they bypass the real-time rate-limiting and anomaly detection built into newer systems, opening a route to build synthetic identities using verified financial information.

Third-party involvement in breaches doubled to 30% across industries last year, according to Verizon's 2025 Data Breach Investigations Report, and fintech firms specifically saw 41.8% of breaches trace back to third-party vendors. In an open-finance model built almost entirely on third-party connections, that puts the risk close to the middle of the system.

Blind spots in a multi-vendor fraud stack 

Building a best-in-class fraud stack usually means stitching together specialists:

  • Device fingerprinting
  • Document verification
  • PEPs and sanctions screening
  • Behavioural biometrics

The trouble is these systems rarely sync with each other in real time.

Latency is where this breaks down first. If a biometric vendor takes noticeably longer to respond than usual, the orchestration engine often hits a timeout threshold. To protect the customer experience and avoid onboarding drop-off, the fallback logic tends to default to a soft pass, or bypasses that check entirely. The very design choice meant to protect conversion quietly opens a door.

Cost management creates a second blind spot. Firms typically build a waterfall flow, running cheaper, high-level checks first (email age, basic bureau checks) and only triggering the expensive, high-friction checks (live document verification, facial biometrics) if something looks suspicious. That's sensible economics. Fraudsters mapping that sequence is well known at this point. The useful point is what happens once a firm starts varying it. Unpredictable ordering and randomised triggers are what trip up targeted attacks, more than the checks themselves.

None of this is unique to any one firm. The average organisation now runs 131 third-party APIs, yet only 16% report a high ability to mitigate the risk those integrations carry. Most firms are running some version of the same exposed stack, and most haven't built a way to see across it yet.

Building fraud-risk architecture across the partner network 

The way through this is moving away from a static risk assessment and towards a live, governed view of the network, built with full visibility from the start. That means building two capabilities in parallel:

  • An API gateway that tracks metadata across the network, including IP paths, SDK versions and their ages, and latency, so issues in a partner's system show up before they become an incident.
  • An event-driven graph database that maps the links a static assessment would never catch: shared device IDs, shared bank accounts, the connections that reveal a coordinated attack instead of a string of unconnected events.

Even with both in place, controls still fail.

When a partner's controls fail

Two scenarios carry the most risk when they do: onboarding failure, and session hijacking or credential stuffing. 

  1. Onboarding failure. The core risk here is a provider returning a false-positive pass signal that gets accepted by the lender without question. Firms need protections in place to pause and verify pass signals before they feed the decisioning models that rely on them.
  2. Session hijacking and credential stuffing. Whether it's a mass compromise attack or a provider's system going offline for a period, either scenario leaves an organisation vulnerable to unauthorised transactions. Anomaly detection solutions that track and flag these attack types early give firms a way to isolate exposure before it spreads across the partner network.

Containment covers a failure once it's happened. But scaling safely means building for what comes next. 

What separates firms that scale safely in open finance

Three capabilities separate the firms that manage it from the ones that hit a ceiling.

  1. Real-time connections across the network. Graph database links across every partner instantly, so attacks are exposed and contained before they gain traction.
  2. Automated privilege controls. Gateway controls that degrade a compromised partner's privileges the moment it's identified, instead of waiting for a manual review cycle.
  3. Tokens that don't linger. Short-lived or periodically reviewed and cleaned-up tokens, so a breach at one third-party partner can't be exploited for mass account takeovers or data harvesting elsewhere in the network.

None of this happens without a case for why it's worth building. 

Fraud-risk architecture as a growth enabler 

Built this way, fraud-risk architecture becomes part of the case firms make to regulators for continuing to grow in open finance. It shows containment keeping pace with innovation, which is what outcomes-focused growth requires.

Most firms invest heavily in tools to detect fraud, but they rarely build the automated containment systems needed to stop it in its tracks. Fraud risk still tends to sit in the compliance column, so containment struggles to get the kind of investment detection gets. In many firms, fraud is treated as a number to report on, and the work ends once it’s been identified.

And open finance raises the stakes on that. Fraud, credit, and AML risk have always been connected. Open finance just makes that connection harder to ignore. Building architecture around that connection is what lets firms keep growing without fraud-risk fragility becoming the reason they stop.

If your fraud-risk architecture hasn't kept pace with your open-finance partnerships, Jaywing's risk specialists can help you map where the exposure sits.

 

You may also like: