Flowable is an open‑source Java workflow engine that follows the BPMN 2.0 standard, offering tighter Spring Boot integration, full CMMN/DMN support, better performance than Activiti, and flexible deployment options, with detailed comparisons to Activiti and Camunda and step‑by‑step Spring Boot and standalone examples.
This article shows how to replace hard‑coded if‑else approval logic with Flowable workflow in a Spring Boot 3.x project, using the three core annotations @EnableProcessApplication, @Deployment and @ProcessVariable to auto‑configure the engine, deploy BPMN files, inject variables, and implement a complete leave‑request service.
This guide walks through setting up Flowable 6.8.0 with Spring Boot 2.7.x, configuring MySQL, defining and deploying BPMN processes, managing runtime tasks, handling dynamic assignments, querying history, adding extensions like multi‑instance approvals and email notifications, and finally containerizing the application with Docker.
This article details the modular design of Flowable's core database tables, dividing them into five categories—Repository, Runtime, History, Identity, and General Data—and explains each table’s fields, types, and inter‑table relationships, including multi‑tenant support and optimistic‑locking mechanisms.
This article explains what workflow engines are, compares five popular options—Activiti, Flowable, Camunda, jBPM and JDEasyFlow—detailing their core principles, architecture, code examples, and suitable scenarios, and provides a comprehensive table and decision flowchart to help developers select the most appropriate engine for their projects.
This article explains what a workflow engine is, outlines Flowable’s core architecture and BPMN support, and provides a step‑by‑step Spring Boot integration example—including Maven setup, BPMN model definition, and Java code for starting, submitting, and approving a leave request—while discussing version and archiving recommendations.
This article walks through designing, deploying, and executing a multi‑level leave‑approval workflow using the Activiti BPM engine, covering BPMN diagram creation, Spring Boot configuration, Java code for process initiation and task handling, database tables, key services, and best‑practice development steps.
This guide walks you through designing a multi‑level leave‑approval workflow using Activiti, from drawing the BPMN diagram and configuring the engine to deploying the process, handling tasks, setting variables, and visualizing execution history, all with concise Java code examples and practical tips.
This article explains how to design, configure, and operate an Activiti workflow engine in a Java Spring Boot application, covering BPMN diagram creation, engine setup, deployment, task handling, code examples, API usage, and comparisons with other workflow solutions.
This article explains how to design and implement a multi‑level approval workflow for an office automation system using the Activiti BPMN engine, covering process diagram creation, Spring Boot configuration, Java code for deployment and task handling, database tables, API overview, and comparisons with similar frameworks.
This article explains how to integrate the Camunda 7 workflow engine into a Spring Boot project, covering core concepts, required Maven dependencies, configuration files, database setup, process modeling, task types, gateways, and essential APIs for managing processes, tasks, and variables.
This article explores common limitations of AI agents and demonstrates how BPMN process orchestration, combined with DMN rules and human supervision, can systematically address transparency, error handling, compliance, and rollback challenges, using a medical‑care scenario as a concrete example.
The article explains how orchestrating AI agents with workflow engines like Camunda can overcome trust and transparency challenges, enabling reliable end‑to‑end business processes through decentralized collaboration, control mechanisms, and auditable decision making.
This tutorial walks through setting up a Spring Boot 2.7.5 project with Flowable 6.6.0 and MySQL8, covering environment setup, Maven dependencies, application properties, core Java classes, REST endpoints, process diagram generation, BPMN definition, database tables, and demo screenshots for a complete leave‑approval workflow.
This article provides a step‑by‑step tutorial on integrating the Flowable BPMN workflow engine into a Spring Boot application, covering dependencies, BPMN diagram creation, task configuration, service implementation, process visualization, and common pitfalls such as font issues and process definition updates.
This article explains how to build a multi‑level office approval workflow using the Activiti engine, covering BPMN diagram design, deployment, Java code for process creation, task handling, gateway logic, database schema, API overview, framework comparisons, and further learning directions.
This article introduces the evolution of Java workflow engines, explains core BPMN concepts, and provides a comprehensive tutorial on integrating Flowable with Spring Boot—including Maven dependencies, database configuration, BPMN diagram creation, service task implementation, diagram viewing API, and unit testing.
This article introduces the evolution of Java-based workflow engines, compares Activiti, Flowable, and Camunda, explains core BPMN concepts, and provides a step‑by‑step tutorial for integrating Flowable into a Spring Boot project, including dependencies, BPMN diagram creation, service task implementation, and testing.
This article walks through the evolution of Java‑based workflow engines, compares Activiti, Flowable and Camunda, and provides a complete Spring Boot integration tutorial—including Maven setup, BPMN modeling, service task implementation, diagram generation, unit testing and common troubleshooting—using a concrete leave‑request example.
This article provides a detailed tutorial on using Flowable as a BPMN workflow engine within a Spring Boot application, covering the history of workflow engines, core concepts, Maven dependencies, BPMN diagram creation, process deployment, task configuration, service task implementation, and troubleshooting tips.
Activiti is a BPMN workflow engine that provides components such as Process, Repository, Runtime, Task, and History services, stores definitions, runtime data, and history in a relational database schema, and is used by deploying BPMN diagrams, starting instances, and managing tasks via its Java API.
This article introduces the evolution of Java‑based workflow engines, compares Activiti, Flowable and Camunda, explains core BPMN concepts, and provides a detailed Spring Boot integration tutorial—including Maven dependencies, BPMN diagram creation, service task implementation, REST endpoint for diagram viewing, unit tests, and common troubleshooting tips.
This article explains how to use the Flowable BPMN engine in a Spring Boot project, covering workflow basics, related BPMN concepts, Maven dependencies, diagram creation, service‑task implementation, REST API for diagram viewing, unit testing, and common pitfalls such as font configuration and process definition updates.
This article provides a detailed tutorial on the Activiti 7 workflow engine, covering workflow concepts, BPMN modeling, environment configuration, Maven dependencies, database schema creation, deployment methods, process instance management, task handling, and historical data querying, with complete code examples for Java developers.
This article explains how to design, configure, and code a multi‑level leave‑approval workflow using the Activiti BPM engine, covering process diagram creation, deployment, task handling, exclusive gateways, and database schema while providing complete Java examples and best‑practice recommendations.
This article explains how to design a two‑level leave‑approval process using the Activiti BPMN engine, covering diagram creation, Spring‑Boot configuration, deployment, task handling, exclusive gateways, database tables, API overview, and practical tips for extending the workflow.
This article demonstrates how to design, deploy, and run a two‑level leave‑approval workflow using the Activiti BPMN engine, covering diagram creation, Spring Boot configuration, process variables, task handling, exclusive gateways, database tables, API overview, and best‑practice tips for extending the flow.
This article walks you through designing, deploying, and managing a multi‑level approval workflow using the Activiti engine, covering BPMN diagram creation, Spring Boot integration, database schema, API usage, code examples, and best practices for extending processes without additional code.
This article provides a step‑by‑step guide to building a student leave approval process using Flowable BPMN, Spring Boot 2.7.5, MySQL, and related dependencies, covering environment setup, Maven configuration, application properties, Java classes, REST endpoints, diagram generation, and database tables.
This article explains how to design a multi‑level workflow approval system using the Activiti engine, covering process diagram creation, deployment, task handling, variable management, exclusive gateways, and complete project configuration with Spring Boot and an H2 database.
This article explains how to use the Activiti workflow engine to design a multi‑level leave‑approval process, covering BPMN diagram creation, Spring Boot configuration, deployment, Java code for starting instances, task handling, database schema, API overview, and tips for extending the workflow without additional code.
Covering workflow history, this article explains BPMN standards, outlines core modeling concepts, and demonstrates a practical SmartEngine integration that deploys BPMN 2.0 XML, highlights visual execution benefits, notes limitations in error handling and concurrency, and advises its use for moderately complex, frequently changing processes.
This article provides a step‑by‑step tutorial on installing Flowable‑UI, designing BPMN diagrams, setting up a Spring Boot backend project, configuring the database tables, and using Flowable engine APIs with complete code examples and deployment instructions.
Learn how to set up Camunda, a flexible Java-based BPMN 2.0 workflow engine, within a Spring Boot application by generating a project, configuring dependencies, defining data models and REST endpoints, designing a simple process diagram, and testing the workflow end‑to‑end.
Learn how to set up and integrate the Camunda BPMN 2.0 workflow engine into a Spring Boot application, covering project initialization, Maven dependencies, configuration files, creating a simple user task process, and testing the workflow via Camunda’s web interface.
This article walks Java and Spring Boot developers through installing Camunda, configuring dependencies, setting up the database, creating a simple BPMN process with user and service tasks, and testing the workflow via the Camunda web interface, providing code snippets and screenshots for each step.
This article provides a comprehensive guide to Flowable, a Java-based BPMN 2.0 workflow engine, covering its concepts, BPMN elements, installation, configuration, code examples, and database schema, enabling developers to design and implement employee leave approval processes.
This guide walks through adding Camunda 7 to a Spring Boot project, covering Maven dependencies, configuration files, database schema, BPMN modeling, task types, gateways, API usage, variable handling, listeners, and deployment, providing a complete end‑to‑end workflow solution.
This article introduces the Flowable workflow engine, compares it with other BPM solutions, explains its core concepts, APIs, system tables, BPMN 2.0 modeling, and provides a step‑by‑step quick‑start example with code snippets for building and executing an approval process in a Spring Boot environment.
This guide walks through setting up a Spring Boot 2.2.11 environment with Activiti 7.1, configuring Maven dependencies, explaining the Activiti database tables, defining a BPMN leave‑request process, implementing service and controller layers, and demonstrating API calls to deploy, start, query, and complete the workflow.
This article walks through selecting Camunda 7 as a workflow engine, explains core concepts and components, shows how to integrate it into a Spring Boot project with Maven dependencies, configure the database, deploy BPMN models, and use the rich API for processes, tasks, variables, listeners, and gateways.
This article explains how to integrate the Camunda 7 workflow engine into a Spring Boot project, covering core concepts, required Maven dependencies, configuration files, database schema, process modeling, task types, and detailed API examples for managing processes, tasks, variables, listeners, and permissions.
This article explains how to integrate the Camunda 7 workflow engine into a Spring Boot project, covering core concepts, required Maven dependencies, configuration files, database schema, process modeling, task types, gateways, and detailed API examples for process and task management.
This article provides a step‑by‑step tutorial on downloading Flowable 6.6.0, deploying its UI on Tomcat, designing BPMN diagrams, configuring the required MySQL tables, building a Spring Boot backend project, and using Flowable's Java API to start processes, claim and complete tasks, and query historic data.
This guide walks you through downloading Flowable 6.6.0, deploying the UI on Tomcat, designing a leave‑approval process with events, gateways and user tasks, exporting the BPMN file, setting up a Spring Boot backend, configuring the database, and using Flowable’s core services and APIs with sample code.
The article explains how to create data‑security diagrams that map which participants can access specific enterprise data, recommends breaking large diagrams into role‑based views, and illustrates the approach with UML/BPMN and ArchiMate models while addressing compliance and trust considerations.
The article explains the purpose and structure of application communication diagrams, describes SOA‑oriented component layering, introduces the UML/BPMN EAP profile and Archimate concepts, and provides a detailed list of application component types for enterprise architecture modeling.
This article provides a step‑by‑step guide for integrating Activiti 7 workflow engine into a Spring Boot application, covering Maven dependencies, environment setup, process deployment, task handling, business keys, suspension/activation, candidate users, variables, gateways, and various advanced operations with complete code examples.
This article provides a step‑by‑step guide on integrating Activiti7 into a SpringBoot project, covering Maven dependencies, IDE configuration, deployment of BPMN files, starting and managing process instances, handling tasks, business keys, process variables, candidate users, and gateway configurations, all illustrated with complete Java code examples.
This article provides a comprehensive guide on using Activiti7 in a SpringBoot project, covering Maven dependencies, IDE configuration, process deployment, task handling, business keys, process suspension/activation, candidate users, gateways, and includes complete Java code examples for each step.
JDEasyFlow is an open‑source Java workflow orchestration component from JD's enterprise finance R&D team that supports JSON and BPMN specifications, offers flexible node types, modular architecture, and provides detailed usage examples and implementation principles for building scalable process‑driven applications.
This article provides a comprehensive tutorial on Flowable BPMN, covering the three main gateway types, various methods for setting global, local, and transient process variables, and detailed techniques for querying historical process information, tasks, activities, variables, logs, and identity links.
This article provides a comprehensive tutorial on Activiti 7, covering workflow concepts, engine configuration files, process engine creation methods, service interfaces, BPMN diagram symbols, deployment techniques, task management, process variables, gateway types, and integration with Spring and Spring Boot.
This article provides a comprehensive guide to the Activiti 7 workflow engine, covering its core concepts, Maven dependencies, XML configuration, engine creation methods, service interfaces, process deployment, instance management, task handling, variable usage, gateway types, and integration with Spring and Spring Boot, all illustrated with practical code examples.
This article introduces the need for workflow engines, compares the three major Java‑based engines (Activiti, Flowable, Camunda), explains BPMN notation, and provides detailed guidance on using Flowable's Eclipse Designer, IDEA plugins, flowable‑ui, bpmn.js, and related Vue components to model, deploy, and manage business processes.
This article explains what a workflow is, introduces the Activiti 7 workflow engine, walks through environment setup with Maven and MySQL, and provides complete Java code examples for initializing tables, deploying processes, starting instances, querying definitions, deleting deployments, and retrieving BPMN/PNG resources.
This article provides a detailed tutorial on Activiti 7 workflow engine, covering workflow fundamentals, BPMN modeling, environment setup, Maven dependencies, configuration files, process deployment, instance creation, task querying and completion, process definition management, resource extraction, and historical data inspection, all illustrated with Java code examples.
This guide walks through installing Flowable 6.6.0, deploying its UI, modeling a leave‑approval process, exporting the BPMN file, configuring a Spring Boot backend, understanding Flowable's database tables, and using the engine's APIs to start, query, and complete workflow tasks.
This tutorial walks through creating a basic leave‑approval process using the Flowable BPMN engine in a Spring Boot project, covering project setup, BPMN diagram design, XML definition, and Java code for deploying, visualizing, and handling task approvals and rejections.
This article provides an in‑depth tutorial on Activiti 7 workflow management, covering workflow concepts, system architecture, BPMN modeling, environment setup, Maven dependencies, database configuration, deployment methods, process execution, task handling, and historical data retrieval for Java backend development.
This article demonstrates how to deploy Flowable‑UI, design a BPMN leave‑approval process, configure a Spring Boot backend, explain Flowable database tables, and use the Flowable engine APIs with complete Java code examples to run and manage the workflow.
This article explains what a workflow engine is, why it is used, compares different workflow types, introduces the three major standards BPMN, CMMN, and DMN, and details the core components and design considerations of business process, case, and decision engines.
This article provides a step‑by‑step guide on deploying Flowable‑UI, designing BPMN diagrams, configuring a Spring Boot backend, managing Flowable database tables, and using Flowable engine APIs to implement a complete leave‑approval workflow with code examples.
This tutorial walks through creating a leave‑approval process in Spring Boot 2.3.12 with Activiti 7.1, illustrating how an Exclusive Gateway routes requests based on leave days, how flags control loop‑back or completion, and provides full BPMN, service, and controller code examples.
The article explains how a project context diagram maps work packages to organizational elements and describes UML/BPMN EAP profile elements and an Archimate model centered on a DiscountTravelOrderingSite, while also providing contact information for further discussion.
The article explains how data lifecycle diagrams model business data independently of processes, define stable entity states and transitions, and illustrate these concepts with a UML/BPMN EAP profile example of an order entity, while also providing community and resource links.
The article explains how application and user location maps illustrate the geographic distribution of software usage, development, and hosting, outlines their purposes for capacity planning and support, describes typical user interactions, and introduces UML/BPMN EAP and Archimate profiles for modeling these relationships in enterprise architecture.
The article explains how application migration diagrams map components from baseline to target systems, describes UML/BPMN EAP profile elements such as system, application, entity and process components, and illustrates migration strategies using Archimate with a multi‑version Travel example.
This article explains requirement analysis in software engineering, covering its purpose, key activities, business versus software requirements, and various techniques such as BPMN, ArchiMate, data flow diagrams, use cases, and user stories for capturing and modeling stakeholder needs.
This guide walks through setting up a Spring Boot 2.2.11 project with Activiti 7.1, configuring Maven dependencies, explaining Activiti table prefixes, defining core services, creating a BPMN leave request process, configuring security and datasource, and exposing REST APIs for deployment, execution, and task handling.
This article explains BPMN pools and lanes, their definitions, white‑box vs black‑box pools, lane roles, common misconceptions, typical modeling errors such as missing or misused sequence flows and improper lane usage, and provides corrective solutions for accurate process diagrams.
This article introduces BPMN as an industry‑standard notation for modeling business processes, outlines its key benefits such as stakeholder clarity and vendor neutrality, and explains the five core element categories—swimlanes, flow elements, connecting objects, data, and artifacts—through descriptive text and illustrative diagrams.
This tutorial explains the concepts of BPMN pools and lanes, demonstrates how to model a distilled‑water ordering process for True Aqua using pools, lanes, and nested lanes, and provides step‑by‑step instructions for creating the diagram in a modeling tool.
This tutorial explains how BPMN can be used to model data objects, groups, and text annotations within a business process, demonstrating the technique through a step‑by‑step case study of the True Aqua distilled‑water ordering workflow, including state management and final diagram creation.
This article explains what BPMN (Business Process Model and Notation) is, its purposes, core symbols, and provides step‑by‑step instructions for drawing BPMN diagrams using dedicated software, helping both technical and non‑technical stakeholders visualize and communicate business processes effectively.
The article explains how value chain diagrams provide a high‑level perspective of an enterprise’s direction and external interactions, outlines their purpose in linking stakeholders to change activities, and introduces UML/BPMN EAP profiles and Archimate as modeling approaches, while also promoting related community channels.
The article explains how application and user location maps illustrate the geographic distribution of software usage, support planning of resources and services, describe interaction scenarios, and present UML/BPMN EAP and Archimate profiles to model enterprise architecture components and their deployment across sites.
The article explains the purpose and components of process/system realization diagrams, introduces the UML/BPMN EAP profile and Archimate examples, and includes references and promotional links for enterprise architecture communities.
Zeebe is an open‑source workflow engine that enables visibility, fault‑tolerance and horizontal scalability for end‑to‑end microservice workflows, offering BPMN‑based modeling, append‑only log storage, and language‑agnostic client libraries to orchestrate and monitor complex business processes.
This tutorial explains how to use BPMN’s data objects, groups, and text annotations to enrich a business process model, demonstrating the steps with a True Aqua distilled‑water ordering workflow, including state management for purchase orders and a final annotated diagram.
This article introduces BPMN as an industry‑standard notation for modeling business processes, outlines its key benefits, describes the five basic element categories—including swimlanes, flow elements, connectors, data, and artifacts—and previews a multi‑part tutorial with visual examples.
This article introduces BPMN as a mature, ISO‑standard modeling language, explains why it fits modern microservice orchestration, outlines core workflow patterns such as sequencing, gateways, message correlation, timers, and error handling, and describes the current and upcoming BPMN support in the Zeebe engine.
This article explains the concept of workflow, introduces the open‑source Activiti engine that implements BPMN 2.0, describes its database schema, outlines the basic lifecycle of a workflow, and provides step‑by‑step guidance on creating, deploying, starting, and managing processes with Java and Spring.
This article shares three practical techniques for streamlining Activiti BPMN processes—omitting exclusive gateways by moving conditions to outgoing sequence flows, using skip expressions to bypass unnecessary user tasks, and employing parallel gateways with task listeners to enable multi‑role approvals—complete with XML examples and diagrams.
