Identity Orchestration: What Happens Between an ID Check and a Decision?

Updated: 3 days ago
Verification returns a result in seconds. Trust decisions in regulated workflows depend on a good deal more. The layer in between is where most of the design work actually lives.

The industry has spent a decade making the ID check faster. It has spent far less time deciding what to do with the answer.
Consider the API call at the center of most digital identity products. An application submits a government ID and a selfie. A service compares the two, inspects the document, and returns a result: verified. The application proceeds. Presented this way, identity verification is a single transaction with a single output, and the vendor's job is to make that transaction faster and more accurate.
For low-stakes interactions that description holds. For a high-trust account, a regulated transaction, or a credential that will be relied upon by a third party, it does not. The verified result is one input among several. The organization still has to decide whether this person, on this device, in this context, presenting this evidence, should be allowed to do what they are asking to do. That decision draws on document authentication, biometric matching, liveness, fraud indicators, sanctions or watchlist screening, organizational or credential data, business rules, and, in the cases that matter most, a human reviewer.
The design problem, then, is not verification. It is orchestration: which trust signals a given interaction requires, when each should be collected, how they combine into a decision, and how that decision is communicated and audited afterward.
Verification is a transaction. Trust is a workflow.
The distinction matters because the two are engineered differently.
A verification transaction has a clear boundary. Evidence goes in, a result comes out, and the result is either accurate, or it isn't. Vendors compete on accuracy, coverage, and latency, and buyers evaluate them on those terms.
A trust workflow has no equivalent boundary. It begins before any evidence is collected, with the question of what evidence is needed at all, and it ends after the decision, with a record that can explain why the decision was made. Between those points it may branch, pause, escalate, and resume. Its quality is measured not by the accuracy of any one check but by whether the whole sequence produced the right outcome with the least friction and the clearest record.
Organizations that treat the workflow as though it were a transaction tend to make one of two mistakes. Either they run every check on every user, which is expensive and drives away legitimate customers, or they run the minimum check on every user, which is cheap and admits the wrong ones. Orchestration is the discipline of doing neither.
The Orchestration Pipeline
A useful way to see the whole workflow is as a pipeline with eight stages. These stages provide a working model for a high-trust workflow, even where individual implementations combine or omit some of them.
Request. An application asks for a trust decision on behalf of a user or a transaction. The request carries a purpose, not just an identity.
Context. The system establishes what it already knows: the channel, the device, the requested action, the risk tier that action belongs to, any prior relationship with this person.
Required checks. Given that context, the system determines which evidence is needed. A returning customer moving a small sum needs less than a new applicant opening a credit line.
Evidence collection. The user, or a connected data source, supplies the evidence: a document, a biometric, a bank credential, a registry lookup.
Verification and risk signals. Each piece of evidence is checked, and each check emits a signal. Some are binary (the document is or is not authentic). Others are graded (the face match scores at a given confidence; the device has or has not been seen before).
Decision logic. The signals are combined according to rules the organization owns. This is where thresholds, weightings, and escalation paths live.
Result. A decision is returned to the requesting application: approve, decline, or refer for review, with the reasons attached.
Audit trail. Every stage is recorded: what was asked, what was collected, what each check returned, how the decision was reached, and who, if anyone, intervened.

The rest of this article walks through the three stages where the design decisions are hardest, using a single hypothetical throughout: a digital financial institution opening a new deposit account, where identity requirements and fraud risk make the trust decision consequential.
Deciding what to check, and when
The applicant arrives through a mobile app and asks to open an account. Before any evidence is requested, the system already has context. The device is new. The IP address resolves to a residential connection in the state the applicant claims to live in. The requested product allows deposits and outbound transfers above a threshold the institution classifies as higher risk.
A transactional design would now run the full battery: document capture, selfie, liveness, database lookup, sanctions screen, all at once. An orchestrated design asks a prior question: what is the minimum evidence that would let this interaction proceed safely, and what would trigger more?
In practice the answer is tiered. The institution might begin with document capture and liveness, while holding additional checks in reserve. If the document authenticates and the face matches at high confidence, the applicant moves on. If the document is genuine but the face match is marginal, the system steps up: a second capture, a different angle, or a knowledge-based challenge drawn from a data source the applicant would need to control.
This is what risk-based verification means in operation.1 The friction is not removed. It is placed where the risk is. Note that the sequencing is itself a design decision with consequences: a check that runs early can short-circuit the pipeline and save every downstream cost, while a check that runs late can only confirm or reverse a decision that was nearly made. Which checks earn the early position depends on what the institution is most afraid of and how much each check costs, in money and in abandonment.
Weighing signals that don't agree
Suppose the applicant's document authenticates cleanly and the liveness check passes, but the sanctions screen returns a partial name match, and the device has been associated with two prior applications in the past month.
None of these signals is decisive on its own.3 A partial name match on a sanctions list is not, by itself, confirmation that the applicant is the listed individual.2 A device shared across applications may indicate legitimate shared access or coordinated fraud. A clean document and a live face are strong evidence that a real person is present, but say nothing about whether that person is who the account is for.
This is the point at which two things that are often conflated need to be held apart. A verification provider can tell an organization what it observed. The organization still has to decide what those observations mean for the action being requested. The first is a signal. The second is decision logic, and it belongs to the organization, because only the organization knows what it is protecting, what it is willing to risk, and what its regulators and auditors will expect it to have considered.
The mistake to avoid, then, is treating every signal as equally authoritative, or worse, treating the most recent signal as the authoritative one. Decision logic has to encode what the organization actually believes about the relative weight of its evidence. A sanctions partial match is a reason to look closer, not a reason to decline. A device cluster is a reason to look closer, and, combined with the partial match, perhaps a reason to pause. A successfully authenticated document is strong evidence about the document itself, but it does not resolve every question about the person presenting it or the interaction being requested.
The practical implication is that a decision engine may need at least three paths rather than a simple binary outcome. Approve and decline are the easy cases. The third, refer, is the one that separates a well-designed workflow from a brittle one. In the hypothetical, the combined signals would route the application to a reviewer with the full evidence set attached: the document images, the match scores, the specific sanctions record that partially matched, and the two prior applications from the same device. The reviewer's job is not to re-run the checks. It is to exercise the judgment the rules could not.
A workflow that has no refer path forces the rules to decide every edge case, and the rules will decide some of them wrong in both directions. A workflow that refers too readily turns the review queue into the real decision engine and the automation into an expensive intake form. Tuning the threshold between the two is a standing operational responsibility, not a configuration set once at launch.
Passing the result downstream
The reviewer clears the application. What does the account-opening system need to receive?
It needs a decision and a reference to the reasons. It does not need the applicant's document images, the raw biometric template, or the sanctions record that was examined and dismissed. Yet a surprising number of integrations pass exactly that: the full evidence bundle, forwarded to whichever system asked, because forwarding everything is easier than deciding what each consumer actually requires.
Two architectural considerations follow, and both need to be present in the design from the start rather than retrofitted.
The first is data minimization. Each downstream system should receive the verified attributes it needs and nothing more. The core banking platform needs to know the identity was verified to the institution's standard on a given date with a given reference number. The marketing system, if it is entitled to anything, needs less. Raw personal data that leaves the verification layer becomes a liability everywhere it lands.
The second is auditability, which is the mirror image. While downstream systems should receive less, the verification layer itself should retain a complete, tamper-evident account of what happened: which checks ran, in what order, with what results, who reviewed, and on what basis the decision was reached. When a regulator, an auditor, or a fraud investigator asks why this account was opened, the answer should be a record, not a reconstruction. The audit trail is not a log kept in case something goes wrong. It is the artifact that makes the decision defensible.
Together these two principles describe a verification layer that is generous with decisions and stingy with data: it tells every system what it concluded, and it tells almost none of them how.4
From "Can we verify this identity?" to "What evidence do we need to trust this interaction?"
Identity verification asks whether the evidence is valid and whether it supports the claimed identity. Most identity products are built to answer that question, and they answer it well.
Identity orchestration asks a different question: what evidence and signals are necessary to trust this interaction? That is the question organizations actually face every time a high-trust interaction begins, and it is a question about architecture rather than about any single check.
Framed that way, identity verification stops being a tool that returns a result and becomes a layer that assembles evidence, weighs it, decides, and remembers. The same layer can serve an account opening, a credential exchange, a regulated transaction, or a workforce onboarding, because the pipeline is the same even when the required checks differ.
It also raises a question this article has deliberately left open. Every stage above assumes the request comes from a person, or from an application acting straightforwardly on a person's behalf. As more requests originate from automated systems acting under delegated authority, the question of who is asking becomes as consequential as the question of who is being verified. That is a subject for another piece.
Verif-y Insights publishes work on identity verification, credentials, and the infrastructure that connects them.
This is the fist in a series on identity verification as infrastructure.
Next: what changes when verification is designed for APIs rather than users.
References
National Institute of Standards and Technology. Digital Identity Guidelines, NIST SP 800-63-4 (July 2025). https://pages.nist.gov/800-63-4
U.S. Department of the Treasury, Office of Foreign Assets Control. FAQ 5, "Assessing OFAC Name Matches" (updated September 9, 2026). https://ofac.treasury.gov/faqs/topic/1591
Federal Financial Institutions Examination Council. BSA/AML Examination Manual, "Customer Due Diligence — Overview" (May 2018). https://bsaaml.ffiec.gov/docs/manual/06_AssessingComplianceWithBSARegulatoryRequirements/02.pdf
National Institute of Standards and Technology. NIST Privacy Framework: A Tool for Improving Privacy Through Enterprise Risk Management, Version 1.0 (January 2020), Subcategory CT.DM-P8. https://doi.org/10.6028/NIST.CSWP.01162020




Comments