Everything the engine can do

A full list of what Inzinx's eligibility and rating engine actually supports today — not a roadmap. Want steps for how to actually use each one? See the Business User Manual. Building against the API directly? See Developers for request/response shapes.

Eligibility & rating logic

What a single rule can express.

Eligibility conditions & Decision Graphs

  • Chained Decision Graphs (DAG). model complex multi-step pipelines visually with 6 node types (Input, Eligibility, Table, Rating, Transform, Output), context mutation, and conditional on_pass / on_fail branching.
  • Nested AND / OR / NOT. arbitrarily deep condition trees, not a flat list of checks.
  • 10 Native comparison operators. numeric/equality (==, !=, >=, >, <=, <, in), rich strings (starts_with, ends_with, contains, not_contains), linear-time regex (matches), and network CIDR range checks (cidr_match).
  • Null & empty safety. built-in is_null, is_not_null, is_empty, and is_not_empty checks that handle missing or blank fields gracefully.
  • Nested array quantifiers. array_any, array_all, array_none, and array_count with sub-conditions and $item sentinels to evaluate multi-item carts, covered drivers, or claims without code.
  • Raw expressions. sandboxed Rhai scripts for arbitrary formulas and arithmetic when needed.
  • Composable rules. a condition can reference another one of your eligibility rules by id ($ref) instead of duplicating its logic — expands inline in the trace.

Rating factor kinds & Decision Tables

  • DMN 1.5 decision tables & hit policies. exact-match and numeric-range lookup tables with First, Unique, CollectSum, CollectCount, and CollectMin/Max hit policies.
  • Spreadsheet CSV import / export. bidirectional CSV round-tripping with row-by-row pre-validation to bulk-load pricing matrices from Excel or Google Sheets.
  • Keyboard-first entry grid. arrow keys, Tab, and Enter-adds-row navigation for editing table rows directly, plus pasting a block of cells copied straight from Excel or Google Sheets in one go.
  • Flat. a fixed multiplier or addend.
  • Condition-based. applies only when a condition passes (e.g. a bundling discount).
  • Tiered / bracket. a progressive charge across brackets of a basis value (e.g. layered limits).
  • Deductible curve. a factor read off a curve of deductible-to-factor points, step or interpolated.
  • Raw expression. a factor's value computed from a formula, for anything the structured kinds can't express.
  • Rule composition (rating_ref). compose another rating rule's own computed amount into this one.
  • Accumulators. a persistent, cross-call running total — e.g. how much of an annual deductible has been paid so far.
  • Reinsurance layers. excess-of-loss attachment point + limit, composable into a full layered tower.

Calculation correctness

  • Effective-dating, region, and product-type scoping. one rule id can have multiple versions; the most specific match is selected automatically.
  • Multi-line-item and multi-entity rating. rate a bundle of items, or the same rule across several members, in one call.
  • Mid-term pro-ration. built in, not something you compute separately.
  • Configurable rounding. half-up, half-even, or truncate, with per-region overrides.
  • Exact decimal arithmetic. never floating-point rounding errors on money math.

Safety, AI explainability & governance

  • Natural-language rule generation. describe what you want in plain English and get a draft condition tree back to review — nothing is ever saved or activated automatically.
  • 4-Eyes Maker-Checker governance. strict multi-user approval queues (Draft -> Pending Review -> Active) with independent reviewer sign-off to satisfy banking and insurance compliance.
  • Visual semantic diffing & 1-click rollback. AST-level diff viewer highlighting added, removed, and modified clauses between any two versions, with instant rollback.
  • Deterministic plain-English explainer. zero-hallucination recursive AST translator rendering complex logic into plain English for audit and compliance teams.
  • Auto-generated test scenarios. sample inputs derived from a rule's own structure to exercise its different branches, as a starting point before you write your own.
  • Shadow & conflict detector. real interval-overlap math flagging redundant or conflicting rules across your tenant.
  • Full evaluation trace on every call. not just a pass/fail or a number — a complete, nested explanation of exactly how each condition and factor contributed, suitable as an audit trail for a regulated industry.
  • Loud failure. a calculation error surfaces immediately, never a silent default.
  • Load-time and activation-time validation. overlapping effective-date/region/product versions of a rule are rejected outright.
  • Semantic lint checks. dangling table references, unused tables, no-op factors, out-of-order brackets, and likely-negative amounts are flagged before deployment.

Platform, observability & operations

How rules are simulated, monitored, metered, and billed.

Observability & Simulation

  • Interactive live simulator. test draft logic in real time with custom JSON payloads and inspect green/red condition traces and microsecond execution latency.
  • Real-time hit-rate radar. tracks evaluation frequencies and pass/fail ratios across rules and decision tables over trailing 24h, 7d, and 30d windows.
  • Condition rejection funnels. visual step-by-step drop-off breakdown pinpointing which specific condition is disqualifying applicants or orders.
  • Dead-rule detector. highlights active rules that have received 0 evaluations, keeping production logic clean.
  • Sub-millisecond latency distribution. monitors p50, p95, and p99 evaluation latency in microseconds (&mu;s), proving Rust's high-throughput performance.

Rule lifecycle

  • Draft → pending review → active → archived. every version of every rule, rating rule, table, and decision graph is retained forever, queryable newest-first.
  • Atomic activation. the full resulting active rule set is validated as a whole before anything commits — never a half-broken state.
  • Hot activation. a successful activation refreshes your live rules immediately, with no server restart and no effect on any other tenant.
  • Selective activate & deactivate. checkbox-driven — activate or deactivate exactly the rules, rating rules, tables, and decision graphs you choose, not an all-or-nothing switch.
  • Test before you activate. try a draft against real input on the actual evaluation path, before it's ever live.

Isolation & access

  • Full tenant isolation. your evaluate/rate calls only ever see your own activated rules, never a shared global set.
  • Two-tier API keys. admin keys manage rules, consumer keys are evaluate/rate-only — hashed at rest, never stored in plaintext.
  • Self-service key management. mint and revoke your own keys anytime, without needing us involved.
  • Per-tenant rate limiting. your own independent request budget — another tenant's traffic can never affect yours.

Usage, quotas & billing

  • Usage metering. every management and evaluation call is counted per day, visible to you via the dashboard.
  • Independent daily quotas. management (submit/activate/deactivate) and evaluation (evaluate/rate) are budgeted separately, so building rules never eats into your live-traffic allowance.
  • Transparent, database-driven plans. quotas and pricing come from the same plan data the public pricing page shows — never a hidden ceiling.

Operational trust

  • Database-backed audit trail. every eligibility/rating call and every rejected authentication attempt is logged.
  • Automatic backups. periodic database backups, shipped off-host, with a tested restore path.
  • TLS everywhere. every request, both to and from the engine, is encrypted in transit.

For the full picture on encryption, MFA, lockout, and what we don't have yet (SOC 2, a formal third-party pentest), see our security page.

Ready to try it?

Every account gets 3 months free with a daily quota — no credit card required.

Get started free