# Switch from DecisionRules to GoRules | Rules Engine Migration

> Step-by-step DecisionRules migration guide: map Decision Tables, Decision Trees, Scripting Rules, and Decision Flows to JSON decision graphs, convert operators to Zen expressions, and run them on Zen Engine.

v2.0

GoRules Version 2 is here - redesigned, now with managed cloud.GoRules Version 2 is here!

Watch the launch videoWatch

# Switch from DecisionRules to GoRules.

A step-by-step guide to moving your Decision Tables, Decision Trees, Scripting Rules, and Decision Flows to GoRules: map each rule type, rebuild with the AI copilot, validate in parallel, and cut over.

[Start migrating](https://us1.gorules.io) [Talk to an engineer](/contact-us)

## What you get with GoRules

Where your rules land: the parts of GoRules most relevant to this migration.

### One expression language everywhere

Decision table cells, expression nodes, and switch conditions all use Zen - a single expression language with 60+ built-in functions (`sum`, `avg`, `filter`, `map`, `date`, `duration`, `matches`). For logic beyond expressions, `functionNode` runs sandboxed JavaScript with `zod`, `big.js`, `dayjs`, and `http` imports.

### Versioning, environments, and rollback built in

Semantic versioned releases, environment-scoped deployments with rollback, and branching for parallel rule development. Publish, release, and deploy are explicit human actions, each with an audit trail.

### AI copilot for authoring and conversion

The copilot converts uploaded rule files into decision graphs, edits tables from plain-language instructions, generates test cases, and explains what a decision did on a given input. Deploys and releases stay explicit human actions.

### Stateless Rust engine with per-node tracing

The Zen Engine evaluates a decision per request: JSON in, DAG traversal in topological order, JSON out. Each node runs exactly once, and the response can include a per-node trace with input, output, and sub-millisecond timing.

## The migration path

A step-by-step route from your current setup to running your rules on Zen Engine.

### 1. Map DecisionRules rule types to GoRules node types

Decision Table rows map to `decisionTableNode` rows - condition columns become input columns with Zen unary tests (`> 1000`, `in ["US","CA"]`), result columns become output columns. The `FIRST_MATCH` strategy maps to `first` hit policy and `STANDARD` maps to `collect`. `EVALUATE_ALL` (which returns a result for every row, matched or not) and the `ARRAY` strategy have no direct hit-policy equivalent - restructure those tables around `collect` plus downstream expression logic. Calculation columns have no direct equivalent - use `expressionNode` upstream of the table to compute intermediate values. Decision Trees (IF-THEN-ELSE blocks) map to `switchNode` with ordered Zen conditions and downstream nodes for each branch. Scripting Rules map to `functionNode` (sandboxed JavaScript) or `expressionNode` chains for simpler logic. Decision Flows map to the graph itself - Business Rule nodes become `decisionNode` references, Switch nodes become `switchNode`, Assign nodes become `expressionNode`.

### 2. Convert operator syntax to Zen expressions

DecisionRules per-cell operators translate to Zen unary tests: `= "US"` → `"US"`, `>= 1000` → `>= 1000`, `BTW [10 AND 50]` → `[10..50]`, `IN "A"|"B"|"C"` → `"A","B","C"`, `NULL` → `== null`, `C TXT "abc"` → `contains($, "abc")`. Functions translate to Zen equivalents: `SUM(a,b)` → `a + b` or `sum(list)`, `CONCAT("a","b")` → `"a" + "b"` or `string(a) + string(b)`, `IF(cond,a,b)` → `cond ? a : b` (chain ternaries for multi-branch logic). Variables change from `{variableName}` to direct path references (`customer.age`). Inside an `expressionNode`, `$.key` references keys computed earlier in the same node; in decision-table cells, `$` refers to the tested column value.

### 3. Restructure flow orchestration patterns

If your Decision Flows use Foreach, Global Variables, Declare, REST API Client, or Database Query nodes, restructure them onto the graph DAG: `switchNode` for conditional branching, `expressionNode` chains for data transforms, `decisionNode` for sub-rule calls, and `functionNode` for HTTP calls or complex logic. For array iteration, use loop execution mode on `decisionTableNode` or `expressionNode` - set `executionMode: "loop"` with `inputField` pointing to the array (e.g., `order.items`) and `outputPath` to wrap the results. There is no built-in database query node - use `functionNode` with the `http` import to call a data API.

### 4. Handle Integration Flow workloads

If you use Integration Flows for batch processing or long-running jobs, note that GoRules does not have a built-in async job system - it is designed for synchronous request/response evaluation. For batch workloads, call the GoRules evaluate endpoint from your application's own job infrastructure (worker queues, cron jobs, or serverless triggers). The evaluate API returns sub-millisecond for typical rules, so high-throughput batch processing is achievable via parallelized HTTP calls from your orchestration layer.

### 5. Swap the API integration

Replace `POST /rule/solve/:ruleId/:version` with body `{"data": {...}}` and `Authorization: Bearer <SOLVER_API_KEY>` (plus any `X-Strategy` header) with `POST /projects/:projectId/evaluate/*` with body `{"context": {...}}` and the `x-access-token` header. The response changes from an array of result objects to `{ performance, result, trace }` - result is a single object, with built-in execution timing. If you send bulk inputs as an array under `data`, send individual requests per input instead (the engine creates and disposes per request). Three evaluation variants: `/evaluate/*` (published), `/environments/:environmentId/evaluate/*` (pinned release), `/releases/:releaseId/evaluate/*` (specific release).

### 6. Replace environment and CI/CD patterns

If your environments are modeled as separate spaces with distinct API keys and your CI/CD pipeline exports from one space and imports into another via the Management API (`decisionrules-cicd-tools`), replace that with first-class environments and release pinning: deploy a semantic versioned release to a named environment, and all evaluations against that environment use the pinned release. No export/import cycle needed. Branching supports parallel rule development with change request approvals. Roll back by repointing the environment to a previous release.

### 7. Validate in parallel, then cut over

Run identical inputs through both engines and compare outputs. GoRules simulation returns a per-node trace - each node reports its input, output, and execution time - so divergences localize quickly. Once outputs match, publish the decision documents and release them to the target environment, then switch your Solver API calls over to the GoRules endpoint.

GoRules AI

## Let the copilot do the translation.

The AI copilot can restructure rule logic described in natural language into GoRules decision graphs - adding nodes, edges, and Zen expressions via graph modification tools. It understands the Zen expression language, all 7 node types, and can simulate graphs during conversion. For DecisionRules migration specifically: describe your Decision Table conditions and the copilot generates `decisionTableNode` rows with Zen unary tests. Describe IF-THEN-ELSE tree logic and it builds `switchNode` branches. Describe Scripting Rule behavior and it produces `functionNode` or `expressionNode` chains. What it cannot do automatically: there is no file-format importer for DecisionRules exports - the copilot works from natural language descriptions and pasted rule logic, not from DecisionRules JSON exports. Decision Flow orchestration patterns (Foreach loops, Global Variables, database queries, REST API Client nodes) require manual restructuring into GoRules graph patterns. Integration Flow async job patterns have no direct equivalent and must be redesigned around your own batch infrastructure.

**On this page**

-   [What you get with GoRules](#what)
-   [One expression language everywhere](#one-expression-language-everywhere)
-   [Versioning, environments, and rollback built in](#versioning-environments-and-rollback-built-in)
-   [AI copilot for authoring and conversion](#ai-copilot-for-authoring-and-conversion)
-   [Stateless Rust engine with per-node tracing](#stateless-rust-engine-with-per-node-tracing)
-   [The migration path](#path)
-   [1\. Map DecisionRules rule types to GoRules node types](#map-decisionrules-rule-types-to-gorules-node-types)
-   [2\. Convert operator syntax to Zen expressions](#convert-operator-syntax-to-zen-expressions)
-   [3\. Restructure flow orchestration patterns](#restructure-flow-orchestration-patterns)
-   [4\. Handle Integration Flow workloads](#handle-integration-flow-workloads)
-   [5\. Swap the API integration](#swap-the-api-integration)
-   [6\. Replace environment and CI/CD patterns](#replace-environment-and-ci-cd-patterns)
-   [7\. Validate in parallel, then cut over](#validate-in-parallel-then-cut-over)
-   [Let the copilot do the translation](#ai)

## Other migration guides

[View all guides](/switch)

[_Guide_

### Switch from Drools

A step-by-step guide to moving your DRL rules, DMN models, and spreadsheet decision tables to GoRules: export, convert with the AI copilot, validate in parallel, and cut over.

](/switch/drools)[_Guide_

### Switch from IBM ODM

A step-by-step guide to moving your BAL rules, decision tables, and ruleflows to GoRules: export, convert with the AI copilot, validate in parallel, and cut over.

](/switch/ibm-odm)[_Guide_

### Switch from FICO Blaze Advisor

A step-by-step guide to moving your SRL rulesets, decision tables, ruleflows, and score models to GoRules: map the BOM to JSON, convert with the AI copilot, validate in parallel, and cut over.

](/switch/fico-blaze-advisor)

## Leave the build step  
behind.

Bring your DecisionRules rules over, run both engines in parallel, and cut over when the outputs match.

[Get started](https://us1.gorules.io) [Book a demo](/contact-us)
