DMN Engine Comparison: QuantumBPM vs Camunda, Drools and jDMN
If you only need a DMN engine and not a full BPMN platform, the relevant comparisons are with Camunda DMN (the DMN-Scala engine in Camunda 7, also embedded in Camunda 8), Drools, and jDMN. This page covers that scope.
QuantumBPM is the only one of the four written in native Go rather than running on the JVM, and the only one that ships execution history, simulation and a FEEL language server as part of the product rather than as something you assemble yourself.
Evaluating a full BPMN and DMN platform instead? See the Camunda alternative comparison.
Core Capabilities
| Feature | QuantumBPM | Camunda | Drools | jDMN |
|---|---|---|---|---|
| DMN 1.5 Support | Yes | Yes | Yes | Yes |
| Conformance Level 3 | Yes | Yes[1] | Yes[2] | Yes[3] |
| FEEL Support | Full | Partial | Full | Full |
| Decision Tables | Yes | Partial | Yes | Yes |
| Boxed Expressions | Yes | Partial | Yes | Yes |
| Business Knowledge Models | Yes | Partial | Yes | Yes |
| Decision Services | Yes | No | Yes | Yes |
What Makes QuantumBPM Different
| Feature | QuantumBPM | Camunda | Drools | jDMN |
|---|---|---|---|---|
| Built-in Execution History | Native | External* | External* | No |
| Real-time Simulation | Yes | No | No | No |
| In-flight Impact Analysis | Yes | No | No | No |
*Requires external data stores and pre-processing
Developer Experience
| Feature | QuantumBPM | Camunda | Drools | jDMN |
|---|---|---|---|---|
| FEEL Language Server | Yes | Modeler Only | No | No |
| Autocompletion | Yes | Partial | No | No |
| Hover Documentation | Yes | Partial | No | No |
| Semantic Highlighting | Yes | Partial | No | No |
| Visual Modeler | Web-based | Desktop + Web[4] | Web[5] | No |
| Live Evaluation Preview | Yes | No | No | No |
Runtime & Performance
| Feature | QuantumBPM | Camunda | Drools | jDMN |
|---|---|---|---|---|
| Runtime | Go Native | JVM | JVM | JVM |
| Cold Start | ~5ms | ~10s+ | ~1s+ | ~200ms |
| Memory Footprint | ~10MB-50MB | ~100MB-~8GB with full platform[6] | ~150MB+ | ~50MB |
| Containerization | Optimized | Heavy | Heavy | Medium |
| Serverless Ready | Yes | Challenging[7] | Challenging[8] | Partial |
Deployment & Operations
| Feature | QuantumBPM | Camunda | Drools | jDMN |
|---|---|---|---|---|
| SaaS Offering | Yes | Yes[9] | No | No |
| Self-hosted | Yes | Yes | Yes | Yes |
| Git Integration | Planned | Enterprise | No | No |
| Multi-tenancy | Native | Enterprise | Manual | No |
| Audit Trails (Why a decision was made) | Native Graphical | Yes | Custom Dev Required | No |
| OpenTelemetry | Yes | Yes | Manual | No |
SDK Support
| Language | QuantumBPM | Camunda | Drools | jDMN |
|---|---|---|---|---|
| Go | Yes | Deprecated[10] | No | No |
| Java | Yes | Native | Native | Native |
| JavaScript/TypeScript | Yes | Yes[11] | No | Yes[12] |
| Python | Yes | Yes[13] | No | No |
TCK Compliance Details
| Engine | TCK Tests Passed | Total Tests | Compliance % |
|---|---|---|---|
| QuantumBPM | 3367 | 3390 | 99.32% |
| Camunda DMN-Scala 1.9.0 | 2850 | 3390 | 84.07%[1] |
| Camunda Platform 7.21.0 | 2741 | 3390 | 80.86%[14] |
| jDMN 9.0.0 | 3390 | 3390 | 100%[3] |
QuantumBPM's 23 failing tests are deliberate exclusions. We do not plan to support:
- External Java function calls - QuantumBPM is written in Go and does not include a JVM
- Regex backreferences - Go's RE2 regex engine does not support backreferences for performance and security reasons
- Unrealistic date ranges - Dates like
999999999-12-31exceed Go's time package limits and have no practical use
The Quant Advantage Explained
Built-in Execution History
Traditional DMN engines are stateless. They evaluate inputs and return outputs without any built-in persistence, so audit trails require custom logging infrastructure.
QuantumBPM stores every evaluation with full context:
- Complete input/output snapshot per execution
- Queryable history for compliance and debugging
Native Performance vs. JVM Overhead
Traditional engines like Drools run on the JVM, leading to slow "cold starts" and massive memory consumption (often hundreds of megabytes just for a basic knowledge base). This makes them poorly suited for modern, serverless, or highly-containerized architectures.
QuantumBPM is written in 100% native Go:
- Sub-millisecond decision evaluation
- Lightweight memory footprint (~10MB-50MB)
- Instant startup times, making it perfect for serverless infrastructure.
Complete Auditability
When managing business rules, knowing what was decided is only half the battle; you need to know why it was decided. Tools like Drools require significant custom development to trace the declarative rule graph and build audit trails.
QuantumBPM provides out-of-the-box audit trails for every transaction, instantly showing which rules fired, what the variables evaluated to, and precisely how the final decision was reached.
Sources
- Camunda DMN-Scala TCK Results - 2850/3390 tests passed (July 2024)
- Drools DMN Conformance Level 3 - Full runtime support for DMN 1.1-1.6 at CL3
- jDMN TCK Results - Goldman Sachs jDMN 9.0.0: 3390/3390 tests passed
- Camunda Modeler - Desktop and Web modeler for BPMN/DMN
- KIE DMN Editor - Web-based DMN editor for Drools
- Camunda JVM Memory - Default Optimize heap: 1GB
- Camunda 8 Architecture - Camunda 8 requires distributed microservices (Zeebe)
- Drools Serverless Challenges - Kogito/GraalVM needed for cloud-native Drools
- Camunda Cloud - Camunda's SaaS offering (Camunda 8)
- Camunda Go Client - Go client for Zeebe (deprecated)
- Camunda JS SDK - Node.js SDK for Camunda 8
- jDMN JavaScript Runtime - Goldman Sachs jDMN JavaScript runtime
- Camunda Python Client - PyZeebe community client
- Camunda Platform 7 TCK Results - 2741/3390 tests passed
Frequently Asked Questions
Which DMN engine has the best spec conformance?
By TCK pass rate, jDMN leads at 100% (3390/3390), QuantumBPM follows at 99.32% (3367/3390), then Camunda DMN-Scala 1.9.0 at 84.07% and Camunda Platform 7.21.0 at 80.86%. QuantumBPM's 23 failures are deliberate exclusions: external Java function calls, regex backreferences, and unrealistic date ranges. All four engines claim DMN conformance Level 3.
What is the best open DMN engine alternative to Drools?
It depends on whether you want a library or a product. Drools is a JVM library, so execution history, a modeler, and FEEL tooling are things you build yourself. QuantumBPM is a standalone product with a web modeler, a FEEL language server, built-in audit trails and simulation, running as native Go with a ~10MB-50MB footprint against Drools' ~150MB+ on the JVM.
Can I run a DMN engine serverless?
QuantumBPM starts in roughly 5ms with a small memory footprint, which suits serverless and heavily containerized deployments. JVM engines are harder: Drools typically needs Kogito or GraalVM native image to get cold starts down, and Camunda's full platform is not designed for it. jDMN sits in between.
Do I need the full BPMN platform to use QuantumBPM for decisions?
No. The DMN engine is usable standalone through a single OpenAPI spec with SDKs in Go, Java, JavaScript/TypeScript and Python. If you later want processes as well as decisions, BPMN is already in the same product. See the Camunda alternative comparison for the platform-level view.
Ready to Try QuantumBPM?
Start with the Developer tier and evaluate the DMN engine against your own decision models. If you have any more questions, feel free to reach out to us.