Flowable

Last reviewed Aug 26, 2026 · 809 words

If you found Flowable while searching for self-hosted automation, it is almost certainly not what you want. It is a business process engine: it executes BPMN 2.0 diagrams, CMMN case models and DMN decision tables, usually embedded inside a Java application that a team of developers maintains. It does not connect to your Gmail, it has no palette of SaaS integrations, and nobody installs it to water the plants. For a Java shop that needs approvals, multi-step human tasks and audit trails as first-class objects, it is one of the 2 serious open-source choices. For everyone else, n8n is the answer, and I say so again at the end.

What a process engine is for

BPMN lets you draw a process (a purchase request goes to a manager, then to finance if over 5,000, then to a script that raises the order) and hand the drawing to the engine, which runs it: creating human tasks, waiting days for someone to complete them, firing timers, calling services, and recording every step for audit. DMN adds decision tables (which approver, which discount) that analysts can edit without code. CMMN covers less linear case work like an insurance claim or an onboarding, where steps are optional and order varies. Flowable ships all 3 engines, standards-compliant, in one library. Its lineage is the Activiti codebase; the core Activiti developers forked it in 2016, and Camunda forked the same codebase 3 years earlier, which is why the two look so alike.

Where it sits in a stack: embedded or REST

The native way to use Flowable is as a Maven dependency. Add flowable-spring-boot-starter, point spring.datasource.url at PostgreSQL, drop .bpmn20.xml files into src/main/resources/processes/, and the engine deploys them at startup. Your application starts process instances and completes tasks through the Java API. That is where the "lightweight" reputation comes from: the engine is a handful of jars and its tables, not a platform.

The standalone option for a self-hoster is the REST application:

services:
  flowable:
    image: flowable/flowable-rest:latest
    ports:
      - "8080:8080"
    environment:
      - SPRING_DATASOURCE_URL=jdbc:postgresql://db:5432/flowable
      - SPRING_DATASOURCE_USERNAME=flowable
      - SPRING_DATASOURCE_PASSWORD=flowable
      - SPRING_DATASOURCE_DRIVER_CLASS_NAME=org.postgresql.Driver
    depends_on:
      - db
  db:
    image: postgres:16-alpine
    environment:
      - POSTGRES_USER=flowable
      - POSTGRES_PASSWORD=flowable
      - POSTGRES_DB=flowable
    volumes:
      - ./db:/var/lib/postgresql/data

The API lives under /flowable-rest/service/ with basic auth; the image ships a rest-admin user with the password test, and changing it is the first job. Without the database block it falls back to an in-memory H2 that forgets everything on restart. Give the JVM 1 GB as a floor. The Hard difficulty rating is about the concepts more than the deployment.

The open-source UI apps are gone; model elsewhere

Older tutorials show Flowable Modeler, Task and Admin web apps in an all-in-one image. Recent open-source releases dropped those; what remains in the community edition is the engine, the REST app and the Java APIs. Modelling happens in Flowable's own Design tool (a commercial product with a free tier at last check) or in any BPMN 2.0 editor, of which the bpmn.io toolkit is the usual free choice. The XML is standard, so a diagram drawn anywhere deploys. If you wanted a self-hosted, click-together process modeller in the browser, that is the thing you no longer get for free, and it is the strongest argument for looking at Camunda before committing.

Flowable, Camunda, n8n: a table because people conflate them

Camunda 7 shared Flowable's embeddable design; Camunda 8 is a different architecture aimed at scale. For a Java team that wants an embeddable engine with an active open-source core in 2026, Flowable is the more direct continuation of that lineage. For a home server, neither belongs in the automation rack.

What I'd do

Running a Java application that needs approvals, SLAs and an audit log: embed Flowable through the Spring Boot starter on PostgreSQL, model in bpmn.io, keep the diagrams in the repository next to the code, and budget a week to learn BPMN properly, because the engine is only as good as the model. Anything less formal than that, including every homelab use I can think of, goes to n8n, or to Node-RED if it is hardware-shaped; the n8n vs Node-RED piece splits those two.