Why BPM for financial services needs more than a workflow engine
A regulated lender or bank running onboarding, KYC and loan decisions across a core banking system, a document store and several scoring services needs more than a workflow engine that moves tasks along. The process layer itself must produce evidence for each decision: which step ran, who approved it, which rule version applied and what data was used. Once the BPMN engine holds that evidence and routes customer data, it becomes an in-scope system. Under DORA, which has applied since 17 January 2025 to the financial entities it covers, the engine and its hosting sit inside the ICT services that need a register of information entry, a stated data location in each contract, and a tested exit strategy if they support critical or important functions. Confirm with your legal and risk teams which of your processes meet that threshold before the design starts.
Two other regimes often apply to the same engine. Where a process touches cardholder data or could affect the security of the cardholder data environment, PCI DSS applies to the systems involved, so the engine, its database and its admin interfaces need to be scoped in your assessment. Where a process feeds financial reporting, the SEC's guidance on management's report on internal control names program changes, computer operations and access to programs and data as areas an assessor will examine. Practically, this means four-eyes approvals enforced by the engine rather than by convention, change control for BPMN and DMN versions, and access rights for the people who deploy models. The engine's own change approval and testing then become controls you must evidence. Ask your assessor early which of these apply to your processes.
On licensing, the platform choice decides whether production use is possible at all. Flowable is licensed under Apache-2.0, so it can run in production in your own infrastructure without a commercial license, and its commercial add-ons are optional. Camunda 8 source code is under the Camunda License 1.0, which permits use only in non-production environments without a commercial license, so a production Camunda 8 deployment requires a commercial agreement with the vendor. Confirm the current terms in the Camunda License 1.0 text with your counsel before you commit to either path.
Which regulatory requirements shape the process build
This table maps each regulatory requirement in scope to what it means for a BPMN build on Flowable or Camunda, the evidence an assessor will ask for, and where teams usually fall short. Read it as a checklist to take into scoping, since several rows affect the engine's hosting, access model and change process before any process is modeled. The main takeaway is that the process engine itself becomes an in-scope ICT service, so its contracts, exit plans and admin access need the same care as the loan or onboarding flows it runs.
| Requirement | What it means for the BPMN build | Evidence to prepare |
|---|---|---|
| DORA Article 28(3): register of ICT contracts | The engine, its database, hosting and any partner support must each appear as an ICT arrangement in the register if they support a financial function. | Register entries for the engine, supporting services and the implementation partner, kept current after each change. |
| DORA Article 28(8): tested exit strategy | For processes that support critical or important functions, such as loan decisions, you need a documented route to move running instances and models to another engine or version. | Written exit plan, migration test results and a named owner for the transition. |
| DORA Article 30(2): data location and data return | Contracts with partners must state where process data is stored and processed, give notice of changes and cover data return if a provider fails or the contract ends. | Contract clauses on hosting location, change notice and data return, plus a tested export of process history. |
| SEC Release 33-8810: ITGC program changes and access | Changes to BPMN models, DMN tables and engine configuration fall under program change controls. Admin and developer access to the engine falls under access controls. | Change tickets with approver and test evidence for each deployed model, and access reviews for engine admins and modelers. |
| FTC Safeguards Rule 16 CFR 314.4(c)(5): MFA | Applies to non-bank lenders and similar entities under FTC jurisdiction. Every user of the task inbox, modeler and admin consoles needs multi-factor authentication unless the Qualified Individual approves an equivalent control in writing. | MFA configuration per user group, a written exception record where one is used, and sign-in logs. |
| PCI DSS v4.0.1: cardholder data in tasks | If card numbers or sensitive authentication data pass through process variables, forms or logs, the engine, its database and its task UI can fall inside the cardholder data environment. | Scope statement that names where cardholder data enters the process, plus masking or tokenization of those fields before they reach process variables. |
| Swift CSP v2026 (only where payment messaging is involved) | If the process triggers or reviews Swift messages, the controls framework applies with 32 controls, 26 mandatory and 6 advisory, and the controls must be independently assessed annually. | Mapping of process steps to the relevant controls, and confirmation with your Swift counterpart of the assessment scope. |
What data moves through onboarding, KYC and loan processes
The first design decision in a financial services BPM build is which data classes the engine will carry. Onboarding, KYC and loan processes move identity documents, beneficial ownership declarations, sanctions and watchlist screening results, credit bureau inputs and payment account data through process variables and task forms. Each class needs its own rule on what may be stored in a variable, who can read it, and how long it lives. Ask the process owner and the compliance lead to classify every variable in the BPMN model before any task form is built, and treat a variable without a classification as a defect.
Process variables and history tables are not scratch space. Once an engine records who approved a loan, which screening result was attached, and when a task was claimed, those rows become records that an examiner or auditor may ask to see. The history tables therefore need the same retention and access controls as the system of record. Personal data should be limited to references: store a case identifier, a document reference in the core system or document store, and a screening result code, rather than copying passport numbers, full bureau reports or account numbers into variables. Flowable's configuration docs list H2, MySQL, Oracle, PostgreSQL, DB2 and Microsoft SQL Server as supported database types, and the choice affects retention, backup, point-in-time recovery and who holds database credentials. Confirm with your database team whether the engine schema will sit in the same backup and encryption scope as the core banking data, and confirm the retention period for history with your records officer.
Integration points set the boundaries of that data. Core banking provides account and product data, CRM provides customer contact records, credit bureau services return scores and reports, and sanctions or identity verification services return match results. For each interface, document which fields the process reads, which it writes, and which calls leave your network. Confirm in writing with each provider where data is processed and stored, because contracts for ICT services that support critical functions must state those locations under DORA Article 30(2). Map each integration to a named service account with minimal rights, and log each call with its request reference so a screening decision can be traced back to the exact response it relied on.
Which open-source engines fit financial process work and why
Financial process work needs four-eyes approvals, versioned decision rules, and an audit trail that holds up to examination. The engines below differ in license terms, in whether they ship native human task and decision support, and in how much security configuration falls to your team.
Flowable for approvals and decisions
Flowable is Apache-2.0 licensed and provides BPMN for process execution, CMMN for case management, and DMN for decision tables, with Java and REST APIs. This combination is why it is the usual default for four-eyes approvals on loan origination and KYC, where a rule table decides the route and a human signs off. Check that your database, identity source, and task UI are chosen up front, since the engine itself does not ship a production task interface in version 7 and later.
Camunda 8 license limits
Camunda 8 source code is under the Camunda License 1.0, which permits use only in non-production environments without a commercial license. For a bank or lender, this means budgeting for a commercial agreement before any production go-live, not after testing is complete. Ask any vendor or partner to show the license terms that cover the exact production deployment you plan to run.
Temporal needs an Authorizer
The Temporal server is MIT licensed and suits code-first, long-running workflows such as multi-day reconciliations or waiting on external events. Without an Authorizer configured, the default noopAuthorizer allows every API request with no authentication or access control, which is unacceptable for customer financial data. Require a configured Authorizer, mTLS, and a ClaimMapper before any production namespace is exposed to internal users.
Temporal visibility store choices
Temporal's visibility store is separate from its persistence store, and the supported options differ by server version. Elasticsearch or OpenSearch is recommended once you have more than a few workflow executions, so a visibility design belongs in the sizing discussion before you select a database. Confirm the exact supported combination with your target server version before committing.
Node-RED and n8n as integration glue
Node-RED is Apache-2.0 licensed and n8n uses the Sustainable Use License, with files marked .ee requiring an n8n Enterprise License. Both suit connecting core banking, document stores, and notification channels around a process, but they are not where approval logic or audit history should live. Confirm which n8n features you use fall outside the .ee directories before relying on them in a regulated flow.
Airflow for batch reconciliation
Apache Airflow is Apache-2.0 licensed and schedules and monitors workflows defined in code. It fits nightly reconciliations, regulatory extracts, and ledger matching that run without a person in the loop. Keep it out of human task routing, because it has no native task inbox for four-eyes decisions, and let the BPMN engine call Airflow for the batch work it handles.
How production licensing changes the Flowable versus Camunda decision
For a production loan origination, onboarding or KYC process, the engine license is a design input, not a procurement detail. Flowable is licensed under Apache-2.0, so the open source engine can be run in production in the organization's own infrastructure without a license fee for the engine itself. Camunda 8 source code is under the Camunda License 1.0, which permits use only in non-production environments without a commercial license. A financial institution that picks Camunda 8 for production therefore needs a commercial agreement with Camunda before the first live case runs.
- Flowable engines: BPMN, CMMN and DMN engines are Apache-2.0, so production use does not depend on a vendor license for the engine.
- Camunda 8 source: Production use requires a commercial license under the Camunda License 1.0, which should be priced and signed before design starts.
- Support and services: Flowable open source users get a community forum, while professional services and partners are offered separately and priced under their own agreements.
- Commercial add-ons: Flowable Work, Engage, Orchestrate and Design are built on the same engines and add low-code modeling, visual debugging, security controls, monitoring and governance.
- Audit exposure: A license gap discovered during a SOX or PCI DSS review can stop a process that is already live, so confirm terms with the vendor in writing.
Ask each vendor to confirm in writing which products and components the production license covers, including clustering and any enterprise directories.
Pre-production and test environments are where most financial services teams build and verify their process models, decision tables and integrations. The Camunda License 1.0 allows use of Camunda 8 source in non-production environments without a commercial license, which makes development and test work straightforward on that engine. Flowable's Apache-2.0 license applies the same way to every environment, so the team does not need to track a separate permission for staging or UAT.
- Build and unit testing: Developers can model BPMN, CMMN and DMN artifacts and run automated tests on either engine within the non-production terms.
- Staging that mirrors production: If a staging system is used for load tests, disaster recovery drills or pre-cutover checks, confirm whether that use counts as production under the vendor's terms.
- Vendor sandboxes and trial builds: Evaluation builds and hosted trial environments carry their own terms, so keep a record of which build ran where.
- Migration rehearsals: Rehearsing the move of running instances between versions may involve data that is production-like, which can affect the license position.
- Evidence trail: Keep a register that maps each environment to its license basis, which auditors will ask for.
Before a test environment is loaded with real customer or applicant data, check with the vendor whether that use is permitted and how it is classified.
Flowable's commercial products, including Flowable Work, Engage, Orchestrate and Design, are built on the same engines that the open source distribution provides. That means a team that starts on the Apache-2.0 engine is not locked into a different execution model if it later buys a commercial layer. The commercial products add capabilities that many regulated teams eventually want, such as low-code modeling, visual debugging, security controls, monitoring and governance. Those are product decisions with their own license and support terms.
- Same engine core: The commercial products are built on the same engines, so process definitions and running instances are expected to carry over, subject to version checks.
- Low-code modeling and debugging: Visual tools can speed up model changes, but they add a license cost that should be compared with the internal effort they replace.
- Security and governance features: Confirm which security controls, access features and governance functions are included in each commercial product rather than assumed.
- Community forum versus paid support: Open source users rely on the community forum, so production incidents need a contracted support path.
- Vendor and partner costs: Professional services and partners are priced separately, and that cost recurs for upgrades and maintenance.
Ask Flowable to confirm in writing which commercial components, if any, the bank would need to meet its UI, monitoring or governance requirements.
Licensing terms change with product versions, deployment models and how a product is used. Public license texts describe the general position, but a financial institution should not rely on a summary when the design depends on it. Get written confirmation of the license basis for each environment, each component and each product version that will be used, before the process architecture is fixed. The conclusion may change the engine choice, the support model and the budget.
- Scope of the confirmation: Cover production, pre-production, test, disaster recovery and any hosted or managed use.
- Components and extensions: Confirm the status of enterprise directories, add-ons and any code paths that the design depends on.
- Version coverage: Confirm whether the terms apply to the versions you plan to deploy and to future upgrades.
- Legal and procurement review: Have legal and procurement sign off on the written position and store it with the architecture records.
- Third-party engagement: If a partner implements the solution, require them to state the license basis of the components they deliver.
Do not start process design until the written licensing position is in hand and has been reviewed against the planned production environment.
How a financial BPM rollout moves from one process to regulated production
The sequence turns a set of candidate processes into a Flowable or Camunda deployment that runs in the organization's own infrastructure, with each stage producing evidence that auditors, risk teams and the second line can review.
Inventory processes and classify risk
The bank or lender lists the candidate processes, such as loan origination, onboarding, KYC refresh and claims, and records for each one the data it handles, the regulated obligations it touches, the systems it calls and the decisions it makes. Compliance, operational risk and the process owner agree a classification that sets the depth of controls for each process. This step is done when every in-scope process has an owner, a risk tier and a documented list of integrations, and the team has confirmed which processes fall under PCI DSS, DORA or other obligations in the organization's environment.
Model BPMN and DMN with approval rules
Process analysts model the flows in BPMN and move eligibility, pricing and policy rules into DMN decision tables, so that policy owners can review rules without reading code. Four-eyes approvals and segregation of duties are written into the model as separate task assignments, and the rules that prevent the same user from initiating and approving a payment or credit decision are tested against the model. The step closes when a reviewer from the business and a reviewer from risk have signed off the diagrams and decision tables, and each rule has a named owner and a version identifier.
Connect identity, MFA and core systems
Engineers connect the engine to the bank's identity provider so that task assignment follows existing roles and groups, and configure multi-factor authentication for every person who can access the process engine, its task interface or its administration tools. Integrations to core banking, KYC providers and document stores are built with defined service accounts, least-privilege permissions and encrypted credentials. The step is complete when access reviews can be run from the identity system, when an approved exception is documented for any control that is not MFA, and when integration tests show each service account can perform only its intended calls.
Test changes and capture approval evidence
Testers run functional tests on each BPMN and DMN version, including negative cases for the four-eyes rules and for timeouts on long-running steps. Each change goes through a documented request, review and approval in the organization's change system before it is promoted, and the promotion record links to the test results and the approver. This evidence maps to program development, program change and access control areas that auditors examine under IT general controls for SOX purposes. The step closes when a change can be traced from request to test result to production deployment for every process version in scope.
Deploy a clustered engine in production
Platform engineers deploy the engine as a cluster on the organization's infrastructure, with the database, backups and monitoring placed in the same controlled environment. The async executor uses lock owners and lock expiration times stored in the database, so the team checks that expired locks are recovered and that jobs are picked up by a surviving node when one node is stopped in a test. Monitoring covers running processes, failed jobs and queue depth. The step closes when a failover test has been run and recorded, and when the operations team has confirmed the runbook for restarts, backups and restores.
Operate under controlled version migration
After go-live, the operations team manages process versions through the same change path used before launch. When a new BPMN or DMN version is approved, running instances stay on their original version unless a migration plan has been tested, reviewed and approved for that process. Audit history is retained for each instance, showing which rule version decided each case and who approved each step. The step is ongoing, and it is complete for a given change when the migration result, the affected instance count and the decision log have been reviewed and filed with the change record.
How to review automated decisions and prove which rule version decided a case
To prove which rule version decided a case, the decision record must point to an exact, immutable version of both the process definition and the DMN decision table, and the audit history must show who approved each change. In a Flowable or Camunda deployment, the process instance stores the process definition key and version it started on, and each decision task stores the decision table key and version it evaluated. A reviewer should be able to take a loan or onboarding case, read its history, and rerun the same inputs against the recorded versions. Confirm with your engine vendor and your own test environment exactly which history tables and fields your chosen version writes, and whether decision inputs and outputs are captured in history or must be logged separately.
Four-eyes control belongs on rule changes as well as on case approvals. Require that a rule author cannot also approve and deploy the same DMN table, and that the approver's identity, the diff against the prior version, and the test results are stored with the deployment. Keep reviewer identity in the history itself, not only in a ticketing system, so that an auditor can see that the person who approved a credit policy change is a different named user from the person who edited it. Map those identities to your directory service so that leavers and role changes are traceable. Ask your partner how the identity service is wired to your identity provider, because the Flowable docs describe replacing the identity service to integrate with an external store.
Where an AI model contributes to a decision, such as a document classification or a risk summary feeding a DMN table, the logging obligations go beyond the BPM history. Article 12(1) of the EU AI Act requires high-risk AI systems to technically allow automatic recording of events over the system's lifetime, and Article 19(1) requires providers to keep those logs for at least six months unless other law provides otherwise. Whether your use is high-risk, and which retention period your own regulators require, is a question for your legal and compliance teams. Capture the model identifier, prompt and output references, and the rule version that consumed the output in one correlated record, and plan retention accordingly.
Which evidence auditors and examiners ask for and which component produces it
This table maps the evidence auditors and examiners typically request for a financial services BPM deployment to the component that produces it. Read each row as a question an assessor will ask, the system that should hold the answer, and the item to confirm in your own environment. DeployOpen prepares this evidence, but independent auditors assess it.
| Evidence item | Component that produces it | What to confirm before the assessment |
|---|---|---|
| Process definitions and version history | BPM engine deployment repository and the engine's deployment and definition tables | Each live BPMN definition maps to a version, a reviewer and a release record, and retired versions remain queryable |
| Task-level approver records | Task layer and engine history tables, including assignee, claim and completion events | Every loan, onboarding or claim decision names the individual who approved it, with timestamps and no shared accounts |
| Four-eyes and segregation of duties rules | BPMN gateway logic and task assignment rules in the task layer | The maker and checker cannot be the same identity, and tests show the rule blocks a self-approval attempt |
| DMN rule versions behind automated decisions | DMN decision engine, with decision table versions stored alongside each process instance | Each automated decision records which table version and inputs produced the outcome, so past cases can be replayed |
| Access logs and MFA records | Identity provider and administrative consoles for the engine, database and hosting platform | Privileged and operator access is logged, and MFA evidence exists for every individual accessing systems that hold customer data |
| Change tickets and test results | Source control, CI/CD pipeline and change management system | Each process or rule change links to an approved ticket, a test run and a production deployment record |
| Register of ICT contracts for the engine and hosting | Third-party risk register maintained by the institution, with the engine, support and hosting contracts listed | Contracts state service locations, data processing locations, notice of change and data return on termination |
| Exit and transition documentation | Architecture records, migration runbooks and tested recovery procedures | A documented plan exists for moving process definitions and running instances to another engine or host, and it has been exercised |
What financial institutions ask before hiring a BPM partner
What drives the cost of a financial BPM build?
The largest drivers are the number of processes in scope, how many decision points depend on policy rules, how many systems the processes must read from and write to, and how much human task UI must be built. Costs fall into one-time work (process discovery, modeling, integration, task UI, testing, migration of running instances) and recurring work (infrastructure, upgrades, patching, monitoring and support). Ask any partner for a quote that splits these components, names who performs each one, and states which items assume the bank provides access, test environments or subject matter experts. Some of the cost sits in the bank's own time, so the quote should list those dependencies explicitly.
How long does a BPM rollout at a bank usually take?
Duration depends on how many processes move to production in the first release, how many integrations need security review, how many approval chains require sign-off from policy owners, and whether any legacy process instances must be migrated. A single well-scoped process such as onboarding usually takes less time than a suite covering loan origination, KYC and claims together. Change approval, test evidence and production access reviews often add more time than the engineering work. Ask for a written plan that marks each gate, the reviewer for each gate, and the dependencies on the bank's internal teams.
What must the bank provide for a BPM engagement to succeed?
A bank needs to supply named process owners who can confirm how work is done today, policy owners who can approve decision table logic, and a technical contact for identity and integration access. In practice this means directory access for group-based task routing, service accounts or API credentials for core banking, KYC and document systems, and test environments that mirror production data controls. Without these, models stay theoretical and testing slows down. Confirm in the scope which of these the bank owns, the response times it can commit to, and who signs off each process before it goes live.
Can our internal team run the BPM platform after handover?
Yes, if the handover is planned from the start. Internal teams need to operate the engine's infrastructure (database, clustering, monitoring, backups), maintain BPMN and DMN models through a governed change process, and handle routine upgrades. They also need documented runbooks for incident response and instance recovery. Ask a partner what documentation, training and knowledge transfer is included, whether models and code live in the bank's own repositories, and whether ongoing support is a separate retainer. Support is available as a retainer, so the choice between internal ownership and continued support can be made in writing before handover.
How do Flowable and Camunda licenses differ for production use?
Flowable's engines are licensed under Apache 2.0, which permits production use without a license fee for the open source engine itself. Camunda 8 source code is under the Camunda License 1.0, which permits use only in non-production environments without a commercial license. That means a Camunda 8 production deployment needs a commercial agreement with the vendor. Confirm the license terms against the current versions of each project, because a bank that plans to run in production must know the exact terms before choosing an engine. Commercial add-ons for Flowable, such as low-code modeling and monitoring products, are separate from the open source engine and carry their own terms.
Does the BPM engine itself fall under DORA and SOX?
The engine is part of the bank's ICT environment, so it is relevant to both frameworks, but the obligations attach to the bank's arrangements and controls rather than to the software license. Under DORA, a process engine that supports critical or important functions falls within the register of ICT arrangements and needs documented exit and transition plans. Under SOX, the SEC guidance names program development, program changes, computer operations and access to programs and data as IT general control areas, so the engine and its models need change approval, testing before production, and access reviews. Ask the partner to map these controls to the engine and to say what evidence each control produces.
What security controls does a BPM engine need in a bank?
The engine needs authenticated access for every user and service, role-based permissions for starting, claiming and completing tasks, encrypted connections, and separation of duties for model changes and approvals. Process variables often carry customer data, so the design should limit what is stored in variables and how long history is retained. Confirm how the partner handles database access, secrets for integrations, logging of administrative actions, and the mapping of identity groups to task roles. These controls should be stated in the scope and tested before production.
Questions to ask a BPM partner before a financial services project
Start with four-eyes and segregation of duties. Ask the partner to show, in the actual BPMN model, where the second approver is enforced: which user task carries the approval, how the engine blocks the initiator from approving their own case, and how the approver group is resolved from your identity system rather than typed into the model. Ask them to demonstrate a failing test where the same identity attempts both steps. Then ask how DMN decision tables are tested before a rule change goes live: who signs off the table, which regression cases are replayed against the new version, and how the decision version that ruled on each case is recorded in history. A vague answer about testing is a warning sign for eligibility and pricing rules.
Ask how running instances are handled when a process version changes. Long-running loan or onboarding cases can span months, so ask for the migration approach, who approves it, how it is rehearsed on a copy of production data, and how stalled instances are detected afterward. On licensing, ask for written confirmation of which engine and license terms apply to production, since the Camunda 8 source code license permits only non-production use without a commercial license, while Flowable is Apache-2.0. Ask for the license position in writing from the partner and the vendor, not from a sales conversation.
For ITGC and engine change control, ask how the partner documents approval and testing of BPMN and DMN deployments and of the engine itself, and how that evidence maps to the program development, program change and access control areas named in SEC Release 33-8810. Ask how task users authenticate: whether MFA is enforced at the identity provider for everyone who can access a task, and how any exception would be approved in writing by the Qualified Individual under 16 CFR 314.4(c)(5) where that rule applies. Finally, for DORA, ask which contract terms they will document: the location of services and data under Article 30(2), data return on termination, and a tested exit strategy and transition plan under Article 28(8). Confirm these in the contract and in the register of information under Article 28(3) before work starts.
Integration points and deployment pattern for a regulated bank
A Flowable engine in a bank rarely runs alone. It sits between core banking, KYC and screening services, and the identity provider, and it writes its own history store that auditors will read. The cards below cover the components to connect, the database and clustering decisions, and the hosting and monitoring controls that the engine depends on.
Core banking and loan systems
Process tasks that move a loan application forward need reads and writes against the core banking ledger, the loan origination system and the collateral register. Each call should be a service task with an explicit timeout, retry count and compensating step, so a failed call leaves a visible incomplete state rather than a silent gap. Confirm which system owns each data item and whether the process stores a reference or a copy of it in process variables.
KYC and screening services
Onboarding and periodic review depend on identity verification, sanctions and politically exposed person screening, and adverse media checks from third-party providers. Model each provider call as a separate, logged step with its request reference and response status, so the decision record shows which screening result was used. Ask each provider where its data is processed, since that answer belongs in the contract and in your DORA register of information.
Identity provider with MFA
Every person who opens a human task, approves a step or changes a model must authenticate through the bank's identity provider with multi-factor authentication. Map identity groups to Flowable candidate groups and keep that mapping under the same access review as other production systems. Flowable's identity service can be replaced with a custom implementation, so confirm how the group sync is built and tested before go-live.
Database and history store
Flowable supports H2, MySQL, Oracle, PostgreSQL, DB2 and Microsoft SQL Server, and the choice affects backup, replication and audit tooling. Use a production-grade database with point-in-time recovery and keep the history tables on the same retention schedule as the business records they describe. Note that MySQL versions below 5.6.4 lack millisecond precision, which matters for audit timestamps.
Clustered nodes and async executor
Run several Flowable nodes against one database so that timers and asynchronous jobs survive a node failure. The async executor stores lock owners and lock expiration times in the database, so when a node stops, its expired locks are recovered and other nodes pick up the jobs. Test this with a deliberate node kill during a timer-driven step, because a missed timer on a repayment or deadline process is a regulatory finding, not a technical inconvenience.
Private hosting and actuator monitoring
Host the Kubernetes cluster or virtual machines in the bank's network, with no public ingress to the engine's REST API or admin endpoints. Expose the /actuator/flowable endpoint only to the monitoring network and feed it into the bank's alerting, tracking running processes and failed jobs. Ask your partner to document which endpoints are reachable from which network zone, since this is the evidence a control reviewer will request.
How DeployOpen scopes and supports regulated BPM work
DeployOpen plans, implements, integrates, hardens, documents and supports self-hosted open-source process platforms inside the client's own infrastructure. For financial services BPM, that means the process engine, its audit history and its integrations are built to produce the evidence that examiners, auditors and internal control owners will ask for.
How we scope
- Written scope names the processes in play, such as loan origination, onboarding, KYC or claims, before any build work starts.
- Scope lists which approvals need four-eyes controls and which decision tables carry policy rules that need a named owner.
- Scope records the engine choice, the license position for production use, and the data residency terms for process variables.
How we build
- Engineers model BPMN processes, decision tables and human task forms, then connect them to core banking, KYC and document systems.
- Build covers identity integration, segregation of duties on approval tasks, and audit logging of who decided what and when.
- Testing includes negative cases for approval bypass, timer escalation and decision table changes before any production release.
How we hand over
- Handover includes process models, decision table versions, runbooks and the configuration of the engine and its database.
- Documentation maps each control to the evidence the process generates, so control owners can explain the trail to assessors.
- Operators are trained on upgrades, running instance handling and the change approval steps the client applies to the engine itself.
How we support
- Ongoing support, upgrades and continuous testing are available as retainers after the fixed-scope engagement closes.
- Retained support covers engine upgrades, security patching and re-testing when processes or decision tables change.
- Confirm with DeployOpen in writing which support hours, response terms and upgrade cadence apply to your scope.

