Use Temporal for the durable machine side of a banking operation, Flowable for the human task side, and BIAN to name the business capabilities and Service Domains that each one serves. The two engines should not share state implicitly. Connect them through an explicit business contract that states which system owns each status, how a human decision reaches the saga, and what happens when events arrive late or arrive twice.
One limit frames everything below. The official Temporal, Flowable and BIAN documentation reviewed for this article does not describe a native Temporal–Flowable connector or an official three-way reference implementation. The pattern here is an architecture synthesis built from what each product and standard documents on its own. The integration layer is code your team writes and operates.
As an Amazon Associate I earn from qualifying purchases.
Give each engine one job
The cleanest split comes from asking what each product is built to guarantee. Temporal documents durable workflow execution: workflow tasks are scheduled by events, and workers recover workflow state by replaying event history. Flowable documents user tasks, forms, assignment, and case and process work. BIAN supplies banking capability and Service Domain framing. It is not an executable workflow engine, so it sets vocabulary and boundaries rather than runtime behavior.
Recommended Free Tools
| Concern | Temporal | Flowable | BIAN |
|---|---|---|---|
| Primary role | Durable machine orchestration | Human tasks, forms, assignment, case and process work | Banking capability and Service Domain framing |
| Execution unit | Workflow tasks scheduled by events such as workflow start, signals, updates, activity completion, timers, and child-workflow completion; activities that make attempts at work | User tasks and process steps that collect human information and interact with systems; cases that hold related work and information | Not an execution unit; business scenarios and semantic API concepts are used for modeling |
| Failure model | Workflow task failures are distinguished from workflow execution failures; activity attempts are retried under policy | Asynchronous jobs are persisted, retried, and moved to dead-letter state when they need manual intervention | Not applicable to runtime |
| Owns | Machine progress and coordination of side effects | The human task lifecycle and the recorded human decision | Service Domain boundaries and responsibility vocabulary |
Sources: Temporal tasks documentation for the Temporal column; Flowable process editor documentation and Flowable asynchronous execution documentation for the Flowable column; the BIAN Semantic API Practitioner Guide V8.1 for the BIAN column.
#1 Best Overall
Decide which system owns each status
Every business status needs one authoritative owner. A practical rule: Flowable records what a person did, and Temporal decides what the operation does next. Flowable holds the human task record and the submitted form data. Temporal holds the overall operation state and the decision to continue, compensate, or stop.
| Concern | Authoritative owner | Record of truth | Rule |
|---|---|---|---|
| Overall operation status (pending, approved, rejected, timed out, canceled, failed) | Temporal workflow | Workflow execution history | Changes only when an accepted event is recorded |
| Human task lifecycle (created, assigned, completed) | Flowable | Flowable task and process or case instance | Temporal stores the Flowable instance reference, not a copy to act on |
| Submitted form data | Flowable | Task form submission | Only the fields the next machine step needs are passed to Temporal |
| Side effects on banking systems | Temporal activities calling the system of record | The system of record | Every external call carries an idempotency key |
| Business and correlation identifiers | Temporal, assigned once at operation start | The shared contract | Never regenerated by either engine |
Two patterns cause most of the trouble. The first is both engines making a final decision on the same status. The second is copying a status into both systems with no rule for which copy wins.
How a Temporal workflow waits for a Flowable approval
Temporal’s event model fits waiting well. A workflow that waits resumes when an event schedules its next workflow task. The steps below use that model. The Temporal-to-Flowable call and the Flowable-to-Temporal callback are implemented by an integration service your team builds, because no native connector is documented.
- Accept and validate the request in Temporal. Assign a business case ID and a correlation key once, at operation start, and record both in the workflow history.
- Run an activity that calls the Flowable REST API to start the approval process or case, passing the business case ID as the correlation key. Flowable’s REST API documentation covers BPMN and CMMN surfaces; confirm the exact endpoints for your release.
- Make the start call idempotent. If the same correlation key arrives again, the integration service returns the existing Flowable instance instead of starting a second one.
- Record the returned Flowable instance reference in Temporal’s history and move the operation to pending.
- Start a durable timer for the approval deadline, then wait for a signal that carries the correlated outcome.
- When the person completes the Flowable user task, the integration service sends the outcome to Temporal with the business case ID, request version, outcome, event ID, and the data the next step needs.
- The signal handler checks the correlation key, the request version, and whether a terminal outcome is already recorded. If all checks pass, it applies the outcome. Otherwise it logs the event as stale.
- If the timer fires first, Temporal records the operation as timed out, instructs the integration service to close or cancel the Flowable task, and treats any later human decision as stale.
Use the callback as the primary path. Polling Flowable in a loop is harder to reason about than a correlated callback; a scheduled reconciliation job is a sensible safety net, covered below.
Define the integration contract
The contract is what stops the two engines from sharing hidden state. Version it like any external API and keep payloads small. At minimum it should carry:
- The business case ID, generated once by Temporal and reused by Flowable as its correlation key.
- The Flowable process or case instance reference.
- The request version, so a decision made against an older payload can be recognized.
- An outcome drawn from a closed set, such as approved or rejected. Free-text outcomes make transitions impossible to test exhaustively.
- An event ID, unique per emitted event, used for idempotency.
- Only the data the next machine step needs, not the full form.
- Timestamps and an actor reference for audit correlation.
Transitions and terminal states
| State | Entered when | Set by | Allowed next states |
|---|---|---|---|
| Pending | Flowable instance started and its reference recorded | Temporal workflow | Approved, rejected, timed out, canceled, failed |
| Approved | First accepted approval event for the current request version | Temporal workflow | Terminal for the approval step; the operation continues in its next machine step |
| Rejected | First accepted rejection event for the current request version | Temporal workflow | Terminal for the approval step |
| Timed out | Deadline timer fires before a valid human outcome | Temporal workflow | Terminal; later human decisions are stale |
| Canceled | Upstream cancellation accepted by Temporal | Temporal workflow | Terminal; the Flowable task is closed |
| Failed | Machine-side failure after the retry policy is exhausted, or a contract mismatch | Temporal workflow | Requires operator recovery before any transition |
When a timer and a human decision race, the first terminal event recorded in Temporal’s history should win and the other should be logged as stale. This is a recommended rule rather than behavior either product enforces across the boundary, so write it into the contract and test it.
Rank #4
Failure handling across the boundary
Separate transport retry from business retry
Transport retry repeats a call that did not complete, such as a Flowable start request that timed out. Business retry sends a decision back to a person, such as returning a case for correction. These must not share a counter or a policy. Flowable’s asynchronous execution documentation describes transaction boundaries, persisted jobs, retries, and dead-letter jobs that need manual intervention. Temporal distinguishes workflow task failures from workflow execution failures and counts activity attempts. Keep one retry owner per call: if Temporal retries an activity that itself retries the Flowable request, attempts multiply and duplicates become likely.
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minutePC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Duplicates, reordering, and stale human actions
- Every inbound event carries an event ID. The signal handler records processed IDs and ignores repeats.
- Events can arrive out of order. Compare request versions before applying an outcome.
- A person may act on a task that was reassigned or canceled. The integration service should check the Flowable task state at the moment of callback and reject actions on closed tasks.
- Run a scheduled reconciliation that compares Temporal operation states with Flowable instance states and sends mismatches to an operator queue.
Compensation is a business action
A human rejection or timeout can require undoing machine work already completed, such as releasing a hold or reversing a provisional entry. That undo is a business decision with its own rules, approvals and audit trail. Using a saga does not make it automatic. Define each compensating action explicitly, and state which ones can themselves fail and what happens then.
Best Value
Recovery and troubleshooting
| Symptom | First check | Likely action |
|---|---|---|
| Operation stays pending and no Flowable task is visible | Compare the stored Flowable instance reference with the instance state; confirm whether the start activity completed | Run reconciliation. If no instance exists, restart the start activity with the same correlation key |
| Approval recorded in Flowable, Temporal still pending | Check whether the callback was sent and whether the signal was rejected as stale | Resend the callback with its original event ID; the duplicate check makes this safe |
| Several Flowable instances for one business case | Check how the start endpoint handles repeated correlation keys | Close the extra instances, fix key handling, and add a test for repeated start |
| Flowable job in dead-letter state | Read the job exception and the affected instance | Intervene manually as Flowable’s recovery guidance describes, then reconcile |
| Temporal workflow failed | Determine whether the failure is in workflow task processing or in workflow execution | Recover the operator-side issue first; record any manual transition as a logged event |
| Decision arrives after timeout | Check the terminal state in Temporal’s history | Log as stale and notify the task owner; no state change |
Mapping the design to BIAN Service Domains
Start from the banking capability rather than from the engines. Identify the Service Domain or Service Domains that own the operation, then use BIAN’s semantic API concepts to name the operations and information each side exposes. The BIAN practitioner guide describes its business scenarios and wireframes as archetypal and non-prescriptive. Use them to model and adapt requirements while keeping each Service Domain’s role and purpose intact. A sample scenario is not a mandatory implementation design.
The V8.1 guide reports approximately 320 Service Domains. That figure is version-specific and carries 2020 copyright context, so treat it as a historical reference and check the current BIAN release before describing today’s landscape.
Security, audit and data handling
The official sources reviewed do not establish bank-specific controls for a combined Temporal, Flowable and BIAN design, and BIAN does not impose these as requirements. Treat the items below as design points to validate with your security, risk and compliance teams. None of them is a certification claim.
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Clear out junk files and repair common Windows errors3Fix the driver behind crashes, sound loss and screen glitches- Least-privilege service identities for the Temporal worker, the integration service, and the client used to call Flowable’s APIs.
- Authenticated and authorized callbacks, with the callback endpoint accepting only known senders.
- Protection of data in transit and at rest, including Flowable task form data.
- Minimal payloads: only the fields the next step needs.
- Audit correlation: the business case ID and event ID recorded in logs on both sides.
- Retention rules for workflow histories and task data, which may differ between the two engines.
- Named operational ownership for each engine and for the integration service.
Version and scope limits
- The Flowable documentation reviewed sits under its “latest” path. Product behavior and API surfaces may change, so confirm against your exact edition and release.
- Confirm that your Temporal server and SDK versions support the task behavior your design relies on.
- No performance benchmark or cost comparison is established for this pattern. Sizing and cost decisions need your own measurements.
- End-to-end exactly-once behavior cannot be claimed from either product’s local mechanisms. Design for repeated delivery with idempotent handlers.
Design review checklist
Use these six questions to compare alternative placements of orchestration and human work:
Quick Recap
- Machine-state durability and replay: where does operation state live if a worker restarts while the operation waits?
- Human task assignment, forms and case context: who can see and act on each task, and what context travels with it?
- Business state ownership and contracts: which system owns each status, and is every payload field versioned?
- Retry, timeout, cancellation and compensation: is each one defined, with a named owner?
- Observability and operator recovery: can an operator see both sides of one business case from a single identifier?
- Security, data handling and governance: are identities, retention periods and data location decided?
)
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
