Start typing to search this publication.
techcirkle
Open menu

Subscribe to techcirkle

Get new posts delivered straight to your inbox.

Building AI Fraud Scoring Around a Deterministic Payment Core

An engineering pattern for ACH fraud scoring: anomaly models, payee-change risk and human review, all advisory to a deterministic payment core.

techcirkle
5 min read
Cover image for Building AI Fraud Scoring Around a Deterministic Payment Core

A fraud model in a payment system needs one property above accuracy: it must be structurally incapable of causing money to move. It can slow a payment down, send it to a person or attach a warning. Entries, limits, retry caps and ledger postings stay in deterministic code.

The reason this pattern is getting attention is partly regulatory. Nacha's 2026 risk management rules put false-pretense payments squarely in scope for covered parties, and in those payments the authorized user is real while the instruction is false. Static rules struggle there. So here is how we would wire scoring into an ACH system without letting it near the money path.

An executive holding a smartphone and completing an online financial transaction at a desk beside a tablet
An executive holding a smartphone and completing an online financial transaction at a desk beside a tablet

The shape of the system

payment intent
   |
   v
deterministic validators  (limits, calendar, payee status, role checks)
   |
   v
risk service (advisory)   -> score, reasons, model version
   |
   v
policy engine (code)      -> ALLOW | HOLD | REVIEW | REJECT
   |
   v
approval workflow -> origination -> ledger

Two properties matter. The risk service has no credentials for origination and no write path to payee records. And its output is only one input to a policy engine that is ordinary, versioned, unit-tested code.

type Risk = { score: number; reasons: string[]; modelVersion: string } | null;

function decide(p: Payment, risk: Risk): Decision {
  if (exceedsHardLimit(p)) return reject('limit');
  if (p.payee.changedWithinHold) return hold('payee_cooling_off');
  if (!p.payee.callbackVerified) return hold('callback_required');

  // Fail toward review when the model is unavailable on risky flows.
  if (risk === null) return p.isFirstToPayee ? review('no_score') : allow();

  if (risk.score >= policy.reviewAt) return review(...risk.reasons);
  return allow();
}

Notice what the score cannot do. No branch lets a low score skip a hold, a callback or a limit. The score can only add friction. If the model is unavailable, the system degrades to its rules instead of failing open.

Signal one: behavioral anomaly scoring

Rules such as "flag anything above $50,000" are readable and easy for attackers to stay under. A model trained on your own history can notice that a payment is unusual for this payer, this payee and this time of month, even with an unremarkable amount.

Useful feature groups include:

  • Pair history. How often this payer has paid this payee, and at what intervals and amounts.

  • Timing. Position in the billing cycle, and distance from the usual run.

  • Operator behavior. Who prepared the payment, and how that compares with their norm.

  • Destination recency. How recently the receiving account was added or edited.

An unsupervised anomaly model is a practical start, because confirmed fraud labels are scarce early on. Supervised models become more viable as review outcomes accumulate. Whichever you use, evaluate per payer segment, since one aggregate metric can conceal poor behavior for small accounts.

Signal two: payee-change risk

The most valuable place to score is often upstream of the transfer, at the moment bank details are created or altered. Treat a change as its own event with its own pipeline:

onPayeeAccountChange(async (change) => {
  const signals = {
    lookalikeDomain: domainDistance(change.requestDomain, change.payee.knownDomain),
    ownership: await validateOwnership(change.newAccount, change.payee),
    velocity: recentChanges(change.tenantId),
  };
  const assessment = await riskService.assessChange(change, signals);

  await startHold(change, policy.coolingOff);
  await requireCallback(change, { phone: change.payee.phoneOnFile });
  await audit.record(change, signals, assessment);
});

The hold and the callback happen regardless of the score. The assessment only determines how much attention the case gets. Note also that the callback number comes from the existing record, never from the request, and that validation tests ownership in addition to existence, since an open account belonging to the wrong party passes a simple check.

Keep the explanation with the decision

Under the 2026 rules, covered parties must maintain risk-based processes and review them at least annually. Monitoring has to be demonstrable, and a black-box number with no retained reasoning makes that harder. Store an immutable record per decision containing input feature references, score, reasons, model version, policy version and outcome. When someone asks why a payment was or was not held, you want to replay the exact context.

This is engineering guidance and not legal advice. Your ODFI's interpretation and the rule text are what bind you.

Human review as a system component

A flagged payment needs somewhere good to land. A workable review queue has:

  • Enforced separation of duties. Whoever created or edited the payee cannot approve its first payment, and this is checked in code.

  • Context on one screen. Reasons, payee history, change log and the documents behind the payment.

  • Outcome capture. Every decision becomes a structured label, which is how the supervised model gets better over time.

Language models fit nicely here as assistants. They can summarize the case and draft a note for the reviewer. Ground them in your own records and treat every outside document as untrusted, because a hidden instruction in an invoice is a prompt injection attempt. Our LLM integration practice concentrates on this kind of grounded, auditable layer, and our AI development services cover the models around it.

Sequencing

Do not begin with the model. Ship the ledger, state machine, role separation, payee holds and rules-based monitoring first, then log everything. Once you have clean labeled history, introduce scoring in shadow mode, compare it against reviewer decisions, and only then let it route real work. The surrounding system matters more than the first model you try, as our complete guide to ACH software explains in its discussion of ledgers, returns and fraud controls.

Frequently Asked Questions

Can a fraud score ever approve an ACH payment by itself?

It should not. In this design a score can only add friction such as a review or hold. Clearing a payment is decided by deterministic policy, and a low score never bypasses limits, callbacks or cooling-off periods.

What should happen if the fraud model is down?

The policy engine should degrade to its rules. Routine payments may continue, while higher-risk cases such as a first payment to a payee go to review. The system should never fail open simply because a score is missing.

Why score payee changes separately from payments?

The bank-detail change often comes before the fraud and gives the earliest chance to stop it. Scoring it separately, alongside mandatory holds and callbacks, offers more protection than analyzing the later transfer alone.

What should be logged for each fraud decision?

Record the input references, score, reasons, model version, policy version and final outcome, immutably. That supports the demonstrable monitoring expected under Nacha's rules and allows any decision to be reconstructed later.

When is a team ready to add machine learning to ACH fraud checks?

After the deterministic core and rules-based controls are running and producing clean labeled history. Run the model in shadow mode first, then let it route work once its results compare well with reviewer decisions.

Subscribe to techcirkle