Which open-source DMN decision engine fits your Java stack?
If you are building new DMN decision logic into Java applications, the short answer depends on where your code and governance need to sit. Drools, delivered through Apache KIE, suits a team that wants Apache-governed code and is comfortable with a project still in incubation. Flowable suits a new build that wants a compact, actively released engine that pairs with its BPMN engine. An existing Camunda 7 estate usually points to a migration path, since Camunda 7 Community Edition no longer receives releases or security patches. All three engines are Apache-2.0 licensed in their open-source form, and the Camunda 7 Enterprise Edition is the commercial exception. Because DMN feature coverage overlaps heavily, the decision should turn mainly on maintenance status, release cadence and who will patch the engine in three to five years.
Start by writing down which DMN version your decision tables must conform to and which Java framework your applications already run on. Apache KIE 10.2.0 added DMN 1.6 support and Java 21 support, and Flowable 8.0.0 moved to Spring Framework 7 and Spring Boot 4 with no backward compatibility for Spring Boot 3. Those framework dates can force an upgrade before you ever touch the rules. Confirm the exact DMN level and Java baseline each engine supports for your target runtime, using the release notes and your own proof-of-concept rather than assumptions.
Next, decide how tightly the decision engine must integrate with a process engine. If your processes already run on Flowable or Camunda 7, the Flowable DMN engine and the Camunda 7 DMN engine share the same modeling family as their BPMN engines, which reduces integration work. Drools is a separate rules engine that you would wire to a BPMN engine such as jBPM or Flowable through your own service layer. Ask each vendor or project which BPMN engine it pairs with in production, and test a decision call inside a real process instance, including timeouts and retries, before you commit.
Which DMN decision engine fits which scenario
This table maps five common situations to the DMN engine that fits best, along with the condition that makes each choice hold and what to confirm before committing. Read it as a starting point: the best fit depends on your Java stack, your existing BPMN engine and the DMN version your target release supports.
| Scenario | Best fit | Why, and what to confirm |
|---|---|---|
| New Java build with BPMN in the same stack | Flowable DMN engine | Flowable's BPMN, CMMN and DMN engines are Apache-2.0 and share one embeddable design, so decisions and processes run in one runtime. Confirm the DMN version supported in the Flowable release you plan to use, and check that your database type is on its supported list. |
| Existing Camunda 7 estate | Camunda 7 DMN engine on a supported path, or a planned migration | Camunda 7 Community Edition stopped receiving releases and security patches after 7.24, so long-term support depends on the Enterprise Edition or a migration. Confirm the Enterprise end of life date and extended support terms with Camunda before planning. |
| Spring Boot team with its own process engine | Flowable DMN engine via Spring Boot starters | Flowable publishes starters for the DMN engine and supports Spring Boot 4.x in version 8.0.0, which dropped Spring Boot 3. Holds only if you can move to Spring Boot 4. Confirm the Spring Framework and Spring Boot versions your code must run on. |
| Team that wants Apache Software Foundation governance | Drools in Apache KIE | Apache KIE is under the Apache License 2.0 but is still in incubation, which the project says does not reflect code completeness or stability. Holds if you accept incubator status. Confirm the DMN 1.6 and Java 21 support in the release you pin. |
| Team that needs a commercial vendor path | Flowable commercial platform or Camunda 8 with a commercial license | Flowable sells commercial products built on the same engines, with professional services offered separately. Camunda 8 needs a commercial license for production use under the Camunda License 1.0. Confirm which DMN engine each vendor supports and the support terms in writing. |
What DMN version support means for your decision models
The DMN version an engine reads and executes decides whether your existing decision models import unchanged. DMN has several published versions, and a model authored against one version may use elements that another engine does not parse or evaluate the same way. Before you pick an engine for decision tables you already maintain, export a representative sample from your current authoring tool, check which DMN version it declares, and load that sample into a test instance of each candidate engine. Treat a clean import as the minimum bar, and compare the evaluation results for a set of known inputs as the real test.
Apache KIE shows the tooling side of this risk. Its 10.2.0 release introduced a new BPMN editor to replace the legacy GWT-based tooling, removed the classic BPMN and DMN editors, and added DMN 1.6 support alongside Java 21 support. If your team authors decisions in the classic Drools editors, plan for a tooling change as well as a version check: decide whether models will be edited in a newer editor, converted by hand, or kept as files and maintained outside the editor. Confirm the editor path in the Apache KIE 10.2.0 release post before you commit to a migration date.
This research does not confirm which DMN versions the Flowable DMN engine or the Camunda 7 DMN engine support. Do not assume either one matches the Drools or DMN 1.6 behavior. Ask each vendor or project for the supported DMN versions for the exact release you plan to run, and test your sample models against that release. Record any element that fails to import or evaluates differently, because those gaps determine whether you need model rewrites, a translation step or a longer parallel run during migration.
How each engine embeds in a Java application
The Flowable DMN engine is designed to be embedded in a Java application or run as a service. It can be added as a JAR to Java SE applications, to servlet containers such as Tomcat or Jetty, to Spring applications and to Java EE servers, or it can be used over HTTP through the Flowable REST application. The Spring Boot docs describe starters for all engines, for REST, and for the individual process, CMMN and DMN engines, with support for Spring Boot 4.x. Flowable 8.0.0, released on February 27, 2026, is based on Spring Framework 7 and Spring Boot 4 and drops Spring Boot 3 support, so teams on Spring Boot 3 need a planned upgrade before adopting it.
- Packaging options: Embed the engine as a JAR in a Java SE process, a servlet container, a Spring application or a Java EE server, or call it through the REST application.
- DMN starter: Use the Spring Boot starter for the DMN engine when only decision tables are needed, and the starter for all engines when BPMN and DMN share a process.
- Monitoring endpoint: The actuator endpoint at
/actuator/flowableexposes running process information for monitoring. - Identity hooks: Identity management can be replaced by overriding the IDM identity service implementation or implementing the IdmIdentityService interface, with an LDAP reference implementation provided.
- Version coupling: Flowable 8.0.0 requires Spring Boot 4, so the Spring Boot major version in your application sets the Flowable line you can use.
Before you commit, confirm with Flowable which starter and Spring Boot version combination your application's dependency tree needs, and whether the DMN engine's embedded deployment is supported in your servlet container or Java EE server version.
The Camunda 7 engine is a Java framework that supports BPMN, CMMN and DMN, and it persists process state to a relational database through MyBatis. According to the Camunda 7 documentation, the engine can run embedded in a Java application, as a shared engine or standalone. The distribution also ships REST APIs and the Tasklist, Cockpit and Admin web applications. Camunda's final feature release, 7.24, was scheduled for October 14, 2025, and no further releases or security patches are made for the Community Edition after that. Enterprise Edition support is longer, with end of life extended to April 9, 2030.
- Embedded mode: The engine runs inside the application process and shares its transaction and lifecycle.
- Shared mode: One engine serves several applications, which can reduce duplicated configuration but couples their deployments.
- Standalone mode: The engine runs as its own service, reached through the REST APIs.
- Web applications: Tasklist, Cockpit and Admin ship with the platform for task work, operations and administration.
- Repository status: The camunda-bpm-platform repository is archived with 7.24.0 as its last tag, so community patches depend on the fork or vendor you choose.
Confirm which 7.x line your DMN decision tables run on, whether your Java version and application server are covered by that line, and who will provide security patches after the Community Edition stopped receiving releases.
Drools is the rules engine within Apache KIE, the home of Drools, jBPM, Kogito and related tools under the Apache License 2.0. Apache KIE is still in incubation at the Apache Software Foundation, which the project notes does not by itself reflect how complete or stable the code is. Apache KIE 10.0.0 was the first major release under the ASF, with upgrades to Java 17, Jakarta 10, Quarkus and Spring Boot. Kogito was a cloud-native business automation technology, and its Runtimes and Apps repositories are now archived, with their code moved into the apache/incubator-kie-drools repository. Apache KIE is Java-focused, so the embedding path runs through Java build tooling and the framework versions each release sets.
- Java focus: The project is built around Java applications, so the embedding model follows Java packaging and dependency management.
- Kogito archival: Kogito code now lives in the apache/incubator-kie-drools repository, so update any dependency or build reference that still points to the archived repositories.
- Java and framework versions: Apache KIE 10.2.0 added Java 21 support and moved to Quarkus 3.27.2 and Spring Boot 3.5.10, so check the Java, Quarkus or Spring Boot versions for the release you adopt.
- Release cadence: Tags for 10.0.0, 10.1.0 and 10.2.0 were issued on December 11, 2024, July 8, 2025 and April 28, 2026, which helps you plan upgrades.
- Tooling change: Apache KIE 10.2.0 replaced the legacy GWT-based BPMN tooling and removed the classic BPMN and DMN editors, so existing authoring workflows may need review.
Confirm the exact Java, Quarkus or Spring Boot combination your release supports, and whether your target runtime is covered by the project's documentation, since the supplied facts do not describe every embedding option.
Capability across the three DMN engines
This table sets Drools in Apache KIE, the Camunda 7 DMN engine and the Flowable DMN engine side by side on license, project status, release activity, standards support, APIs, Spring integration, databases, BPMN pairing and migration. Where the researched facts do not settle a cell, it says confirm with vendor, so treat those cells as questions for your shortlist. The main takeaway is that Camunda 7 Community Edition no longer receives releases or security patches, which affects every row for teams already running it.
| Capability | Drools in Apache KIE | Camunda 7 DMN engine | Flowable DMN engine |
|---|---|---|---|
| License | Apache-2.0 | Apache-2.0 (repository archived) | Apache-2.0 |
| Project status | Incubating at the Apache Software Foundation | Community Edition ended after 7.24; repository archived | Actively released open-source engines |
| Latest supplied release | Apache KIE 10.2.0, April 28, 2026 | 7.24.0, final Community Edition feature release | Flowable 8.0.0, February 27, 2026 |
| DMN version support | DMN 1.6 added in Apache KIE 10.2.0 | Confirm with vendor | Confirm with vendor |
| Java and REST APIs | Confirm with vendor | Java engine and REST APIs provided | Java and REST APIs provided |
| Spring Boot integration | Apache KIE 10.2.0 uses Spring Boot 3.5.10; confirm with vendor for other versions | Confirm with vendor | Starters for DMN engine; Spring Boot 4.x supported in 8.0.0 |
| Supported databases | Confirm with vendor | Relational database via MyBatis; confirm the list with vendor | H2, MySQL, Oracle, PostgreSQL, DB2, Microsoft SQL Server |
| BPMN pairing | jBPM in the same Apache KIE home | Native pairing with the Camunda 7 BPMN engine | Same product family as the Flowable BPMN engine |
| Migration path | Confirm with vendor | Camunda 8 migration tools, including the Diagram Converter for DMN files | Reported in-place migration from Camunda 7 in a 2022 Flowable post; confirm scope |
Three DMN engines in brief, with license and status
Each of these three engines executes DMN decision tables and literals and can sit beside a BPMN engine, but their licenses and maintenance signals differ enough to change the decision. Read each card for the license, the current status and the condition under which the option suits a team.
Drools in Apache KIE
Drools is the rules and decision project within Apache KIE, licensed under Apache License 2.0 and still in incubation at the Apache Software Foundation. Incubation does not by itself mean the code is complete or stable. Apache KIE 10.2.0 added DMN 1.6 support and Java 21 support, and the project is moving forward under the ASF. This option suits a Java team that wants an open-source rules engine under a foundation's governance and is comfortable with an incubating project. Verify the release line and incubation exit plan before committing.
Camunda 7 DMN engine
The DMN engine ships with Camunda 7, the Java framework for BPMN, CMMN and DMN, and the Community Edition is licensed under Apache-2.0. The camunda-bpm-platform repository is archived, and 7.24.0 is its last tag, so the Community Edition receives no further releases or security patches. The Enterprise Edition is a commercial product with its end of life extended to April 9, 2030. This option suits a team that already runs Camunda 7 and needs a supported path, either a paid Enterprise subscription or a planned migration. Confirm whether your Camunda 7 deployment will be patched by the vendor or by you.
Flowable DMN engine
The Flowable open-source engines support BPMN, CMMN and DMN and are licensed under Apache-2.0. They run embedded in a Java application or as a service and expose Java and REST APIs. Flowable 8.0.0 was released on February 27, 2026 and is based on Spring Framework 7 and Spring Boot 4, so teams on Spring Boot 3 must plan an upgrade. Commercial products such as Flowable Work and Orchestrate are built on the same engines and sold separately. This option suits a team that wants an actively released Apache-2.0 DMN engine next to a BPMN engine. Check your Spring Boot version against the 8.0.0 requirement before choosing it.
What Camunda 7 end of life means for DMN users on Camunda 7
If your DMN decision tables run on the Camunda 7 engine, the key fact is that Camunda 7 Community Edition no longer gets releases or security patches. Camunda's final Community feature release, 7.24, was scheduled for October 14, 2025, and the camunda-bpm-platform repository is archived with 7.24.0 as its last tag. Enterprise customers have more time: Camunda 7 Enterprise Edition end of life was extended to April 9, 2030, with 7.24 as a long-term support release that receives updates in April and October, and paid extended support available from April 2030 through April 2032. Confirm which edition and version your DMN decisions run on, and whether your contract covers the extended support window, before you set a migration deadline.
Camunda's migration path for DMN is the Diagram Converter, which analyzes Camunda 7 BPMN, DMN and form files, lists migration tasks and converts them to the Camunda 8 format. Camunda 8 is a different engine with its own licensing, so this path changes your decision runtime, not only your files. Before choosing it, confirm with Camunda how DMN files that use Camunda 7 specific expressions or features convert, and test the converted tables against a representative set of inputs. Also confirm the Camunda License 1.0 terms for Camunda 8 production use, because that license limits production use and requires a commercial license from Camunda.
Flowable has said publicly that Camunda 7 and Activiti data can be migrated to Flowable in place, including active process instances and history, a claim made in its September 7, 2022 engineering blog post. Treat that as Flowable's statement, not an independent test. Flowable also offers the free Flowable LEAP tool to report ahead of time what a migration would involve. If you keep DMN decisions in a Java engine, ask Flowable to confirm DMN file compatibility and the migration steps for your exact Camunda 7 version, and run a rehearsal on a copy of your database before committing to either path.
How to choose and pilot a DMN engine
This sequence moves a team from its existing decision assets to a tested choice between Drools in Apache KIE, the Camunda 7 DMN engine and the Flowable DMN engine. Each step ends with a written output that the next step relies on.
Inventory existing DMN files and versions
Business analysts and the team that owns current decision models list every DMN file, the modeling tool that produced it and the DMN version declared in each file. Include decision tables stored in source control, decisions embedded in BPMN service tasks and any decisions maintained outside the engine. The step is done when the inventory shows which DMN version each file uses, which files use vendor-specific extensions and how many decisions depend on each one. Confirm each candidate engine's DMN version support with its vendor or project documentation before you rely on it, since the version coverage differs across the three options.
Confirm the BPMN engine pairing
The solution architect and the process owners state which BPMN engine will call the decisions, and whether that engine is the same vendor's stack as the DMN engine. Map each business task that invokes a decision, including whether the call is synchronous, uses a REST endpoint or runs inside an embedded process. The step is complete when the pairing is written down for each candidate, such as Flowable DMN with the Flowable BPMN engine or Camunda 7 DMN with the Camunda 7 process engine, and the team has noted any call pattern that would need a custom adapter. Confirm with each project how it expects BPMN and DMN to be deployed together.
Check the target runtime and database
The platform engineering lead records the Java version, Spring Boot version, application server and relational database the decision service must run on, then compares those against each engine's documented requirements. Pay attention to the current Flowable 8.0.0 line, which is based on Spring Framework 7 and Spring Boot 4 and drops Spring Boot 3 support, and to Apache KIE 10.2.0, which added Java 21 support. The step is done when a compatibility table lists each candidate, its required runtime and any upgrade your own applications would need. Also confirm which databases the engine supports, since the Flowable configuration documentation lists a specific set.
Confirm the license and production support path
The legal or procurement lead, with the engineering owner, reviews the license of each engine and the support route for production use. Flowable's open-source engines are Apache-2.0 licensed and sold alongside a separate commercial platform. Camunda 7 Community Edition no longer receives releases or security patches after its final feature release, so the team should check the Enterprise Edition terms and end-of-life dates directly with Camunda. Apache KIE is Apache-2.0 licensed but still in incubation at the Apache Software Foundation. The step is done when the team has a written decision on which support path it accepts, and when it has asked each vendor for its security patch commitments and support windows in writing.
Run a pilot decision table with your own test cases
A decision owner and a QA engineer select one representative decision table, ideally one with hit policies, nested inputs and a known error case, and deploy it to the shortlisted engine. They write test cases from the business rules, including boundary values and the expected output for each rule, then run them through the same BPMN call path that production will use. The step is complete when every test case passes or has a documented, agreed deviation, and when the results are archived with the DMN file version and engine version used. Repeat the pilot on each finalist engine so that the comparison rests on the team's own decisions rather than on feature lists.
Record migration and upgrade steps
The engineering lead and the architect document how the chosen engine will be installed, configured, upgraded and rolled back. Include the steps to convert or re-model any DMN files that the pilot flagged, the database schema changes that come with each upgrade, and the test suite that must pass before a new engine release is accepted. For Camunda 7 candidates, include the migration tooling and the Camunda 7 to Camunda 8 path as a fallback question, and for Flowable, note the migration guidance the vendor has published for Camunda 7 and Activiti data. The step is done when the runbook is stored with the decision assets, and the owner has signed it off for the next engine release.
What do buyers ask before hiring help with a DMN engine?
Can our own Java team run a DMN engine without outside help?
Often yes, if your team already runs Java services and a relational database, because the Flowable and Camunda 7 DMN engines are embedded libraries and Drools runs inside Java applications. The work that usually needs experienced hands is not the first install but the decision model design, testing, upgrades and the integration with your BPMN engine. Confirm your team's Java version and framework (Spring Boot or Jakarta EE), whether someone has run a production upgrade, and who will own the models after go-live.
What drives the implementation effort for a DMN engine?
Effort rises with the number of decision models, how many of them are tied to live processes, and how many systems send them inputs or receive outputs. The main drivers are:
- Java and framework skills in your team, including the Spring Boot generation you run
- Decision table complexity and the number of hit policies and test cases to prove
- Integration points with case data, identity, auditing and your BPMN engine
- Database choice and clustering requirements for the engine's async jobs
Ask any provider to break the estimate down by these items.
Which DMN engine costs are one-time and which recur?
One-time costs usually cover design, build, integration, testing and documentation of the decision models and their hosting. Recurring costs cover your team's time for upgrades, security patches, model changes and monitoring, and any paid support or commercial platform you choose. Open-source licenses carry no license fee for Flowable's Apache-2.0 engines or Drools in Apache KIE, but Camunda 7's Enterprise Edition is a paid product with its own support windows. Ask any quote to separate these categories explicitly.
What does a fixed-scope DMN engagement usually cover?
A fixed-scope engagement is agreed in writing before work starts and typically lists the decision models, the hosting environment, the integrations, the test approach and the handover documents. DeployOpen plans, implements, integrates, hardens, documents and supports self-hosted platforms inside your own infrastructure, and a quote follows from that written scope. It does not issue audit reports or certifications. Ask for the list of excluded items, such as model authoring by business users or ongoing support, and for the acceptance criteria.
How does moving from Camunda 7 affect our existing DMN files?
DMN files are standard XML, so a Flowable or Drools move starts from the same model files, but the engine's behavior, expression language and extensions may differ and need testing. Camunda's Diagram Converter for Camunda 8 analyzes Camunda 7 BPMN, DMN and form files, which is useful as a reference even if you leave Camunda. Flowable has said Camunda 7 data can be migrated in place for its own engine, so check the current migration guide against your Camunda 7 version. Confirm the count of files, custom expressions and any Camunda-specific extensions before you estimate the work.
Does Apache incubation affect production use of Drools?
Incubation does not automatically make Drools unsuitable for production, but it means the Apache Software Foundation has not yet fully endorsed the project, and the Apache KIE site notes that incubation does not necessarily reflect the completeness or stability of the code. Check the current release line, your version's support window, the license (Apache 2.0) and the test coverage for the DMN version you need. Apache KIE 10.2.0 added DMN 1.6 support and Java 21 support, so confirm those against your requirements. Your risk team should decide how much weight incubation carries for your environment.
Which support windows should we check before choosing a DMN engine?
Support windows decide how long you can stay on a given line without a forced upgrade. Flowable 8.0.0 was released on February 27, 2026 on Spring Framework 7 and Spring Boot 4, and it dropped Spring Boot 3 support, so teams on Spring Boot 3 face a migration. Camunda 7 Community Edition stopped receiving releases and security patches after 7.24, while Camunda 7 Enterprise Edition end of life was extended to April 9, 2030. Ask each vendor or maintainer for the current end-of-life dates and the patch policy for the version you will deploy.
How DeployOpen scopes DMN engine selection and implementation
DeployOpen approaches DMN engine selection as a written, fixed-scope engagement inside your own infrastructure. We plan, implement, integrate and document the chosen engine, whether it is Drools in Apache KIE, the Camunda 7 DMN engine or the Flowable DMN engine, and we prepare the handover so your team can run it.
How we scope
- We agree the decision use cases, DMN files and the BPMN engine they must pair with before any build starts.
- Scope, deliverables and timelines are set out in writing, so the engine choice is tested against your real constraints.
- We confirm the target runtime, Java version, database and identity source in your own environment before recommending a path.
How we build
- We implement the selected engine embedded in your Java applications or as a service, inside your cloud accounts, data centers or air-gapped networks.
- We integrate decision tables with your BPMN processes and REST or Java APIs, and test rule changes against agreed sample inputs.
- We harden the deployment and set up backups and upgrade procedures alongside the decision logic.
How we hand over
- We document the DMN model inventory, engine configuration, integration points and the upgrade path your team will follow.
- We walk your engineers through running, testing and changing decision models, so the knowledge stays with your organization.
- We prepare evidence and configuration records that your internal or external assessors can review.
How we support
- Ongoing support, upgrades and continuous testing are available as a retainer after handover.
- Retainers can cover engine version upgrades, such as tracking the release lines your chosen engine ships, under a written agreement.
- Ask us to confirm the support window and upgrade scope for your chosen engine version before signing any retainer.
