The rules were written for a different business
Most libraries ship one generic set. A payments firm inherits patterns designed for a retail bank, and the ones it actually faces were never in the box.
Monitor transactions as they move, not overnight. Detect the typologies&patters your sector actually faces from a library that ships ready, prove a rule works against your own history before you publish it, and take a case from alert to filed report in one place.
Every other control tells you when it failed. A screening match is right or wrong, and you find out. Monitoring never closes that loop: the pattern nobody wrote a rule for produces no alert, no case, and no record that anything happened. So programs grow the only way they can: by adding typologies written for someone else's business to transactions that settled last night.
Most libraries ship one generic set. A payments firm inherits patterns designed for a retail bank, and the ones it actually faces were never in the box.
Overnight batch means the pattern surfaces once the funds have moved on. The alert describes something you can no longer act on.
A scenario runs for years without anyone measuring what it found. Adding one is safe; changing one is a gamble; removing one is unthinkable.
The platform already held the transactions, the counterparties, and the pattern. The analyst assembles them again, by hand, into a narrative.
Start from a ready library shipped that configured for your sector, or write your own conditions with Natural Language and AI, thresholds, and time windows. Then run it over your history and see what it would have done: how many alerts, how many real cases, what coverage nothing else provides. Nothing goes live on an assumption.
Stream transactions through the API as they settle, or deliver them as batch files on your own schedule. Both paths feed the same engine, so a firm running real-time payments and a firm sending nightly files get the same detection, at the speed their infrastructure allows.
An alert opens as a case with the picture already assembled: the transactions that triggered it, the customer's risk assesment, their screening position, the ownership chain behind them, prior alerts, and every counterparty involved. Notes, evidence and decisions stay on the case.
The narrative is drafted from what the case already contains, with the supporting transactions attached and the approval chain recorded. Review, amend, approve and submit without moving to another system.
A payments firm and a high-street bank operator face different patterns, so they receive different libraries. Each typology arrives pre-parameterized, mapped to FATF and regional guidance, and documented with the reasoning behind its thresholds. The first week is spent tuning rather than writing.
Conditions, thresholds, time windows, peer comparisons, and customer attributes, written in the interface with No-Code Interface. Your business has patterns nobody has published a typology for, and describing one should not require a release cycle.
Any rule, new or changed, runs over your own history before it goes live. Alert volume, cases still caught, and coverage unique to that rule are shown against the version it replaces. Turning a scenario off stops being a political decision and becomes an evidence-based one.
Transactions are evaluated as they arrive through the API in real time or delivered as files on your own schedule. Same rules, same engine, same case output, at whatever speed your infrastructure runs.
Alerts arrive as cases with the rating, screening position, ownership chain, prior alerts, and counterparties already attached. Assignment, notes, evidence, escalation, and the decision stay in one place, with every action timestamped and attributed.
The narrative is drafted from the existing investigation, in the format the receiving authority expects, with supporting transactions attached and the approval chain recorded. Filing happens where the work happened.
Type the logic the way you would explain it to a colleague. Nova lays out the conditions and explains what it built, and every node stays editable by hand.
A ready library shipped that has been configured for your industry, with each scenario documented with the reasoning behind its thresholds.
Stream transactions through the API as they settle, or deliver files on your own schedule. Same rules, same output.
An alert opens as a case with the picture already assembled, and the reason stated in language a reviewer can repeat.
What each scenario has actually produced, and what a change would do before you make it.
The narrative drafted from what the investigation already contains, in the format the authority expects.
Type the logic in plain language. Nova lays the nodes on the canvas and explains what it did, and every node stays editable by hand.
Institutions learn about new patterns alone, each one after its own loss. Confirmed typologies arrive here as ready-to-backtest scenarios you can switch on. The detection logic travels across the network. Customer data never does.
A scenario enters the library after an institution has worked it into real cases. What you receive has already produced findings somewhere, which is a different thing from a typology paper describing what might happen.
A shared scenario is a draft until you simulate it. Alert volume, cases it would have caught, and coverage that nothing else provides, measured on your transactions before they touch your queue.
Your customers, transactions, counterparties and thresholds stay yours. Only anonymized pattern logic moves, and contribution is opt-in, per rule, decided by you.
FATF, EBA, and local regulator updates are linked to the scenarios they touch, so a change in guidance arrives as a list of rules to review rather than a document to interpret.
Transaction behavior feeds the same customer risk score as screening and ownership, so a rising monitoring score pulls a customer into review across the whole program rather than only inside this module. And the score comes back the other way, setting the thresholds against which this customer is monitored.
Bring twelve months of transaction history and one scenario you have never been able to justify changing. In 30 minutes, you will see what it caught, what it cost, and what a tuned version would have done instead.
Post transactions as they settle or deliver them as files. Alerts arrive as events with the rule, the version, and the reason attached.
Rule-only monitoring buried analysts in false positives. After adding AI scoring against each customer’s baseline, alert volume fell and confirmed cases rose, because the alerts reflected the pattern.
Both. A library shipped configured for your sector runs from day one, each scenario pre-parameterized, mapped to FATF and regional guidance, and documented with the reasoning behind its thresholds. From there, you write your own patterns for which nobody has published a typology.
Transaction monitoring answers whether behavior should be reported over days and weeks. Real-time fraud prevention answers whether a payment should be allowed in milliseconds. Both run on the same customer record.
See Real-Time Fraud Prevention →Any rule, new or changed, runs over your own transaction history first. Alert volume, cases it would still have caught, and coverage unique to that rule come back as numbers, shown against the version it replaces.
Performance is measured per rule or customer: alerts raised, cases opened, filings produced, and false-positive rate. A scenario that has never converted is visible as such, and backtesting shows what it would have missed if retired. The decision is recorded with the evidence behind it, which is what makes it defensible rather than political.
Transactions are scored on ingest, so a pattern raises an alert while the activity is still current. Batch delivery by file is supported on the same engine, for firms whose infrastructure works that way.
Partly by scoring against each customer's own baseline, so ordinary behavior for that customer does not fire. Partly by letting you tune from inside the alert that prompted you, and prove the change in history before publishing it.
Typologies confirmed by other institutions arrive as ready scenarios you can backtest and switch on. Only anonymised pattern logic moves across the network. Your customers, transactions, counterparties and thresholds stay in your tenant, and contribution is opt-in per rule.
Every alert shows the rule and version that raised it, the transactions in the window, the counterparties involved and the reason stated in language a reviewer can repeat. Nothing fires on a number alone.
You describe the logic in plain language and Nova lays out the conditions, thresholds and windows on the canvas with its reasoning written alongside each node. Every node stays editable by hand, and the rule still goes through simulation and approval before it runs.
Yes. The narrative is drafted from what the case already contains, in the format the receiving authority expects like goAML, FINCEN, , with supporting transactions attached and the approval chain recorded.
Rules read the customer's rating, segment, and declared expectations, so the same scenario behaves differently for a merchant and a retail savings customer.
It is the largest weight in the Fusion score, so a rising monitoring score pulls a customer into review across the whole program rather than only inside this module.
Which of your scenarios has never produced a filing? Bring a year of history and we will run it, along with a tuned version, and show you the difference.
Complead provides ultimate control via its case management and safelist systems. Automated API operations significantly reduced my team's manual workload.
Using the API we run AML controls automatically and stay compliant, while reducing our team's daily workload.
With Complead we offer fast, easy, secure onboarding. We focus on real risks, not false positives.