Policy authoring, testing, and flows

Author policy, prove it with tests, and wire it into flows.

Write business rules in plain language, validate them with real test cases, and connect decisions into automated flows — all from one workspace.

Representative policy draft with readable business rules

Concrete test run with pass/fail outcomes and execution traces

Flow orchestration view showing how decisions connect downstream

Main workflow proof

From draft policy to routed decision

Live product surfaces

Author the rule

if applicant.risk_score > 72 -> manual_review

Prove the outcome

Test: High-risk applicant -> manual_review

Trace: blocked_country false, risk_score true

Route the decision

Intake

Policy decision

Manual review queue

Concrete proof points

See how it works, step by step

Each section walks through a core part of the workspace with representative examples so you know exactly what to expect.

1. Policy editor

Draft a versioned policy with schema context

Write readable rules, keep drafts separate from published versions, and shape the input contract before anyone ships a change.

Natural-language rule blocks for product and operations teams
Schema-backed inputs so test cases and runtime payloads stay aligned
Draft and published states kept distinct for safer iteration

Representative policy

Eligibility screening draft

Draft v4

policy eligibility_screeningstatus: draft

if applicant.country in blocked_countries -> reject

if applicant.risk_score > 72 -> manual_review

otherwise -> approve

Input schema

`applicant.country`, `applicant.risk_score`, `blocked_countries`

Publish guardrail

Draft stays isolated until tests and review pass.

2. Test runner

Run test cases and inspect execution traces

Validate scenarios before publish, inspect which rules fired, and repair logic with the exact data that produced a decision.

Named cases for approval, referral, and rejection paths
Execution trace output for outcome-by-outcome debugging
Pre-publish proof instead of trusting a generic feature claim

Concrete test run

Approval, referral, and rejection paths

3/3 passing

Test cases

EU applicant below risk thresholdapprove

High-risk applicantmanual_review

Blocked-country applicantreject

Execution trace

input.applicant.country = "DE"

rule blocked_countries -> false

rule risk_score > 72 -> false

outcome approve = true

3. Flow builder

Ship the policy inside a decision flow

Connect policy outputs to downstream actions so teams can orchestrate routing, follow-up checks, and human review in one place.

Visual handoff from intake to policy decision to next action
Reusable policy nodes inside larger approval or servicing flows
Clear operator view of how a single rule affects the journey

Flow orchestration

How the policy feeds the next step

Approval flow

Intake node

Collect applicant data and normalise payload fields.

Policy decision node

Execute `eligibility_screening` and emit approve, reject, or manual review.

Approve path

Continue onboarding automatically.

Manual review path

Route to ops with the policy result and trace.

Enterprise isolation

Your data stays on infrastructure dedicated to your tenant.

Enterprise customers are routed to their own environment and backed by dedicated database servers. We do not ask enterprise tenants to share a database server and rely on loose application filtering to separate data later.

Exact tenant routing

Dashboard traffic resolves from the exact tenant hostname, and invalid tenant hosts do not enter tenant-scoped content.

Tenant-bound API keys

API keys resolve through a dedicated key service so the orchestrator connects to the correct tenant database server without client-selected tenant input.

One enterprise tenant, one database server

If you are an enterprise customer, your data is your data. Each enterprise tenant is mapped to a dedicated database server so storage boundaries are explicit, easier to audit, and fail closed on mismatch.

Ready-made recipes