By Arnaud Schwartz and Antoine Popineau, in collaboration with OpenSanctions
Sanctions screening only works if it's fast enough. Otherwise, it gets in the way on a critical path.
If it isn't fast enough, the workarounds are worse than the problem.
Async checks that clear transactions before the result is back. Batch processing that leaves windows open for long periods. Sensitivity thresholds dialed down just to keep queues from backing up.
These aren't edge cases. They're what happens when screening infrastructure doesn't scale.
We refused these compromises. Because compliance teams deserve better. So we built Marble's screening layer on OpenSanctions: open, auditable, and continuously updated. Perfectly in line with Marble's values.
But there came a time when the volume demands of our largest customers outgrew the standard tooling.
We didn't want to compromise on the openness, auditability, and continuous updates. But we needed more speed. Improve efficiency. Not a quick hack solution: we’re building what compliance really needs.
So we re-engineered the matching engine, taking OpenSanctions even further. We call it Motiva.
Here's how – and how this open source innovation improves compliance teams' work.
OpenSanctions' yente as the foundation
Instead of creating black boxes, OpenSanctions builds flourishing, open ecosystems.
It provides an open, continuously maintained database of sanctioned individuals, politically exposed persons (PEPs), and entities of criminal or financial interest – drawn from over 360 official sources worldwide. Friedrich Lindenberg, OpenSanctions’ founder highlights that
“Openness is our design principle – it applies to our data and extends to our entire tech stack. Hundreds of compliance integrations, investigative journalists, and academic researchers all scrutinize our work, which creates a level of scrutiny that a proprietary system cannot match.”
Every record is traceable. Every source is named. When a match is flagged, you can follow the chain back to the original list it came from.
OpenSanctions publishes yente: an open-source screening API and can be hosted inside your own infrastructure.
Zero customer data leaves your environment. Zero black boxes stand between your transactions and the result.
This was our starting point: data sovereignty and complete transparency. Not as premium upgrade features. As baseline requirements.
The breakthrough: Motiva
We started with yente, built directly on OpenSanctions' data. It was, and still is, the reference implementation for this kind of screening. For our first wave of customers, it worked exactly as it should.
Then our volumes exploded.
We needed to speed screening up.
The problem wasn't yente's design. We had to push it further. Make it do more.
When you're scaling for the most demanding enterprise clients (including a crypto exchange with more than 17 million users), sanctions screening can't afford to take seconds.
If it takes too long, the options are bad: delay the transaction, skip the check, or run it asynchronously and accept the gap.
None of those are acceptable for a company that takes screening seriously.
Marble does not accept compromises like that. We innovate them away.
As Antoine Popineau said:
“So I rebuilt the matching layer.
Not the data. OpenSanctions' data remains the source.
And at that stage, not the scoring logic, either. I reimplemented OpenSanctions' own published algorithms, carefully and verifiably, checking the results against the original at every step.
What changed was the execution: a tighter, leaner engine, purpose-built for the concurrency levels Marble's customers actually operate at.”
The results speak for themselves.
- Maximum latency: slashed from 1.26 seconds down to 254 milliseconds.
- Compute costs: reduced resource consumption by 75%.
- Hardware footprint: a workload that previously starved four processing cores now runs flawlessly on one single core, with headroom to spare.
That's what Motiva is. Marble's way to take OpenSanctions' yente further – without compromising any of what made it worth building on in the first place.
This is what cutting-edge innovation looks like. We took the absolute best open-source compliance foundation on the market, and gave it enterprise-grade velocity. To prove that compliance never has to compromise on speed to get precision.
What Motiva brings to compliance teams
Speed is the headline.
But it's not the point.
Control is.
Slow screening forces compliance teams to give up control and make bad compromises.
Like raising thresholds to reduce queue pressure. Moving checks out of the critical path. Accepting a gap between when a transaction clears and when the screening result is back.
Each adjustment may feel like a pragmatic decision. But together, they erode precision. Steal control.
Motiva erases that limit. It gives control back to compliance teams.
When screening returns in under 300 milliseconds (even at the transaction volumes of a platform with millions of users), you don't need workarounds anymore. The system works exactly as compliance was always meant to: checking every transaction every single time, without lag, directly in the payment flow. No more asking compromises from compliance teams on precision and speed.
This gives them three massive advantages:
1. Your risk appetite determines your rules – not hardware limits
In Marble, you configure your own matching thresholds. How many candidates to review, which lists to screen against, and many more.
With Motiva as the engine, those settings are yours to set.
You never have to dial them down because the system can't keep up. You set them exactly where your risk framework says they should be.
2. Every transaction screened in real time, every time
Real-time screening is what separates a screening program that actually works from one that mostly works. When a payment hits Marble, every party is screened and cleared before the transaction is finalized. Automatically, completely, and without exception.
Screening queues, samples, and batches are dangerous.
A bad actor added to a watchlist overnight can easily clear a transaction before the next batch window opens.
Marble's screening closes that window on compromises for good
3. Screening doesn't stop when the transaction settles
Continuous monitoring doesn't wait for a transaction to occur. Marble runs it in both directions simultaneously.
When a sanctions list updates, Marble automatically screens the changes against your entire customer base instantly. So a match surfaces today. Not at the next scheduled batch or at the next onboarding review.
And it runs the other way, too.
The moment client data changes (a name change, an updated nationality, a new address), that record is instantly re-screened against all lists.
Motiva's innovation moves compliance from a point-in-time check to real-time protection. A paradigm shift thanks to cutting-edge, open-source innovation innovation.
OpenSanctions’ perspective
For OpenSanctions, the value of open infrastructure isn't just in the data itself. It's in what others build when the foundation is transparent enough to build on. As Friedrich Lindenberg, OpenSanction’s founder put it:
“Marble didn’t need to design or license a new matching methodology – they could rebuild yente’s matching layer to suit their use case.
This kind of collaboration creates a natural upgrade path that strengthens the broader compliance ecosystem. It encourages open knowledge sharing between organizations, and ultimately allows us to work together to fight financial crime.”
What's next
We solved the transaction screening bottleneck at scale across millions of entities. Continuous monitoring was the first step.
Now, we are pushing the algorithmic edge even further.
Our next milestone target is handling messy, incomplete real-world data. Improving matching where records aren't clean or complete.
For example, in many jurisdictions, birth dates aren't fully precise (e.g.a birth year instead of a full date, a quarter rather than a month, a registration system that didn't exist when the entry was created). In legacy systems today, the date either matches exactly, or it doesn't affect scores. Real risk hides in the gap between "exact match" and "no match".
We're currently engineering smart, error-tolerant algorithms directly on top of OpenSanctions' logic to handle discrepancies proportionally, removing the final blindspots from high-velocity compliance.
The infrastructure is already in place.
The next step is making every match even more precise.
