A Verdict That Shows Its Work
The hard part of sanctions screening was never finding the match. It was remembering why you decided what you decided.
A compliance manager I spoke with a while back described a moment that stuck with me: an auditor pulled a file from eight months earlier and asked why a particular vendor had been cleared. The answer, at the time, existed only in one analyst’s memory, and that analyst had left the company four months prior. The spreadsheet said “cleared.” It didn’t say why, who decided, or what the analyst had actually looked at before typing that word into a cell.
That gap is where a lot of screening programs quietly fail, and it isn’t the part anyone designs for up front. Most of the attention in building or buying a screening process goes to the matching itself: does it catch the right names, does it handle misspellings, does it check the right lists. All of that matters. But a match is only half the job. The other half is producing something that survives past the moment the decision was made, something a different person, possibly a regulator, possibly a new hire trying to understand a legacy case, can pick up later and actually reconstruct the reasoning from.
Here’s the shape of the problem in practice. A name gets screened. It comes back with a fuzzy match against a sanctions list, say a score of 91 out of 100, against two slightly different name-and-date-of-birth combinations on the OFAC SDN list. Somebody has to decide what that means. Is it the same person under a translated or abbreviated name, or a coincidental overlap between two unrelated people who happen to share a common name and a plausible birth year? That decision, once made, is either recorded with the reasoning attached, or it collapses down to a single word: cleared, or escalated.
The single word is what most homegrown processes end up with, not because anyone chose it deliberately, but because a spreadsheet or a lightweight internal tool doesn’t naturally force anything richer. Somebody builds a column for status. Nobody builds a column for “why,” because at the time it feels obvious. It’s only obvious the day the decision is made. Eight months later it isn’t obvious to anyone, including the person who typed it.
Get Howth Technology Factory’s stories in your inbox
Join Medium for free to get updates from this writer.
What changes this isn’t a policy reminding people to write better notes, since that relies on discipline holding up under deadline pressure indefinitely, and it never does across an entire team over years. What changes it is a screening process that produces a structured verdict as its actual output, not just a pass/fail flag. A verdict that includes the match score, which lists it came from, which specific evidence drove the outcome, and a place for a reviewer’s decision to actually attach to that evidence rather than floating separately in an email thread or a Slack message that’s since been deleted in a retention sweep.
The diagram above shows roughly what that structural difference looks like. A raw match comes in carrying its own facts, the list it hit, the score, how many name variants triggered it. That gets folded into a verdict object rather than a bare status. The verdict carries a status of CLEAR, REVIEW, or ESCALATE, but also the reasoning that produced it and a field for who signed off. That object is what gets stored, timestamped, and kept, so that the audit record isn’t a reconstruction project later, it’s just the same object read back.
This matters more the longer a compliance program runs, not less. Early on, when a team is small, memory can substitute for documentation because everyone involved is still around and still remembers the specifics. Programs don’t stay that way. People leave. Cases from years ago get pulled up during a regulatory exam, an M&A due diligence process, or a customer dispute, and by then the person who made the original call is often gone, and the reasoning has to come from what was actually recorded, not from someone’s recollection of a decision they can barely place.
There’s also a quieter cost to not having this, separate from the audit-exam scenario. Without a documented reason attached to a verdict, every review is effectively starting from zero. A name that was cleared six months ago, if it comes up again for a second transaction, gets re-litigated from scratch, because there’s nothing to check against except a bare status. With reasoning attached, a reviewer can see immediately that this exact scenario was already evaluated, what evidence was weighed, and whether anything has actually changed since then. That’s not just an audit benefit. It’s the difference between a review team that gets faster over time and one that redoes the same judgment call indefinitely.
None of this requires exotic engineering. What it requires is treating the verdict as the actual deliverable of a screening call, not an afterthought bolted onto a match score. We ended up building around a sanctions API with built-in verdict documentation specifically because it returns that structured object by default rather than a raw match list we’d have had to build our own documentation layer around. The distinction sounds small until the day someone asks why a decision from eight months ago was made, and the answer either already exists or it doesn’t.
