Building an Evidence-Driven Workflow: A Step-by-Step Guide

Introduction

Traditional enterprise workflows rely on decision trees, where each step evaluates fixed conditions and branches accordingly. This approach works well when inputs are limited and scenarios are predictable. However, modern processes incorporate a growing number of signals—behavioral indicators, fraud scores, identity verification results, machine learning predictions, and regulatory checks—that must be interpreted together. Embedding these interactions directly into branching logic leads to fragile, hard-to-maintain systems.

An alternative model is the evidence-driven workflow. Instead of predefining every possible path, it accumulates signals about a case and dynamically determines the next appropriate action. Progression is governed by the evolving evidence, not static branches. This guide walks you through building such a workflow, separating contextual reasoning from deterministic execution using a dedicated runtime layer (the Agent Tier).

What You Need

• Workflow engine supporting dynamic routing (e.g., Camunda, Temporal, or custom state machine)
• Decision management platform or rules engine for evidence interpretation
• Access to signal sources: identity verification APIs, fraud detection services, behavioral analytics tools, regulatory databases
• Event bus or message queue to collect signals asynchronously
• Case data store (relational or document DB) to maintain evolving evidence state
• Development team familiar with microservices, event-driven architecture, and workflow orchestration

Step-by-Step Guide

Step 1: Analyze Your Current Process and Identify Signals

Start by mapping your existing workflow as a decision tree. List every point where a branching decision occurs and identify the signals that influence it. For a customer onboarding process, common signals include:

• Identity confidence scores from document verification
• Biometric validation results
• Device fingerprint and behavioral patterns
• Fraud detection model outputs
• Regulatory policy checks (e.g., AML/KYC)

Critically, note interactions between signals. For example, an identity verification pass may be acceptable alone but requires scrutiny when combined with unusual device characteristics. Understanding these interactions helps you design evidence categories later.

Step 2: Define Evidence Categories and Their Weights

Group signals into logical categories. Each category should represent a dimension of evidence that contributes to case progression. For example:

• Identity Confidence: document verification, biometrics, third-party identity services
• Behavioral Indicators: typing rhythm, navigation patterns, time of day
• Fraud Risk: fraud score, device reputation, geolocation anomalies
• Regulatory Compliance: sanction list checks, suitability questionnaires

For each category, define a weight or priority that influences the next action. Not all evidence is equal; some signals may be dispositive (e.g., a positive hit on a sanctions list leads to immediate rejection), while others merely adjust the risk score.

Step 3: Build the Runtime Layer for Contextual Reasoning (Agent Tier)

The core idea from the original article is to separate contextual reasoning from deterministic execution. Create a dedicated runtime layer—the Agent Tier—that interprets all accumulated evidence and decides the next action. This layer should:

• Listen for new signals via an event bus
• Update the case’s evidence state in a data store
• Apply decision rules (e.g., “if identity confidence is high AND fraud risk is low → proceed to verification”)
• Emit a command to the workflow engine: e.g., “move to Approval step” or “request manual review”

The workflow engine itself remains deterministic: it only knows how to execute states and transitions. All what-to-do-next logic lives in the Agent Tier.

Step 4: Design Dynamic Next-Action Rules

Instead of branching on individual signals, write rules that evaluate the combined evidence state. For example:

• If identity confidence > 90% AND fraud risk < 20% AND behavioral indicators normal → auto-approve
• If identity confidence > 70% BUT fraud risk > 50% → send for manual review
• If any critical check fails (e.g., sanctions hit) → reject immediately

These rules can be maintained in a decision table or a simple if-then logic. The key is that they reference the aggregated evidence, not raw signals. This makes them robust to changes in individual signal sources.

Step 5: Implement Accumulation Logic

Each time a new signal arrives, your system must update the case’s evidence without interrupting the workflow. Use an event-driven approach:

1. Signal producer publishes an event (e.g., “identityDocVerified”) to the event bus.
2. Agent Tier subscribes to this event, fetches current case evidence from the data store.
3. Updates the relevant category (e.g., sets identity confidence to 95%).
4. Re-runs the decision rules. If the new evidence triggers a transition, the Agent Tier emits a command to the workflow engine.

Ensure idempotency: duplicate events should not double-count evidence. Use exactly-once processing semantics where possible.

Step 6: Wire the Workflow Engine to Execute Deterministic Steps

Configure your workflow engine to expose endpoints that the Agent Tier can call. For each step in the process (e.g., “Collect Documents”, “Verify Identity”, “Assess Fraud”, “Make Decision”), define a state. The engine only transitions when it receives a command from the Agent Tier. This keeps the engine simple and stateless regarding business logic.

Example: When the Agent Tier decides “proceed to identity verification”, it triggers an HTTP POST to the engine’s API. The engine moves the case from “Initial” to “Identity Verification” and awaits the next command.

Step 7: Test with Realistic Scenarios

Simulate various combinations of signals to verify that the evidence-driven behavior works as intended. Create test cases such as:

• Normal applicant with clean signals → expected to pass through quickly
• High fraud score but strong identity → should trigger manual review
• Mixed signals arriving out of order → ensure accumulation is correct
• Edge cases: missing signals, timeouts, conflicting evidence

Use these tests to refine your decision rules and ensure the Agent Tier handles interactions properly.

Step 8: Monitor and Iterate

Once deployed, monitor the workflow’s performance. Key metrics include:

• Average time to decision
• Percentage of cases requiring manual intervention
• False positive/negative rates for automated decisions

As new signals emerge (e.g., new fraud indicators), add them to the relevant evidence category without rewriting the workflow. The modular design of the Agent Tier allows you to update decision rules independently of the workflow engine.

Tips for Success

• Start small: Choose a single process (e.g., customer onboarding) and convert it from decision-tree to evidence-driven. Learn before scaling.
• Separate concerns rigorously: Keep all contextual reasoning in the Agent Tier. The workflow engine should have zero knowledge of signal interpretation.
• Design for asynchronous accumulation: Signals may arrive after the case has moved forward. Your system must handle updates gracefully (e.g., by triggering a re-evaluation).
• Avoid over-engineering rules: Use simple if-then or decision tables initially. Complex rules can be replaced later with machine learning models if needed.
• Document evidence interactions: When two signals together change behavior (e.g., device mismatch + high fraud score), document the rationale so future maintainers understand the logic.
• Use internal anchor links for easy navigation within long guides (as done here).

By following these steps, you can move from brittle decision trees to flexible, evidence-driven workflows that adapt to increasing complexity without sacrificing maintainability.