Business Rules and Decision Modeling
Business rules and decision modeling is the practice of writing down the policies an organization uses to make repeatable operational decisions, such as eligibility, pricing, or routing, in a precise and testable form. Decision Model and Notation (DMN), an OMG standard, supplies diagrams, decision tables, and an expression language so the same model can be reviewed by business experts and executed by software.
itEngineering leadership and delivery management | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic: Business Rules and Decision Modeling
Somewhere in every organization, a policy decides who qualifies, what things cost, and which team gets the awkward case. Those policies are business rules, and they tend to end up buried in application code, where only developers can read them and every change waits for a release. Decision modeling is the practice of digging them back out and giving each decision a name, a list of inputs, visible logic, and a defined answer.
The standard that makes this shareable is DMN, short for Decision Model and Notation, from the Object Management Group, the same people who brought you BPMN. It works at two levels. The top level is a diagram of which decisions exist and what each depends on. The bottom level is the actual logic, spelled out precisely enough for a machine to run.
The diagram has a small cast. A decision is a rectangle. Input data, the facts arriving from outside, is an oval. Reusable logic, called a business knowledge model, is a rectangle with two corners clipped off, as though someone took scissors to it. A knowledge source, meaning the regulation or policy owner who gets the final say, has one wavy edge. Follow the lines from a knowledge source and you find every decision a policy change will touch, which is the kind of question nobody can answer from a pile of code.
Most of the logic lives in a decision table. Each row is a rule, each input column holds a test such as < 18 or [600..750], and a dash means "this input does not matter here". The table is best understood as a map from every possible input to an answer, and nearly all the real work is inspecting that map for holes.
The holes are where it gets interesting. When no rule matches, the table does not complain. It returns null, and a caller that ignores null makes a wrong decision with total confidence. When several rules match, a single letter called the hit policy decides the outcome. Unique, the default, forbids overlaps outright. Priority lets an exception beat a general rule. First takes whichever matching row comes earliest, which means shuffling rows changes answers, and the standard itself frowns on it.
The surprise for most newcomers is that the notation is the smaller half. The hard half is getting two experts to agree whether "orders over 100" includes 100, because every boundary in a table forces a choice the written policy may never have made.
There is an older way to run rules, too. Engines such as Drools fire when-then rules over facts in working memory, and one rule can change a fact that sets off another. That is expressive, and also how rule bases become puzzles. DMN decision services are stateless: same inputs, same outputs, every time.
Start with the Slides for the overall map, then keep the Cheatsheet open for hit policies and table syntax. The Field Notes cover what goes wrong in practice, and the Exercise has you build a shipping-fee table and break it on purpose.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://www.omg.org/spec/DMN/1.6/PDF
Supports
- DMN scope, the two modeling levels, and independence from BPMN
- DRD elements, shapes, and requirement connectors
- Decision table anatomy, unary tests, overlap, completeness, and default output
- Hit policies, collect operators, and the guidance against First tables
- FEEL, S-FEEL, ternary logic, lists, contexts, and durations
- Conformance levels 1 to 3
- Decision services, encapsulation, and statelessness
- Generalized unary tests introduced in DMN 1.2
- Version 1.4 and 1.5 development periods
- PRR named as an existing decision logic format
- XML interchange as a goal of DMN
- https://www.omg.org/spec/DMN/
Supports
- DMN version list and publication dates
- Update source for new DMN versions
- https://www.omg.org/spec/DMN/1.6/
Supports
- DMN 1.6 as the current formal version
- https://www.omg.org/spec/DMN/1.0/
Supports
- DMN 1.0 publication, September 2015
- https://www.omg.org/spec/DMN/1.1/
Supports
- DMN 1.1 publication, June 2016
- https://www.omg.org/spec/DMN/1.2/
Supports
- DMN 1.2 publication, January 2019
- https://www.omg.org/spec/DMN/1.5/
Supports
- DMN 1.5 publication, August 2024
- https://www.omg.org/dmn/
Supports
- DMN as a readable notation designed to work alongside BPMN and CMMN
- https://www.businessrulesgroup.org/brmanifesto.htm
Supports
- Business Rules Manifesto version 2.0, November 2003
- Rules separate from processes, declarative, exceptions as rules, cost of rules
- https://www.omg.org/spec/SBVR/
Supports
- SBVR purpose, current version 1.5, and version history including 1.0 in January 2008
- https://www.omg.org/spec/SBVR/1.5/PDF
Supports
- Behavioral and definitional rule categories
- https://www.omg.org/spec/SBVR/1.5/
Supports
- SBVR 1.5 specification landing page
- https://www.omg.org/spec/SBVR/1.0/
Supports
- SBVR 1.0 publication
- https://www.omg.org/spec/PRR/1.0/
Supports
- Production Rule Representation 1.0, December 2009
- https://www.omg.org/spec/BPMN/2.0.2/
Supports
- BPMN 2.0.2 as the current BPMN version
- https://doi.org/10.1016/0004-3702(82)90020-0
Supports
- Forgy, Rete algorithm, Artificial Intelligence volume 19, September 1982
- https://jcp.org/en/jsr/detail?id=94
Supports
- JSR 94 Java Rule Engine API final release, August 2004
- https://incubator.apache.org/projects/kie.html
Supports
- KIE entered Apache incubation on 2023-01-13
- https://kie.apache.org/docs/10.2.x/drools/drools/introduction/index.html
Supports
- Drools provides forward- and backward-chaining rule engine and DMN decisions engine
- https://kie.apache.org/docs/10.2.x/drools/drools/rule-engine/index.html
Supports
- Facts, production memory, working memory, agenda, pattern matching
- Forward and backward chaining definitions
- Salience default 0 and agenda groups
- Stateless and stateful KIE sessions
- https://kie.apache.org/docs/10.2.x/drools/drools/DMN/index.html
Supports
- Drools summary of DMN and the three conformance levels
- https://dmn-tck.github.io/tck/
Supports
- Shared DMN conformance test suite and differing engine results
- https://camunda.com/dmn/
Supports
- Tutorial content and its basis on DMN 1.1
- https://martinfowler.com/bliki/RulesEngine.html
Supports
- Implicit program flow and chaining risks in rules engines
- Business users writing rules rarely works out in practice
- Heuristics to limit rules, limit chaining, and test with production data
- https://www.methodandstyle.com/blog/decision-table-hit-policy-explained/
Supports
- Priority tables recommended over First tables
- Misleading rules in Priority tables
- Trisotech decision table analysis for gaps, subsumption, and hit policy errors
- https://github.com/sindresorhus/awesome
Supports
- Discovery index for curated lists
- https://github.com/bpm-crafters/awesome-bpm-tools
Supports
- dmn-js, Camunda Modeler, camunda-dmn-xlsx, and bpmn-to-image listings
- https://github.com/DigitalState/awesome-camunda
Supports
- dmn-check listing
- https://github.com/avelino/awesome-go
Supports
- RuleGo listing
- https://github.com/rust-unofficial/awesome-rust
Supports
- datalogic-rs listing
- https://bpmn.io/toolkit/dmn-js/
Supports
- Browser viewer and editor for DMN diagrams
- https://camunda.com/platform/modeler/
Supports
- Desktop modeler for BPMN, DMN, and forms
- https://github.com/red6/dmn-check
Supports
- Static analysis of DMN files for duplicate, conflicting, and shadowed rules
- https://github.com/camunda-community-hub/camunda-dmn-xlsx
Supports
- Spreadsheet to DMN decision table conversion
- https://github.com/bpmn-io/bpmn-to-image
Supports
- Command-line diagram rendering to images and PDF
- https://github.com/GoPlasmatic/datalogic-rs
Supports
- JSONLogic rules engine with Rust core and language bindings
- https://github.com/rulego/rulego
Supports
- Embedded Go rule engine with rule chains
- https://www.drools.org/
Supports
- Drools product homepage (redirects to Apache KIE)
- https://camunda.com/platform/decision-engine/
Supports
- DMN decision tables, FEEL literal expressions, history of triggered rules, Java API
- https://github.com/goldmansachs/jdmn
Supports
- Java implementation of DMN, Apache 2.0 license
- https://gorules.io/
Supports
- Business rules platform with versioning, environments, and approval flows
- https://github.com/gorules/zen
Supports
- MIT-licensed embeddable rules engine
- https://www.ibm.com/products/operational-decision-manager
Supports
- Rules-based decision automation with testing and simulation
- https://www.progress.com/corticon
Supports
- Visual rule modeling, scenario testing, decision services through standard APIs
- https://inrule.com/
Supports
- Decision automation for regulated industries with rule authoring, testing, and deployment
- https://www.sparklinglogic.com/
Supports
- SMARTS decision manager with rule authoring, predictive model import, dashboards, and simulations
- https://www.trisotech.com/
Supports
- Platform built on DMN, BPMN, and CMMN standards
- https://www.flowable.com/
Supports
- Apache 2.0 licensed BPMN, CMMN, and DMN engines in Java
