Flowable
Flowable is an open-source workflow and business process management (BPM) engine written in Java, designed to execute business processes modeled in BPMN 2.0, case management in CMMN, and decision logic in DMN.[1] It provides lightweight, efficient runtimes for these standards, enabling developers to embed the engines directly in applications or deploy them as standalone services, clusters, or in the cloud.[1] Licensed under the Apache 2.0 license, Flowable emphasizes performance, extensibility, and integration with frameworks like Spring.[2] Originating as a fork of the Activiti project in 2016, Flowable was created by the original Activiti core developers who sought to independently advance the engine's capabilities amid concerns over its direction under Alfresco's ownership.[3] The first release, version 5.22.0, was issued on October 13, 2016, building directly on Activiti 5.21.0 with initial enhancements like transient variables for non-persisted data handling.[4] Since then, Flowable has evolved significantly, introducing support for version 6 and beyond, with key advances including improved async executors, enhanced scripting, and better multi-tenancy features compared to its predecessor.[5] The project maintains an active open-source community, boasting over 5,000 stars on GitHub.[1] Beyond its core engines, Flowable powers a commercial enterprise platform that extends the open-source foundation with low-code tools for process design, AI agent orchestration via Flowable AI Studio, and robust security for regulatory compliance.[6] This platform is adopted by more than 600 enterprises worldwide for end-to-end automation of complex workflows involving humans, systems, and AI.[6] Flowable's open-standards-based architecture ensures flexibility, allowing seamless interoperability with existing IT ecosystems.[7]Overview
Definition and Scope
Flowable is an open-source, lightweight business process management (BPM) engine written in Java, primarily designed for executing business processes modeled according to the BPMN 2.0 standard, with extensions supporting case management through CMMN and decision automation via DMN.[1][8] This engine provides a compact and efficient platform for handling complex workflows, enabling the deployment and runtime execution of process definitions while maintaining compatibility with open standards.[9] The core purpose of Flowable is to empower developers and organizations to automate business workflows seamlessly, either by embedding the engine directly into Java-based applications for tight integration or by operating it as independent services that expose REST APIs for broader accessibility.[8][10] It originated as a fork of the Activiti project, building on its foundational capabilities while advancing support for modern automation needs.[8] Flowable supports flexible deployment models, including embedded usage within custom applications, standalone server configurations, clustered setups for scalability and fault tolerance, and integration into cloud infrastructures for managed operations.[11][12] Its high-level use cases focus on workflow automation to reduce manual tasks, process orchestration to coordinate multi-system interactions, and seamless integration with enterprise systems like databases and external APIs to enhance operational efficiency.[13][10]Licensing and Platforms
Flowable is released under the Apache License 2.0, a permissive open-source license that permits commercial use, modification, and distribution of the software without requiring derivative works to be open-sourced.[1][2] This licensing model fosters widespread adoption by allowing integration into proprietary applications while ensuring contributors retain copyright ownership of their contributions.[14] The project follows a community-driven development model hosted on GitHub, primarily through the flowable/flowable-engine repository, which has garnered over 5,000 stars as of 2025, reflecting strong developer engagement and contributions.[1][2] Flowable supports deployment on Java runtimes, with version 6 and earlier compatible with JDK 8 or higher, while version 7 and later require JDK 17 or higher for optimal performance and security features.[14][2] It also includes JavaScript components for client-side interactions, enabling web-based applications.[2] As a Java-based platform, Flowable is inherently cross-platform, running on operating systems including Linux, Windows, and macOS without platform-specific modifications.[15] For integration, Flowable provides REST APIs that allow remote interaction with its engines, deployable via the flowable-rest.war file on servlet containers such as Apache Tomcat.[16] It offers Spring Boot starters for seamless embedding within Spring applications, supporting features like auto-configuration, JPA integration, and security.[17] These capabilities enable Flowable to function either embedded in custom Java applications or as a standalone service in clustered environments.[2]History
Origins as Activiti Fork
In October 2016, core developers of the Activiti project, including Joram Barrez and Tijs Rademakers, departed from Alfresco due to strategic differences regarding the project's direction and control.[18] They initiated a fork of Activiti to establish Flowable as an independent open-source initiative.[3] The primary motivations for the fork centered on the desire to pursue community-driven evolution of the BPM engine without the constraints imposed by corporate oversight at Alfresco.[3] This shift aimed to foster a meritocratic environment where contributors could freely advance ideas, maintaining the project's open and liberal ethos.[18] Flowable's initial codebase was derived directly from Activiti version 5.21.0 and rebranded for its debut release as Flowable 5.22.0, which introduced enhancements such as transient variables—non-persisted variables usable within a single transaction for tasks like REST responses.[4] No immediate changes were made to package names or configuration files to ensure compatibility.[4] The early development team comprised key Activiti contributors, preserving deep expertise in BPMN standards and workflow orchestration to support seamless continuity for users and developers.[3] This foundation enabled rapid community engagement through GitHub hosting.[18]Key Development Milestones
Following its inception as a fork of Activiti in 2016, Flowable achieved its first major milestone with the release of version 6.0.0 on February 15, 2017. This version represented a significant advancement through a complete rewrite of the process virtual machine, establishing a one-to-one mapping between BPMN elements and execution operations to enhance predictability and reduce complexity compared to prior implementations.[19][20] The release also introduced a modular architecture with an abstract data layer, enabling flexible storage options across relational and NoSQL databases to support scalable process execution.[20] The version 7 series, commencing with 7.0.0 on September 20, 2023, marked another pivotal phase by aligning with modern frameworks, including full support for Spring Boot 3.x, Spring 6, and Java 17.[21] Subsequent updates through 2025 focused on robustness, with enhancements to variable handling, performance optimizations, and security measures such as secure HTTP headers. Clustering capabilities were refined for high-availability deployments, allowing distributed processing across nodes while maintaining data consistency.[22] The series culminated in the open-source 7.2.0 release on August 21, 2025, incorporating Spring Boot 3.5.4 and preparing the groundwork for version 8 with anticipated support for Spring 7 and Jackson 3.[23] On the enterprise front, Flowable shifted to an annual release cadence, exemplified by the 2025.1 platform update on July 17, 2025, which integrated AI agent orchestration as a core capability.[24] This release introduced tools for designing and governing multi-agent workflows, including orchestrator, document, utility, and external agent types, enabling context-aware automation and coordination with large language models and external systems.[25] A patch update, 2025.1.05, followed on November 7, 2025.[26] Community engagement has grown steadily, with the Flowable GitHub repository surpassing 5,000 stars by 2025, reflecting widespread adoption among developers and users.[1] Forum activity reached notable peaks in 2024-2025, driven by discussions around version 7 migrations and AI integrations, underscoring the project's vibrant ecosystem.[27]Technical Architecture
Core Engines
Flowable's core engines form the foundational runtime components for executing business automation models, providing specialized handling for different types of workflows and decisions. These engines—BPMN, CMMN, and DMN—are implemented in Java and designed for high performance and scalability, enabling the deployment and execution of standards-based models. They operate on a shared infrastructure that ensures consistency in persistence, execution management, and asynchronous operations across the system.[1] The BPMN engine serves as the primary component for process execution, managing the lifecycle of BPMN 2.0 process definitions from deployment to completion. It handles state management through an execution tree, where each process instance is represented as a root execution entity with child entities for parallel paths and subprocesses, allowing precise tracking of activity states and transitions. Task assignment is facilitated via the TaskService, which assigns human tasks to users or groups based on assignees, candidates, or forms, while event handling supports both intermediate and boundary events through configurable listeners that trigger actions on process events like start, end, or errors. This engine ensures deterministic, sequential process flows with support for gateways, loops, and multi-instance activities.[10][28] The CMMN engine is dedicated to case management, enabling the execution of ad-hoc and knowledge-driven processes that require flexibility beyond rigid sequences. Unlike the BPMN engine's local, state-focused evaluation, the CMMN engine adopts a global view of the entire case instance, evaluating all possible actions based on rules in the case model, such as entry criteria, required plan items, and discretionary tasks. It features a distinct data model optimized for cases, including case instances, stages, plan items, and milestones, which support dynamic task creation, repetition, and completion rules tailored for unstructured scenarios like incident management or customer onboarding. This architecture allows knowledge workers to make contextual decisions, with the engine persisting case data separately while leveraging shared execution mechanisms.[29][1] The DMN engine focuses on automated decision-making, providing a rules-based execution environment for decision models defined in DMN 1.1. It processes decision tables with configurable hit policies (e.g., unique, rule order) to evaluate inputs against rules and produce outputs, supporting complex logic through FEEL (Friendly Enough Expression Language) expressions for input clauses, output values, and literal expressions. The DmnEngine serves as the entry point, allowing deployment of decision definitions and evaluation of decisions within processes or standalone, ensuring decisions are traceable and interchangeable across systems. This engine integrates seamlessly with BPMN and CMMN for embedding decisions, such as credit checks or routing rules, without requiring custom code.[30][31] These engines share a common infrastructure to promote efficiency and maintainability. The abstract persistence layer, introduced in Flowable 6 and continued in version 7 (as of 2025), decouples the engines from specific databases, supporting both relational (e.g., via JDBC and MyBatis) and non-relational stores through configurable mappings, enabling flexible deployment in diverse environments. Version 7 requires Java 17 or higher and supports Spring Boot 3 and Spring 6. The execution tree concept, while BPMN-specific in its hierarchical structure, extends analogously to CMMN cases for representing instance states, and both utilize a unified command executor for transactional API operations. The job executor, known as the Async Executor, is a reusable, configurable component that manages asynchronous jobs and timers across all engines; it features an acquisition mechanism for polling due jobs, an execution thread pool for processing, and persistence for job data, ensuring reliable handling of deferred activities like timers or service calls with retry logic and error recovery.[32][33][34] In the enterprise platform, the core engines are extended with additional capabilities, such as the Agent engine introduced in version 2025.1 for orchestrating AI agents in workflows.[25]Supporting Modules
Flowable's supporting modules provide essential utilities and interfaces that extend the functionality of the core engines without handling primary execution logic. These modules facilitate identity management, content handling, API access, and user interfaces, enabling seamless integration and administration in various deployment scenarios. In the open-source distribution (version 7+), modules focus on core functionality, while advanced features like content and UI are available in the enterprise platform.[8] The Identity Management (IDM) module, implemented in the flowable-idm-engine, handles user authentication, group management, and tenant isolation to support secure, multi-tenant environments. It manages users, groups, and privileges through dedicated database tables prefixed with act_id_, allowing for the creation, querying, and deletion of identities via the IdmIdentityService API. Authentication is typically integrated with Spring Security, where users are verified against IDM-stored credentials or external providers like LDAP, ensuring role-based access control across processes and tasks. Tenant isolation is achieved by associating users, groups, and resources with a tenantId, preventing cross-tenant data visibility and enabling isolated operations in shared engine instances.[35][36][37] The Content Service module, part of the enterprise platform, offers capabilities for storing, retrieving, and managing binary data and documents associated with processes, cases, or tasks. Through the ContentService API in the flowable-content-engine, developers can create content items—representations of files or streams—with metadata such as name, MIME type, and tenantId, supporting operations like uploading attachments or linking documents to workflow elements. This service is particularly useful for handling process-related files without embedding them directly in the engine database, providing CRUD endpoints for content items and related versions. It integrates with the core engines by allowing content references in BPMN or CMMN models, ensuring efficient document lifecycle management.[38][39] The REST API Module delivers standardized HTTP endpoints for interacting with all Flowable engines, packaged as the deployable flowable-rest.war application for servlet containers like Apache Tomcat. This module exposes comprehensive APIs covering process deployment, instance management, task operations, and queries, with support for JSON payloads and authentication via basic auth or tokens. It mirrors the Java APIs closely, enabling remote access to engine features such as starting processes or completing tasks, and includes Swagger documentation for endpoint exploration. Deployment of flowable-rest.war provides a ready-to-use service layer, facilitating integration with external systems or custom front-ends.[40][41] UI Applications, available in the Flowable enterprise platform, are optional web-based tools built on modern frameworks like Angular, offering intuitive interfaces for non-developers to interact with the platform. The Flowable Modeler allows visual creation and editing of BPMN, CMMN, and DMN models, with export options for deployment to engines. The Flowable Task application provides a dashboard for users to view, claim, and complete assigned tasks, including form rendering and delegation features. The Flowable Admin app supports system administration, such as user and group management via IDM integration, engine configuration monitoring, and database querying. Additionally, the IDM-specific UI handles identity operations like user registration and privilege assignment. These were bundled into a single flowable-ui.war for simplified deployment up to version 6.6 in open source, but are now enterprise-exclusive.[8][42]Features and Standards
BPMN 2.0 Implementation
Flowable provides comprehensive support for the BPMN 2.0 standard, enabling the modeling and execution of complex business processes through all core diagram elements, including gateways (exclusive, parallel, inclusive, and event-based), events (both catching and throwing varieties), and sub-processes (embedded and event-triggered). This adherence to the specification ensures interoperability with industry-standard tools and processes.[9][43][44][45][46] The BPMN engine in Flowable enforces precise execution semantics by maintaining a one-to-one mapping between the deployed BPMN model and its runtime instances, where each element in the diagram corresponds directly to an executable artifact in the process execution. This mapping facilitates accurate simulation of process behavior, including sequence flows, conditional branching via gateways, and event handling. Flowable further supports dynamic modifications to active process instances, allowing runtime adjustments such as task insertion or flow alterations without redeployment.[8][9] Among advanced BPMN 2.0 features, Flowable fully implements multi-instance activities, which iterate over collections to execute tasks or sub-processes in parallel or sequential modes, complete with completion conditions and synchronization. Call activities are supported to invoke reusable global processes or tasks, promoting modularity by referencing external definitions while passing input and output variables. Boundary events, attachable to tasks or activities (including multi-instance ones), enable reactive behavior through interrupting or non-interrupting mechanisms for events like timers, errors, or messages.[9][47][48][49] Integration with modeling tools is seamless due to Flowable's use of standard BPMN 2.0 XML for process definitions, allowing export from and import into third-party editors such as the Eclipse BPMN2 Modeler for design and deployment. Flowable also offers native tooling via its Eclipse Designer plugin, a fork optimized for BPMN modeling and direct engine integration.[8][50]CMMN and DMN Support
Flowable provides a dedicated CMMN 1.1 engine that enables ad-hoc case handling for knowledge-intensive, dynamic processes where the sequence of activities is not predefined but emerges based on context and events.[51] This engine supports key CMMN constructs such as stages for organizing case phases, milestones to track progress against objectives, and human tasks to assign discretionary work to knowledge workers, facilitating flexible responses to exceptions and unplanned scenarios.[51] The implementation allows cases to evolve organically through sentries—event and information conditions that trigger plan items—making it suitable for exception-based workflows that require human judgment.[52] In parallel, Flowable's DMN engine achieves compliance with the DMN 1.3 standard, supporting decision requirements diagrams (DRDs) for modeling complex decision logic across multiple interrelated decisions.[53] Core features include decision tables for tabular rule representation with hit policies like unique or collect, boxed contextual expressions using the Friendly Enough Expression Language (FEEL) for calculations and literals, and mechanisms to invoke external services or Java methods within decision logic.[31] This enables precise, executable decision models that separate business rules from processes, ensuring consistency and maintainability in rule-based automation.[54] Flowable facilitates interoperability by allowing seamless integration of CMMN cases with BPMN processes and DMN decisions in hybrid models, where CMMN oversees overarching case lifecycles, BPMN handles structured subprocesses, and DMN provides reusable decision services invoked from either.[55] For instance, a CMMN case can embed BPMN tasks for routine operations while calling DMN tables for eligibility checks, promoting a unified approach to orchestration across standards.[56] These capabilities find application in compliance-driven workflows and rule-based automation within regulated industries, such as financial services for loan origination where CMMN manages adaptive case progression amid varying documentation needs, and DMN enforces regulatory decision criteria like credit scoring.[57] In healthcare or insurance, hybrid models ensure audit trails and exception handling align with standards like GDPR or HIPAA, reducing manual errors and enhancing traceability.[58]Versions and Changes
Version 5 Characteristics
Flowable version 5, derived from the Activiti 5.21 codebase, features a lightweight, embeddable Java-based process engine optimized for BPMN 2.0 workflows.[46] Its core architecture employs a dual-agenda execution model to manage process progression efficiently: the main agenda handles synchronous operations within a single transaction, while the job agenda processes asynchronous elements, such as timers and retries, through a configurable job executor.[59] This separation ensures that process instances advance step-by-step until reaching a wait state, at which point execution pauses and state is persisted.[60] The execution model in version 5 represents the state of a process instance as a hierarchical execution tree, where each node corresponds to an activity in the BPMN definition.[60] Executions act as tokens that traverse the process graph, with multiple executions possible for concurrent activities; each activity supports distinct states, including active (currently executing), waiting (paused for external input, such as a user task), and completed (finished with outgoing flows triggered).[61] This structure allows for complex branching and parallelism but results in a potentially intricate tree with numerous execution entities per instance, especially in multi-instance scenarios.[60] Persistence in version 5 relies on direct, concrete database mappings to relational databases, without an intervening abstraction layer, using JDBC connections or JNDI data sources.[62] Runtime data, such as active executions and tasks, is stored in tables prefixed withACT_RU_ (e.g., ACT_RU_EXECUTION for execution states and ACT_RU_TASK for pending tasks), while historical data resides in ACT_HI_ tables.[62] The engine supports databases like H2, MySQL, PostgreSQL, and Oracle, with automatic schema updates enabled via the databaseSchemaUpdate property to handle deployments and state changes.[62] This approach prioritizes performance in clustered environments through shared database access but ties the engine closely to specific table schemas.[63]
A notable enhancement in version 5.22 introduced transient variables, which are non-persisted, in-memory data structures designed to optimize performance by avoiding unnecessary database writes.[64] These variables can be set on executions or tasks using methods like setTransientVariable(key, value) in Java delegates, execution listeners, or process instance builders, and they remain available only until the next wait state, such as a user task or timer boundary.[64] Transient variables take precedence over persistent ones with the same key and are not recorded in the history service, making them suitable for temporary computations like loop counters or intermediate results.[64]
Version 5's design exhibits limited modularity, with internal implementation classes (e.g., under org.flowable.engine.impl.*) considered unstable and not intended for external extension, emphasizing embedding over customization.[65] The engine's primary focus is on BPMN 2.0 conformance, supporting core constructs like sequence flows, gateways, and events, but with constrained flexibility for alternative modeling notations or highly decoupled components.[61]