Flowable vs jBPM

Flowable and jBPM are both Apache-2.0 Java process engines, but they differ on framework alignment, release maturity and the commercial support behind them. This page shows which fits your team and what switching would involve.

On this page

Flowable vs jBPM: when each engine fits your Java team

A Java team choosing an embedded BPMN, CMMN or DMN engine should start with the framework it already runs. Flowable fits teams that want a stable, Spring-aligned engine with a clear line on Spring Boot 4: Flowable 8.0.0, released on February 27, 2026, is built on Spring Framework 7 and Spring Boot 4 and drops Spring Boot 3 support. jBPM, part of Apache KIE, fits teams already committed to Drools, Kogito or Quarkus-based KIE tooling, and willing to track a project that is still incubating at the Apache Software Foundation. Both are Apache 2.0 licensed, so the decision turns on fit and maintenance rather than license terms.

Four drivers should decide the shortlist. The first is framework version alignment: confirm which Spring Boot or Quarkus version your applications run, then check whether each engine's current line supports it without a framework upgrade you have not scheduled. The second is tolerance for incubation. The Apache KIE site notes that incubation does not necessarily reflect the completeness or stability of the code, so ask KIE maintainers about the release process and compatibility policy before committing. The third is editor needs. Apache KIE 10.2.0 replaced the legacy GWT-based tooling with a new BPMN editor and removed the classic BPMN and DMN editors, so confirm whether your business analysts depend on those editors. The fourth is commercial support, since Flowable sells a separate commercial platform on top of the open-source engines, and KIE support arrangements should be confirmed directly with the project or a vendor.

Which scenarios favor Flowable and which favor jBPM

This table maps common team situations to the platform that fits them better on the supplied facts, with the condition under which the other option could still be right. Use it to shortlist, then confirm open items such as jBPM's Spring Boot 4 and CMMN coverage directly with the Apache KIE project. The main takeaway: Flowable fits Spring-based and CMMN-heavy work, while jBPM fits Quarkus-based platforms and Drools-centered estates.

ScenarioBetter fit and whyWhen the other option could still be right
Spring Boot 4 serviceFlowable. Flowable 8.0.0 targets Spring Framework 7 and Spring Boot 4, with starters for each engine.jBPM if your service already runs on a supported Spring Boot 3 line and you confirm the Spring Boot plan with the project.
Quarkus platformjBPM. Apache KIE grew from Kogito, and 10.2.0 moved to Quarkus 3.27.2.Flowable if Quarkus is only a deployment target and the engines run as a separate REST service.
CMMN case managementFlowable. CMMN is one of its three core engines, alongside BPMN and DMN.jBPM if your work is mostly BPMN and you confirm its CMMN coverage for the cases you need.
Team already running DroolsjBPM. Drools and jBPM are released together under Apache KIE, so versions line up.Flowable if Drools only handles rules and you want one DMN engine for both processes and decisions.
Team needing a commercial vendorFlowable. It sells a commercial platform, with professional services and partners offered separately.jBPM if a vendor or partner you trust supports Apache KIE. Confirm the list and scope in writing.
Procurement requiring a non-incubating projectFlowable, since Apache KIE is still incubating at the ASF.jBPM if incubation is acceptable after your review of the project's maturity and release history.

How Flowable embeds and how jBPM sits inside Apache KIE

Flowable and jBPM make different decisions about where the engine runs, who owns the database schema and how nodes share work. The cards below cover the parts that shape day-to-day operations, from embedding options and job coordination to the Quarkus and Spring Boot runtimes that jBPM inherits from Apache KIE.

Flowable embedding options

Flowable's engines can run as a JAR inside a Java SE application, inside a servlet container such as Tomcat or Jetty, inside a Spring application, or behind the Flowable REST application over HTTP. Embedding keeps process state in your own service, while the REST application gives other systems one shared endpoint. Check which model your teams can operate, because the choice determines where patching, logging and scaling responsibility sits.

Async executor lock coordination

Flowable's async executor runs timers and asynchronous jobs from a thread pool. Nodes coordinate through lock owners and lock expiration times stored in the database, so when a node fails its expired locks are recovered and other nodes pick up the jobs. Ask each vendor how the executor is tuned under load and how lock timeouts are set, since these values decide how quickly a failed node's work resumes.

Supported databases and schema ownership

Flowable's configuration docs list H2, MySQL, Oracle, PostgreSQL, DB2 and Microsoft SQL Server. Your DBA team will own the engine tables, backup and capacity planning, so confirm which database engines your platform team already runs and supports. The docs also note that MySQL versions below 5.6.4 lack millisecond precision, a detail that matters for timer accuracy.

jBPM's position in Apache KIE

jBPM is one project inside Apache KIE, which also holds Drools, OptaPlanner, Kogito and related tools. KIE is licensed under Apache 2.0 but is still in incubation at the Apache Software Foundation, which the KIE site says does not by itself reflect how complete or stable the code is. Your architecture review should therefore treat jBPM as a component of a broader rules and automation family whose governance is still settling.

Quarkus and Spring Boot runtime choices

jBPM's recent Apache KIE releases moved the stack to Quarkus 3.27.2 and Spring Boot 3.5.10, and KIE 10.0.0 had already upgraded to Java 17, Jakarta 10, Quarkus and Spring Boot. Flowable 8.0.0 targets Spring Framework 7 and Spring Boot 4 and drops Spring Boot 3. Match the framework line to your existing Java platform before committing, because a Spring Boot 3 estate and a Spring Boot 4 engine are not a drop-in pair.

Who runs the job pipeline

With Flowable embedded, your application team owns the thread pool, lock settings and any node scaling, so job throughput depends on how that service is deployed. With jBPM on Quarkus or Spring Boot, the same questions apply to the container platform you choose. Confirm in writing which parts of job execution, schema changes and runtime upgrades your partner will handle and which stay with your own engineers.

Side-by-side capabilities, releases and tooling

This table compares the two Java BPM engines on standards coverage, APIs, databases, framework support, release dates and governance. Read the Flowable column as documented facts and the jBPM column as a list of items to confirm against current Apache KIE documentation before you commit.

CapabilityFlowablejBPM (Apache KIE)
BPMN, CMMN and DMN coverageBPMN, CMMN and DMN engines, plus an event registry engine, per the Flowable open source pageBPMN and DMN are part of the KIE stack; confirm CMMN support and scope in current KIE docs
Java and REST APIsJava and REST APIs documented; REST application available for HTTP accessConfirm the REST and Java API surface for your target version in the KIE documentation
Supported databasesH2, MySQL, Oracle, PostgreSQL, DB2 and Microsoft SQL Server listed in the configuration docsConfirm the supported database list for your KIE version with the project
Spring Boot and QuarkusSpring Boot starters for all engines; Flowable 8.0.0 uses Spring Boot 4 and drops Spring Boot 3Apache KIE 10.2.0 moved to Quarkus 3.27.2 and Spring Boot 3.5.10; confirm the Spring Boot 4 position
Flowable release dates7.1.0 on October 7, 2024; 7.2.0 on August 21, 2025; 8.0.0 on February 27, 2026 (GitHub releases)Not applicable
Apache KIE release datesNot applicable10.0.0 tagged December 11, 2024; 10.1.0 on July 8, 2025; 10.2.0 on April 28, 2026 (GitHub releases)
Editor toolingFlowable open source engines have no bundled modeler; low-code design is in the commercial platformKIE 10.2.0 introduced a new BPMN editor, replacing the legacy GWT tooling and removing the classic BPMN and DMN editors
Identity integrationIdmIdentityService can be overridden or replaced, with an LDAP reference implementationConfirm the identity and user-management integration points for your KIE version
Governance and licensingApache-2.0 engines; commercial Flowable platform sold separately with professional services and partnersApache-2.0 code, still in incubation at the ASF, which does not guarantee completeness or stability; confirm commercial support options with vendors

What the Apache-2.0 licenses and commercial layers include

The Flowable open-source engines for BPMN, CMMN and DMN are licensed under Apache-2.0, according to the Flowable open source page. That license lets your team use, modify and redistribute the engine code without a license fee to Flowable for the engines themselves. The engines run embedded in a Java application or as a service, and they expose both Java and REST APIs. What the license does not provide is support, hosted operation or the commercial tooling, so those costs and responsibilities must be planned separately.

  • Engine code: The BPMN, CMMN, DMN and event registry engines are Apache-2.0 licensed, so the code can be reviewed, forked and patched inside your own change control.
  • Community support: Open-source users get access to a community forum. That is a discussion channel, so confirm whether any response expectations apply before you depend on it for production incidents.
  • Professional services: Flowable offers these separately from the license, so you buy implementation, customization or training as scoped work.
  • Upgrade effort: Flowable 8.0.0, released on February 27, 2026, moved to Spring Boot 4 and dropped Spring Boot 3 support, so upgrade labor is a real cost even with no license fee.
  • Tooling gaps: The facts attribute low-code modeling and visual debugging to the commercial products, so confirm what your open-source build includes before you plan to hand models to business analysts.

Check the license file in the exact release you deploy, and ask Flowable in writing what the community forum covers.

Which Spring Boot and Quarkus versions each engine supports today

Flowable 8.0.0 is built on Spring Framework 7 and Spring Boot 4, and it dropped Spring Boot 3 support, so there is no Spring Boot 3 line in the 8.x series. Flowable 8.0.0 was released on February 27, 2026. Flowable 7.0.0 moved the engines to Java 17, Spring Boot 3 and Jakarta EE, so a team still on Flowable 7 that runs Spring Boot 3 is on a supported pairing, but moving to 8.x requires the Spring Boot 4 step as well. The Flowable release notes also list Jackson 3 as the default JSON library, with a Jackson 2 compatibility layer, and removal of JUnit 3 and 4 support. Check any custom serializers and test suites against those changes before you pick a target version. On the jBPM side, Apache KIE 10.2.0 moved its runtime to Quarkus 3.27.2 and Spring Boot 3.5.10 and added Java 21 support. That is a different framework generation from Flowable 8. The KIE 10.2.0 release also replaced the legacy GWT-based tooling with a new BPMN editor. No supplied fact states whether Apache KIE plans Spring Boot 4 or a newer Quarkus line, so ask the Apache KIE project directly before you commit to a roadmap that depends on either. Read the Apache KIE 10.2.0 release post for the exact stack it lists. Framework versions drive upgrade effort because they set the Java baseline, the servlet and Jakarta namespace, the JSON library, the test framework and the starter or autoconfiguration names your application code depends on. A jump from one Spring Boot generation to the next often means changing dependency coordinates, configuration keys and test annotations across every service that embeds the engine, while a minor upgrade within a generation usually does not. Map your current Java version, Spring Boot or Quarkus version and any custom engine extensions before you compare the two engines, and ask each vendor which of those will change in the version you plan to run.

What drives running cost on each side

Running cost for either engine is set less by the license line than by the infrastructure, people and upgrade work around it. The cards below separate one-time setup from recurring spend, and name what to request in a written quote from DeployOpen or any other partner.

Database and application node infrastructure

Both engines run as Java applications backed by a relational database, and both use the database for the job executor and locking. Flowable's documented database types include PostgreSQL, MySQL, Oracle, Microsoft SQL Server and DB2, so licensing and hosting of the database engine you pick is a recurring line. jBPM runs on Quarkus or Spring Boot services, so node count and sizing differ by deployment model. Ask the quote to price each application node, the database tier and its high availability setup as separate lines.

Framework upgrade engineering

Flowable 8.0.0 moved to Spring Framework 7 and Spring Boot 4 and dropped Spring Boot 3 support, so teams on Spring Boot 3 must plan a migration before they can take the release. jBPM's recent Apache KIE line moved to Java 21 and Quarkus 3.27.2 and Spring Boot 3.5.10, which means a different upgrade path. Each framework move recurs in engineering time, so ask for a per-release estimate covering regression tests of your processes.

Internal BPMN, CMMN and DMN skills

Flowable covers BPMN, CMMN and DMN in one set of engines, while jBPM's current tooling centers on BPMN and DMN with its classic editors removed in 10.2.0. Your staff need to model, debug and review process definitions, and the skills you already have decide whether that work is a hiring cost or an internal one. Confirm with each option which notation your team will maintain for the next several years.

Support contract choices

Flowable's open-source users rely on a community forum, while professional services and partners are sold separately. Apache KIE is community supported and still incubating at the ASF, so support for jBPM generally means a paid partner or an internal team. Support is recurring and should be priced against your uptime and response expectations. Ask each vendor or partner what response targets are included and which ones are extra.

Editor and tooling licenses

Modeling tools, visual debugging and monitoring add cost when they are commercial. Flowable sells its low-code design, monitoring and governance tooling as a separate commercial platform on top of the open-source engines. For jBPM, the new BPMN editor that replaced the GWT-based tooling is an open-source choice, but you should confirm whether any paid editor or hosting fee applies. Ask the quote to separate tool licenses from the engine work they support.

Minor and major release upgrades

Apache KIE tagged 10.0.0, 10.1.0 and 10.2.0 at different dates, and Flowable has shipped 7.x and 8.0.0 on its own schedule. Each release, whether minor or major, needs regression testing, database schema checks and deployment rehearsal. Budget for this as a recurring upgrade cycle rather than a one-time project. Ask the quote to state how many upgrade cycles are covered per year and whether that work sits inside a retainer.

Moving process models from jBPM to Flowable, step by step

This sequence turns a jBPM estate into a tested Flowable deployment by separating what transfers as standard BPMN and DMN from what must be rebuilt, so cutover happens only after running instances, integrations and load behavior are checked.

  1. Inventory running instances and process definitions

    Your architects and process owners list every deployed process definition, its version, the number of active and suspended instances, timers and asynchronous jobs, and the KIE-specific constructs each model uses, such as custom work item handlers, Java-based service tasks and any dependency on Drools rules called from a process. The output is a register that marks each definition as standard BPMN, DMN-dependent or KIE-specific. Confirm the register matches what the jBPM runtime reports, since a model that looks inactive may still hold timers.

  2. Map BPMN constructs and decision or case artifacts

    Engineers compare each BPMN element in the register against Flowable's BPMN engine, and check every DMN decision table and any CMMN case model against the Flowable CMMN and DMN engines. Standard BPMN and DMN models should transfer in principle, but the mapping must be verified element by element, including gateways, boundary events, multi-instance activities and script tasks. The output is a mapping sheet with a status for each construct: transfers as is, needs adjustment or must be rebuilt. Test any construct the sheet marks as unclear in a pilot before committing.

  3. Decide whether to migrate or drain in-flight instances

    The process owner and the platform lead choose, per definition, between migrating running instances to a new Flowable definition and letting existing instances finish on jBPM while new instances start on Flowable. Draining avoids migration logic but keeps two runtimes alive for longer, while migration requires a tested mapping of activity identifiers and variables. The output is a signed decision per definition with a rollback position. Confirm with Flowable and your own data whether any in-place migration tooling applies to jBPM sources, because the supplied facts do not establish one.

  4. Rebuild identity and service-task integrations

    Integration engineers replace jBPM work item handlers, human task assignment logic and any calls to user directories with Flowable equivalents. Flowable's identity management can be replaced by overriding its IdmIdentityServiceImpl class or by implementing the IdmIdentityService interface, and an LDAP reference implementation is provided, so the team should confirm that the existing directory and group model maps cleanly onto it. The output is a passing integration test suite that covers each task type, assignment rule and external call. Check that every service task still authenticates to downstream systems the same way.

  5. Re-create editor-driven models in the Flowable path

    Modelers rebuild any process that was authored in KIE tooling, since the editor-specific files and KIE extensions do not carry over automatically. Flowable's commercial platform offers low-code modeling, but the open-source engines do not include a modeler, so teams must confirm which modeling tool they will use for ongoing changes before rebuilding. The output is a versioned set of BPMN and DMN files in source control, reviewed against the mapping sheet. Confirm the chosen editor's licensing and file compatibility before relying on it.

  6. Load test the async executor

    Platform engineers run a load test against the Flowable async executor, which runs timers and asynchronous jobs from a thread pool and coordinates nodes through lock owners and lock expiration times in the database. The test should create realistic timer volumes, simulate a node failure and confirm that expired locks are recovered and jobs are picked up by surviving nodes. The output is a documented throughput and recovery result compared with the jBPM baseline. Confirm the database type you will run in production, since Flowable supports H2, MySQL, Oracle, PostgreSQL, DB2 and Microsoft SQL Server, and check the MySQL version requirement for millisecond precision.

  7. Cut over and retire the jBPM runtime

    The operations team moves traffic to the Flowable services in the order set by the decision sheet, monitors process health through Flowable's actuator endpoint in Spring Boot deployments and watches for failed jobs and stuck tasks. Old jBPM definitions stay read-only until draining or migration is confirmed complete, and the rollback path stays open for an agreed window. The output is a closure record listing each definition, its final state and the date the jBPM runtime was switched off. Keep the audit trail of process data for any retention obligations your regulator sets.

Where Flowable and jBPM implementation projects usually run long

The longest delays in a Flowable or jBPM project rarely come from the engine itself. They come from the database layer, identity integration and framework alignment, so plan those areas first. Start with the schema. Flowable's configuration docs list H2, MySQL, Oracle, PostgreSQL, DB2 and Microsoft SQL Server as supported database types, and they note that MySQL versions below 5.6.4 lack millisecond precision. A DBA should confirm the exact server version, collation and timestamp precision before anyone runs schema creation, because changing these later means rework on live process history and timers. Ask the same question of the jBPM persistence setup, since the database choice drives your operational runbook as much as the engine choice does.

Identity is the next common delay. Flowable documents that identity management can be replaced by overriding IdmIdentityServiceImpl or by implementing the IdmIdentityService interface, with an LDAP identity service provided as a reference. Someone who owns the directory must decide how groups, roles and candidate users map onto task assignment, and that mapping usually takes longer than expected. Custom service tasks and REST calls to downstream systems add a second layer of work, mainly around error handling, retries and idempotency. Modeling tool onboarding also takes time: business analysts need the editor, naming conventions and a review path before the process models are stable. Upgrades complicate all of this. Flowable 8.0.0 is based on Spring Framework 7 and Spring Boot 4 and drops Spring Boot 3, so a team still on Spring Boot 3 must plan a framework migration before or alongside the engine move. Confirm the jBPM side against the Apache KIE release notes for the version you intend to run.

Staffing decides whether these items finish on schedule. You need Java developers who can embed the engine and build the service tasks, a DBA who owns the schema and precision decisions, an identity owner who controls the directory mapping, and a product owner who can settle process questions such as escalation rules and ownership of exceptions. Without the product owner, developers wait on decisions, and the model changes after integration testing. Ask any implementation partner to write down these roles, their time commitments and the decisions each one must sign off, inside a fixed written scope. Those are the questions that determine whether the project runs long, and they are easier to answer before the work starts than after the first integration failure.

Questions buyers ask before choosing Flowable or jBPM

What drives the cost of running Flowable or jBPM?

The engines carry no license fee, since Flowable's open-source engines and jBPM within Apache KIE are both Apache-2.0 licensed, so most of the cost sits in people and infrastructure. The main drivers are engineering time to embed the engine in your Java services, the database platform (Flowable's documented options include H2, MySQL, Oracle, PostgreSQL, DB2 and Microsoft SQL Server), and the recurring work of upgrades, patching and staff time. Commercial items are separate: Flowable sells its enterprise platform on top of the engines, and any implementation partner prices work from a written scope. Ask any quote to split build, integration, testing and ongoing upgrade work, so you can see what recurs each year.

How long does an evaluation of Flowable or jBPM take?

No fixed duration applies, because the answer depends on factors you control. The biggest drivers are how many process models you need to prototype, whether you must test on your own database and identity stack, and which framework versions your organization already runs. Version choice matters here: Flowable 8.0.0 is based on Spring Boot 4 and dropped Spring Boot 3 support, while jBPM 10.2.0 moved to Spring Boot 3.5.10 and Quarkus 3.27.2. Scope the evaluation in writing with a fixed list of processes, target runtime and acceptance criteria, then ask the vendor or community maintainers and any implementation partner for a timeline tied to that list.

What does the work need from our engineering team?

Plan for Java developers who can embed the engine, a database administrator, and a platform engineer who owns clustering and backups. Flowable runs as a JAR in Java SE, servlet containers, Spring applications or Java EE servers, or as a REST service, so your team picks the model first. In a multi-node cluster, the async executor coordinates through lock owners and lock expiration times in the database, so engineers must understand that behavior. Identity integration is also a design task: Flowable documents replacing the identity service by overriding IdmIdentityServiceImpl or implementing IdmIdentityService, with an LDAP implementation as reference. For jBPM, modelers need retraining, because Apache KIE 10.2.0 replaced the legacy GWT tooling with a new BPMN editor and removed the classic BPMN and DMN editors.

Can our team run Flowable or jBPM without outside help?

Yes, a team with Java, database and operations depth can run either engine in-house, because the engines are open source and need no license key. Outside help is optional, and it is most useful for the first build, a framework upgrade or a clustering review. Before committing, name the owner for each recurring task: framework upgrades, security patches, database backups, and monitoring of running processes (Flowable's Spring Boot starters expose an actuator endpoint at /actuator/flowable). Flowable's open-source users get a community forum, while professional services and partners are offered separately. DeployOpen runs ongoing support, upgrades and continuous testing as retainers, and those terms should be written into the scope.

Does jBPM's incubation status matter for production use?

Incubation matters for governance and planning, but the Apache KIE site is explicit that it does not necessarily reflect how complete or stable the code is. It means only that the ASF has not yet fully endorsed the project. Watch the release record instead: Apache KIE 10.0.0 was tagged on December 11, 2024, 10.1.0 on July 8, 2025 and 10.2.0 on April 28, 2026. Also note that the Kogito Runtimes and Kogito Apps repositories are archived, with their code moved into the apache/incubator-kie-drools repository, and that 10.2.0 removed classic editors. Ask how the project plans to graduate, test each upgrade against your own processes, and what you will do if a release changes tooling you rely on.

How should we compare commercial support options for each engine?

Start by writing down what you need supported: engine version, database, application framework, and any modeling tools your analysts use. For Flowable, the open-source engines are backed by a community forum, and the commercial platform (Flowable Work, Engage, Orchestrate and Design) is built on the same engines and adds low-code modeling, visual debugging, security controls, monitoring and governance. Professional services and partners are sold separately. For jBPM, confirm directly which vendors or consultancies offer support, because no supported vendor list is established in this comparison. For either option, request a written statement of supported versions, response terms, upgrade assistance and what happens when a version reaches end of support.

Can DeployOpen help implement Flowable or jBPM?

Yes. DeployOpen plans, implements, customizes, integrates, hardens, backs up, upgrades, documents and supports self-hosted open-source platforms inside your own cloud accounts, data centers or air-gapped networks. Most engagements are fixed-scope, with scope, deliverables and timelines agreed in writing before work starts, and DeployOpen does not publish a price list, so a quote follows from that written scope. Ongoing support, upgrades and continuous testing are available as retainers. The engine choice remains yours, and DeployOpen can help you assess either option against your processes, identity model and database. DeployOpen prepares systems and evidence for compliance assessments but does not issue audit reports or certifications.

How DeployOpen helps teams choose and implement a Java BPM engine

DeployOpen plans, implements, integrates and documents self-hosted open-source platforms inside the client's own infrastructure. For Flowable vs jBPM, we help teams test both engines against their own process models, identity sources and framework choices before committing to one.

How we scope

  • Written scope names the process, case and decision models to be tested on each engine before any build starts.
  • Scope records the Spring Boot or Quarkus target, the database engine and the identity source the engine must integrate with.
  • Engagements are fixed-scope, with deliverables and timelines agreed in writing. Ongoing support is available as a retainer.

How we build

  • We build a proof of concept on the shortlisted engine using a representative subset of your BPMN and DMN models.
  • Integration work covers REST APIs, the async executor configuration for clustered nodes, and identity service wiring to your directory.
  • Hardening covers configuration review, access controls on the engine APIs and monitoring endpoints, and backup procedures for the database.

How we hand over

  • Documentation covers the deployment topology, upgrade path, configuration decisions and the reasoning behind the engine choice.
  • Handover includes runbooks for upgrades, database maintenance and incident response, with your team trained to run them.
  • Evidence packs record configuration, test results and access controls in a form your internal auditors or assessors can review.

How we support

  • Retainers cover upgrades, security patching review, continuous testing and support for changes to process models.
  • Support can follow the engine's release line, including planning for framework upgrades such as a move between Spring Boot versions.
  • Confirm with us in the quote which engine versions, environments and response expectations the retainer includes.

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.