One Complex Rule, Built Everywhere:
Code Effects vs DMN, GoRules, DecisionRules, IBM, FICO, Salesforce, Drools and NRules
Short answer: We took one realistic loan decision - five branches and a default, with calculations, a live credit bureau call, nested AND / OR logic, collections, date arithmetic, calls to other rules and actions - and drew what an author has to build to express it in each product's standard rule UI. In Code Effects it is one rule, built from menus and read as plain language from top to bottom. In DMN it becomes a decision requirements diagram, a set of FEEL expressions, a decision table and a BPMN process. In GoRules and DecisionRules it becomes a graph of nodes with expression or function cells and script or API nodes. In IBM ODM and FICO Blaze Advisor it becomes a vocabulary, a ruleflow and several near-English rules. In Salesforce Business Rules Engine it becomes an expression set with a six-path branch plus a Flow. In Drools and NRules it becomes code. Every one of these products can run this decision. The difference is how many artifacts and notations a person has to build, and then read, before the rule goes to production.
Why it matters more with AI. When an AI agent writes the rule, someone still has to approve it. In Code Effects that person reads the rule itself, as plain language, with no code and no diagrams - the same text in the standard editor and in the AI Rule Editor. See Reading the Whole Rule and AI Agents: Who Builds It, Who Checks It.
The Rule
A lender decides each loan application with these policies, checked in this order - the first one that applies wins:
- Fraud check. If the credit bureau's live score is more than 60 points below the score on the application, flag the application for fraud review, refer it, require manual review and record why.
- Hard decline. Decline, and email the decision, if the applicant is unemployed with an annual income under $20,000, is under 18, or has a debt-to-income ratio over 50%.
- Fast track. Approve prime borrowers within the DTI limit who ask for no more than four times their income, unless it's a home loan without real estate worth more than $100,000 among the collateral. The rate is 5.9% plus twice the DTI, and the decision email rule runs.
- Joint approval. Approve when the co-applicant's credit score is at least 700, the loan is at most three times the combined income, at least two collateral items are worth more than $10,000 each, and the purpose is a home, auto or business loan. The rate is 7.25% plus three times the DTI, and the decision email rule runs.
- Needs review. Refer broker applications, loans between $250,000 and $1,000,000, and applications submitted more than 30 days ago; notify an underwriter and record the reason, including the segment and the application number.
- Otherwise, decline and email the decision.
It's not an exotic rule, but it touches most of what real rules need: a field compared with a calculation of another field, a live method call, mixed AND and OR, a check over a collection and a count over it, dates relative to today, reuse of three rules that already exist (Prime borrower, DTI limit, Employment check) and of one that executes (Decision email), first-match order, a formula as an output, text built from fields, and actions.
The Rule in Code Effects
This is the rule in the Code Effects Rule Editor, built against the loan application source object of the Rule Repository online demo:

Every element in it is a menu choice in the editor: the fields, the operators, the values, the in-rule methods and actions (Credit Bureau Score, Debt To Income, Today, Flag For Fraud Review, Notify Underwriter, Send Decision Email), the three reusable rules used as conditions, and the inline rule executed from THEN. Nothing is typed in an expression language. We built this rule with the Code Effects libraries and evaluated it against ten test applications - fraud, under 18, unemployed with low income, DTI over 50%, prime with real estate, home loan without real estate, joint approval, broker, stale, and nothing matching - and each took the branch the policy says it should.
Side by Side

The schematics below are drawn in one neutral style from each vendor's public documentation, not taken as screenshots. The expression syntax in them is each product's own. Other modeling choices are possible in every product; they change the counts, not the kinds of artifacts. Click any image to open it full size.
DMN: Camunda, Trisotech, Apache KIE and Other Modelers

DMN expresses the conditions well. A decision table with the First hit policy gives first-match order, FEEL handles the arithmetic, the collection checks (some ... satisfies, count(Collateral[Value > 10000])) and dates (today() - duration("P18Y")), and the three reused rules become decisions, business knowledge models or decision services wired into the diagram. Three things move out of the table, though. The bureau score can't be fetched mid-decision, so the caller supplies it as input data. The combined conditions don't fit table cells as literals, so each branch becomes a FEEL expression in its own decision, and the table tests those booleans. And a DMN decision returns values only: flagging, notifying and emailing are BPMN service tasks in a process around the decision. One rule becomes a 12-node diagram, nine FEEL expressions, a six-row table and a BPMN process - four notations. See also Code Effects vs DMN.
GoRules and DecisionRules

Both products build this as a graph. In GoRules, a JavaScript function node calls the bureau, three decision nodes bring in the reused rules, an expression node derives the six branch conditions in ZEN (some(collateral, #.kind == "RealEstate" and #.value > 100000), d(applicant.birthDate).isAfter(d().sub(18, "y"))), a switch node picks the first branch that holds, six expression nodes set the outputs, and another function node performs the actions. A decision table with the First hit policy can replace the switch; its cells then hold the same expressions. GoRules can also show conditions as sentences in its Natural display mode, which is a true rendering of the expressions, but the graph, its wiring and the JavaScript are still built and read separately. DecisionRules builds the same structure as a Decision Flow: an API call node, rule nodes, a First Match decision table whose conditions are function cells (ARRAY_FILTER, PICK, DATEDIFF, COUNT), and API or integration nodes for the actions. See also Code Effects vs GoRules and Code Effects vs DecisionRules.
IBM ODM / ADS and FICO Blaze Advisor

These are the closest to Code Effects, and it's worth saying plainly. IBM's Business Action Language reads like English, and users don't type it from memory: the rule editor in Rule Designer and in Decision Center builds sentences from a completion menu of the vocabulary. In FICO Blaze Advisor, business users typically edit rules in the Rule Maintenance Application, web forms generated from templates a developer designs, while SRL is written in the developer IDE. The extra effort sits elsewhere. The completion menu offers only what a developer has verbalized in advance - "18 years before today" exists only once someone adds and verbalizes a helper for it. One decision becomes several rules whose order lives in priorities and the ruleflow task's exit criteria rather than in their text. A rule can't call another rule, so Prime borrower, DTI limit and Employment check become variables set by earlier rules, and Decision email becomes its own rule task. In Blaze, a template typically fixes the shape of a rule and users change its values; changing the shape goes back to the developer unless the template allows it.
Salesforce Business Rules Engine

In Expression Set Builder, the reused rules become Sub Expression elements, the arithmetic becomes Calculation elements (the DTI, the gap between the stated and the bureau score, the income multiples), and the six policies become one Branch. That uses every path a branch allows: six, including the default. Each path starts with a Condition element - rows of resource, operator and value joined by a custom-logic string such as 1 AND 2 AND 3 AND (4 OR 5) - followed by the steps that set its outputs. The rest happens in a Flow that calls the expression set: the bureau callout, a loop over the collateral to pass in the count and the real-estate flag, the age and days since submission, and the actions themselves. A seventh policy would need a nested branch or another expression set. On the other hand, Salesforce is native to the CRM data the decision usually needs, and it adds a Decision Explainer and effective-dated versions.
Drools and NRules

Both are code-first. In Drools, the rule is six DRL rules in one activation group, ordered by salience, with exists(... from $a.collateral) and accumulate(... count(1)) for the collections and Java helpers or inferred facts for the reused rules. Business Central, with its guided rule editor, was deprecated with Drools 8, so today's standard tooling is a text editor (and the DMN editor, for DMN). In NRules, each rule is a C# class; there are no activation groups, so priorities order the firing and a guard in every rule stops the rest. Both are readable to developers, reviewed as source code and shipped with the application build. See also Code Effects vs Drools and Code Effects vs NRules.
Reading the Whole Rule Before It Goes Live
Whoever releases a rule to production has to be able to read all of it - every branch, its order, what it calls and what it does - and see whether it says what the policy says. That is a different question from whether a tool can build the rule.
- Code Effects shows the complete IF / ELSE IF / ELSE chain, its actions and the names of the rules it calls, as one readable statement, in the standard editor and in the AI Rule Editor alike.
- DMN spreads it across the diagram, a FEEL expression in each decision, table rows whose order matters under the First hit policy, and the BPMN process. Reading it means opening each node.
- GoRules and DecisionRules show the layout of the graph on the canvas, not the logic; the conditions live inside each node and the actions in JavaScript or API nodes. GoRules' Natural mode turns individual conditions into sentences, not the graph.
- IBM ODM shows each action rule clearly, but this decision is six of them plus three that set variables; their order is in priorities and exit criteria that the rule text doesn't show. FICO Blaze is similar: rulesets and tables inside a decision flow, and in the RMA, template forms rather than the full logic.
- Salesforce keeps each path's logic in Condition rows behind custom-logic strings, with part of the decision in the calling Flow.
- Drools and NRules are one readable file or a set of classes - for developers.
Automated checks are a separate strength, and here several competitors are ahead in one area. IBM ODM and Blaze Advisor offer rule analysis, including overlap and gap checks on decision tables and trees; DMN modelers such as Trisotech validate diagrams and FEEL and analyze decision tables; GoRules runs static analysis on every graph as you edit and before every save; DecisionRules' Test Bench and Salesforce's simulation show which rows and branches ran. Those analyses work best on tables - logic inside a FEEL cell, a ZEN expression, a function cell or a JavaScript node is harder for any tool to reason about. Code Effects checks every rule against its source object as it is built: types, nullability, members a source version doesn't have, mixed AND / OR without parentheses, calls to rules that are no longer available, cycles between rules. Checks for overlapping and unreachable branches are coming in upcoming minor releases. Until then, the Rule Repository's tests, batch runs and Audit replays are where a branch that never fires shows up.
AI Agents: Who Builds It, Who Checks It
Most of these vendors now let AI build rules from a description:
- IBM Decision Intelligence's Decision Assistant generates a data model, a ruleflow and rules from policy text, first in natural language for review, then translated into IBM's rule language, and exports them to ODM.
- Camunda Copilot turns plain language into FEEL expressions, and other DMN vendors offer similar assistants.
- GoRules AI edits graphs and policies, simulates and explains, and the same tools are available to external agents through its MCP server.
- DecisionRules' AI Assistant generates decision tables, flows, function expressions and test data, with an authoring MCP.
- Salesforce positions the Business Rules Engine within its Agentforce industry solutions; we found no Salesforce documentation of an AI that authors expression sets.
- Drools and NRules are code, so general coding assistants write them.
Structural checking of what the AI produces isn't unique to Code Effects either: GoRules runs its static analysis as a pre-flight check on save, Trisotech won't execute a model with errors, and IBM's generated rules go through Decision Center like any other rule. What differs is what is checked and where the human comes in:
- One check for people and agents. In Code Effects an agent builds a rule through the same element model as the editor, and the server checks every save against the application's real source object - the same check a hand-built rule gets. Where a competitor checks types only when an input schema or data model exists, a Code Effects rule is always checked against the .NET type it will run on.
- Never live without a person. In the Rule Repository, every agent save is a request for approval; agents can't approve, go live, take a version offline or delete. See the MCP server.
- The text the person approves is the rule that runs. No tool can guarantee that a rule is logically right - in every product, including Code Effects, a person has to confirm the logic. In Code Effects that person reads the rule itself, the same plain-language text the engine compiles. In IBM's Decision Assistant, the natural-language rules are an AI-written description, and an AI translation sits between what was reviewed and what executes. In DMN, GoRules, DecisionRules, Salesforce, Drools and NRules, the reviewer reads the artifacts the agent built.
See also Code Effects vs AI-Assisted Rule Editors and AI-Powered Business Rules.
Who Can Sign Off on Production
The person who approves a rule should own the business logic. In most of these products, that person must also be fluent in the vendor's notation:
| Product |
What the approver must read |
| Code Effects |
The rule as plain language, in the names of your own data |
| DMN |
The decision requirements diagram, FEEL, decision tables and hit policies, and the BPMN around them |
| GoRules |
The graph, ZEN expressions and JavaScript |
| DecisionRules |
The flow, decision tables and the function language |
| IBM ODM / ADS |
Near-English rules (no code), plus priorities, exit criteria and ruleflows |
| FICO Blaze Advisor |
RMA templates, or SRL, plus the decision flow |
| Salesforce BRE |
Expression sets, condition rows and custom-logic strings, formulas, and the calling Flow |
| Drools, NRules |
DRL and Java, or C# |
DMN is a vendor-neutral standard, and that is a real advantage for portability. It is neutral across vendors, not across skill levels: a reviewer still has to read FEEL, the diagram and the hit policy. IBM is the honest exception on coding - BAL needs none - but the reviewer still has to understand how the rules are ordered and connected.
Where Each Competitor Genuinely Wins
- DMN is an open standard with many modelers and engines, so a model can move between vendors, and its decision table analysis (gaps, overlaps) is mature in tools such as Trisotech.
- GoRules has a free MIT-licensed engine that runs one decision file in Node.js, Python, Go, Rust, Java, Kotlin, C#, Swift and WebAssembly, with static analysis, Git-style branching and releases.
- DecisionRules is quick to start as a managed service, with an AI assistant, test bench, integrations and flows that call external systems.
- IBM ODM and FICO Blaze Advisor are long established at large banks and insurers, with near-English rules, mature governance, and rule analysis that checks tables and trees for gaps and overlaps; IBM adds an AI assistant that turns policy documents into ODM projects.
- Salesforce Business Rules Engine runs next to the CRM data most customer decisions need, with prebuilt industry templates, a Decision Explainer, effective-dated versions and bulkified calls from Flow.
- Drools is a free, mature Java engine with forward chaining and complex event processing; NRules is a free .NET Rete engine for developers who want rules in C#.
Where Code Effects Wins
For a rule of this size, Code Effects is the only one of these products where the whole decision - conditions, calculations, collections, dates, calls to other rules, order and actions - is one rule that a business owner can read top to bottom with no code, no diagram and no expression language. The live bureau call, the actions and the email rule are part of that rule, not a process around it. People and AI agents build rules through the same menus and the same server check against your own .NET objects, every agent change waits for a person's approval, and what that person approves is the rule that runs. It all lives inside your own .NET application and database, from the Rule Editor to the Rule Repository, Audit and the MCP server.
A Note on Method
The Code Effects rule above was built and evaluated with the Code Effects libraries. The other products' versions were drawn from their public documentation in November 2026 and were not run; the schematics are neutral and simplified, the counts reflect one reasonable way to model the rule in each product, and products change. Where documentation was thin - FICO Blaze Advisor's current RMA, and how Salesforce expression sets set text outputs - we say so. If you build this rule differently in any of these products, we'd like to hear about it.
FAQ
Can DMN express this rule?
Yes. A decision table with the First hit policy, FEEL expressions for the combined conditions, collections and dates, and decisions or business knowledge models for the reused rules cover the logic. The bureau score has to be supplied as input data, and the actions run in a BPMN process around the decision, because a DMN decision returns values only.
Do IBM ODM and FICO Blaze users have to type rule language?
No. IBM's rule editors build Business Action Language sentences from a completion menu of the vocabulary, and FICO Blaze Advisor's Rule Maintenance Application gives business users web forms generated from templates. The effort is in the vocabulary a developer prepares, and in reading several rules whose order is set by priorities and ruleflows.
How does Salesforce Business Rules Engine handle this rule?
As an expression set with sub expressions, calculations and a branch that uses all six of its allowed paths, called from a Flow that fetches the bureau score, loops over the collateral, computes dates and performs the actions.
Which products check rules for gaps and overlaps?
IBM ODM and FICO Blaze Advisor offer rule analysis, DMN modelers such as Trisotech analyze decision tables, and GoRules runs static analysis on save. Code Effects checks every rule against its source object as it is built; checks for overlapping and unreachable branches are coming in upcoming minor releases.
Can AI agents build this rule?
In most of these products, yes, through their AI assistants or MCP servers. In Code Effects, an agent's rule is checked against your source object by the same server check as a person's, every agent save waits for a person's approval, and the person reads the rule itself as plain language.
Is the Code Effects rule shown here real?
Yes. It was built against the loan application source object of the Rule Repository online demo and evaluated against ten applications, each taking the branch the policy expects.