Forward-deployed / AI Knowledge Graph
Flowable

Roadmap — Flowable from scratch

The single source of truth for phases and lessons. Status glyphs: ✅ done · 🚧 in progress · ⬚ planned.

Legend: Type is Build (from-scratch implementation) or Use (real Flowable engine) or Concept (no code — PM/architect lesson). Ships is the artifact saved under the lesson’s outputs/.

Phase 0 — Orientation & setup 4 lessons ✅

What Flowable is, where it came from (the Activiti fork), where it sits in the landscape, and getting a local engine running.

# Lesson Type Lang Ships
01 What is a process engine, and when do you want one ✅ Concept — decision guide
02 The Flowable platform map: BPMN, CMMN, DMN, event registry ✅ Concept — platform map
03 Run Flowable locally: Docker, REST API, first ping ✅ Use Python client
04 The landscape: Flowable vs Camunda 7/8 vs Temporal vs DIY ✅ Concept — comparison table

Phase 1 — BPMN & the token model 5 lessons ✅

The execution semantics under every BPMN diagram: tokens moving through a graph. Build a token engine by hand, then deploy real BPMN XML to Flowable.

# Lesson Type Lang Ships
01 Tokens & sequence flow: a process engine in 100 lines ✅ Build Python module
02 Gateways: exclusive, parallel, inclusive ✅ Build Python module
03 BPMN 2.0 XML by hand ✅ Build XML process model
04 Use It: deploy & run on Flowable over REST ✅ Use Python client
05 User tasks vs service tasks: where humans and systems meet ✅ Concept — decision guide

Phase 2 — The engine: state & transactions 5 lessons ✅

Why a process engine is really a state machine with a database: wait states, variables, transaction boundaries, and the job executor.

# Lesson Type Lang Ships
01 Wait states & persistence: why the engine sleeps ✅ Build Python module
02 Process variables & scope ✅ Build Python module
03 Transaction boundaries & async continuations ✅ Concept — cheat sheet
04 The job executor: timers, retries, async work ✅ Build Python module
05 Use It: the embedded engine in Spring Boot ✅ Use Java starter

Phase 3 — User tasks, identity & forms 5 lessons ✅

The human side: task lifecycle, assignment strategies, candidate groups, delegation, and forms.

# Lesson Type Lang Ships
01 The task lifecycle: created → assigned → completed ✅ Build Python module
02 Assignment: assignee, candidate users, candidate groups ✅ Use Python client
03 Identity management: users, groups, and external IdPs ✅ Concept — decision guide
04 Forms: form properties, form keys, external form apps ✅ Use Python client
05 Task queries & the task inbox pattern ✅ Use Python client

Phase 4 — Service integration & error handling 6 lessons ✅

The system side: service tasks, delegates, HTTP tasks, BPMN errors vs technical errors, retries, and compensation.

# Lesson Type Lang Ships
01 Service tasks: delegates, expressions, delegate expressions ✅ Use Java module
02 The HTTP task: calling REST APIs from a process ✅ Use XML process model
03 BPMN errors vs technical errors: two failure planes ✅ Concept — cheat sheet
04 Boundary events: catching errors on an activity ✅ Build Python module
05 Retries & incident handling: what happens when a bureau call fails ✅ Use Python client
06 Compensation: undoing completed work ✅ Concept — pattern guide

Phase 5 — DMN: decisions as tables 4 lessons ✅

Externalise business rules into decision tables the business can read — and change without a deploy.

# Lesson Type Lang Ships
01 A decision engine in 80 lines: rules, inputs, outputs ✅ Build Python module
02 Hit policies: FIRST, UNIQUE, COLLECT and why they matter ✅ Build Python module
03 DMN XML & the decision task: wiring DMN into BPMN ✅ Use XML decision table
04 Who owns the rules? Decision governance for product teams ✅ Concept — decision guide

Phase 6 — CMMN: case management 4 lessons ✅

When work doesn’t follow a fixed path: cases, stages, milestones, and sentries — and the honest answer on when you actually need CMMN.

# Lesson Type Lang Ships
01 Processes vs cases: prescribed flow vs available work ✅ Concept — decision guide
02 Plan items, stages, milestones, sentries ✅ Use XML case model
03 Mixing BPMN and CMMN: process tasks inside cases ✅ Use XML case model
04 When CMMN is overkill (most of the time) ✅ Concept — decision guide

Phase 7 — Events, timers & messaging 5 lessons ✅

Time and the outside world: timer events, signals, messages, and the event registry (Kafka, JMS, RabbitMQ).

# Lesson Type Lang Ships
01 Timer events: ISO-8601 durations, cycles, due dates ✅ Build Python module
02 Message events: correlating the outside world to an instance ✅ Build Python module
03 Signals vs messages: broadcast vs point-to-point ✅ Concept — cheat sheet
04 The event registry: Kafka in, process out ✅ Use Python client
05 Event subprocesses & interrupting vs non-interrupting starts ✅ Use XML process model

Phase 8 — Versioning & migration 4 lessons ✅

Long-running instances outlive their definitions. Version tags, running-instance migration, and deployment strategy.

# Lesson Type Lang Ships
01 Definition versions: what a redeploy actually does ✅ Use Python client
02 Instance migration: moving live tokens to a new version ✅ Use Python client
03 Blue-green for processes: strategies that survive audits ✅ Concept — pattern guide
04 Backward-compatible model changes: a checklist ✅ Concept — checklist

Phase 9 — Operations & observability 5 lessons ✅

Running it for real: history levels, the database, async executor tuning, metrics, and the admin surface.

# Lesson Type Lang Ships
01 The history tables: audit trail vs runtime state ✅ Concept — cheat sheet
02 History levels & data growth: the retention decision ✅ Concept — decision guide
03 Async executor tuning: threads, acquisition, lock times ✅ Use Java settings
04 Metrics & health: what to alert on ✅ Use Python dashboard spec
05 The database is the engine: sizing, indexes, cleanup jobs ✅ Concept — runbook

Phase 10 — Architecture & product decisions 5 lessons ✅

The PM/architect capstone layer: embed vs standalone, multi-tenancy, build vs buy, and the honest competitive landscape.

# Lesson Type Lang Ships
01 Embedded vs standalone vs Flowable Work: deployment topologies ✅ Concept — decision guide
02 Multi-tenancy: shared engine, shared tables, or neither ✅ Concept — decision guide
03 Where the process ends and the domain begins: anti-corruption ✅ Concept — pattern guide
04 Build vs buy vs open source: the workflow TCO conversation ✅ Concept — decision guide
05 Flowable open source vs Flowable Work vs Camunda 8 vs Temporal ✅ Concept — comparison table

Phase 11 — Capstone: loan origination 4 lessons ✅

One end-to-end build: BPMN flow + DMN credit decision + user-task review + bureau service calls + offer-expiry timers + error handling, driven over REST.

# Project Combines Lang Ships
01 The process model: application → decision → offer → disbursal ✅ 1, 4, 7 XML process model
02 The credit decision table ✅ 5 XML decision table
03 The driver: a REST client that runs a full application ✅ 2, 3, 4 Python client
04 Failure drill: bureau down, offer expired, manual override ✅ 4, 7, 9 Python runbook