KEY RESPONSIBILITIES
Lead process discovery workshops with business analysts, product managers, and compliance officers to
capture and formalise banking workflows as BPMN 2.0 / CMMN specifications.
Design, implement, and maintain Flowable process definitions: user tasks, service tasks, gateways,
boundary events, timers, escalations, and compensation handlers for complex banking scenarios.
Embed Flowable engine within Spring Boot microservices; configure process application packaging,
deployment strategies, and multi-tenant process isolation.
Develop Java service task delegates, execution listeners, and task listeners that integrate Flowable
processes with downstream microservices - collaborating closely with the Backend Engineer who owns
those APIs.
Model decision logic using Flowable DMN (Decision Model and Notation) to externalise business rules
such as credit scoring tiers, AML risk thresholds, and product eligibility matrices.
Design and implement human workflow: task assignment strategies, candidate groups, swimlane
escalation, delegation chains, and SLA-driven timer escalations.
Build and maintain process observability: Flowable process instance metrics surfaced through Prometheus
and Grafana; SLA breach alerting; audit trail completeness for regulatory reporting.
Write comprehensive process unit tests (Flowable JUnit support), scenario integration tests, and process
regression suites integrated into Git Hub Actions CI pipelines.
Define and enforce process versioning and migration strategies; manage process definition upgrades
without disrupting in-flight instances.
Own process PII handling: ensure sensitive customer data flowing through tasks is masked in Flowable
history tables, audit logs, and process variables consistent with UAE PDPL and CBUAE requirements.
Collaborate with the Backend Engineer to co-design API contracts and Kafka event schemas that serve as
integration points between process tasks and microservices.

Participate in agentic SDLC practices: author machine-readable process specs (BPMN XML + markdown
ADRs) that guide AI-assisted tooling; use Git Hub Copilot to accelerate delegate and test authoring.
Mentor junior engineers and business analysts in BPM best practices; establish process modelling
standards and review guidelines for the team.
Act as the escalation point for production process incidents: diagnose stuck instances, replay failed jobs,
manage dead-letter job queues, and post incident reviews.

REQUIRED TECHNICAL SKILLS

Flowable BPM BPMN 2.0 CMMN DMN
Java 17+ Spring Boot 3.x REST / OpenAPI Kafka Events
Process Testing Git Hub Actions Maven / Gradle Prometheus
Grafana Bank PII Handling OAuth2 / OIDC Agentic Dev

DETAILED TECHNICAL REQUIREMENTS
Flowable Platform - Core (Primary Skill)
Flowable 6.x / 7.x: Flowable Engine, Flowable REST, Flowable Modeler, Flowable Admin, Flowable IDM -
architecture, configuration, and operational management
BPMN 2.0 mastery: all task types (user, service, script, send, receive, call activity, sub-process), all
gateway types (exclusive, inclusive, parallel, event-based, complex), all event types (start, end,
intermediate, boundary - timer, error, signal, message, escalation, compensation)
CMMN 1.1: case plan model, stages, human tasks, process tasks, sentries, milestones - for
adaptive/unstructured processes such as complaints handling and credit review
DMN 1.2: decision tables, hit policies (UNIQUE, FIRST, COLLECT, RULE ORDER), decision requirements
diagrams - externalising rule logic from process models
Process application packaging: Spring Boot auto-deploy, BAR files, version management, tenant-aware
deployments
Process variable management: serialisation strategies, variable history levels (none / activity / full), large
variable handling, variable encryption for PII
Flowable history configuration: Duration Based History Manager, async history, history cleanup policies for
regulatory retention compliance
Job executor tuning: async executor thread pool sizing, failed job retry policies, dead-letter job
management and replay
Flowable event listeners: Activiti Event Listener implementations for cross-cutting concerns (audit, metrics,




PII scrubbing)
Process Integration with Microservices
Java Delegate / Delegate Execution patterns: Spring bean injection into delegates, transactional boundaries
between process and service layer
Flowable REST API: programmatic process start, task query/claim/complete, variable update, process
instance migration - consumed by Backend Engineer's APIs
Kafka integration: service tasks publishing domain events; boundary message events consuming Kafka
topics for process correlation (e.g. KYC completed, payment settled)

External worker pattern (Flowable External Worker API): decoupled, scalable job processing for long-
running service tasks

Synchronous REST service tasks: HTTP task connector configuration, error handling with boundary error
events, retry with exponential back-off
Form engine: Flowable Form (JSON forms), dynamic form rendering integration with frontend, form
variable binding and validation

Java & Spring Boot
Java 17+: proficiency sufficient to implement delegates, listeners, DMN beans, REST clients, and unit tests
independently
Spring Boot 3.x: auto-configuration, Spring Data JPA (for process DB), Spring Security (task-level RBAC),
Spring Web for REST task endpoints
Dependency injection into Flowable delegates; Spring transaction management around task completion
Maven / Gradle: multi-module builds, Flowable Spring Boot starter BOM, dependency version alignment
with Backend Engineer's shared BOM
Testing & Quality
Flowable JUnit 5 support: Flowable Rule / Flowable Extension, in-memory H2 engine for unit tests, process
scenario assertions
Scenario-based integration tests: drive process end-to-end with Testcontainers (Postgres + Flowable),
mock service task delegates with Mockito/Wire Mock
Process regression suite: automated happy-path and exception-path execution on every PR; integrated in
Git Hub Actions
SLA test coverage: timer-triggered escalation tests, boundary event compensation tests, dead-letter replay
tests
Performance profiling of high-volume process deployments: concurrent instance throughput, DB
connection pool sizing
Observability, Monitoring & SLA Management
Instrument Flowable process metrics via Micrometer: active instances by process key, task age by
assignee, SLA breach count, failed job rate

Grafana dashboards: process funnel visualisations, SLA heatmaps by business unit, in-flight instance drill-
down

Prometheus alert rules: SLA breach thresholds, stuck instance detection, dead-letter queue depth
Structured process audit logs: tamper-evident event stream of all task lifecycle events (assigned, claimed,
completed, delegated, escalated) for CBUAE examination readiness
CI/CD & Deployment
Git Hub Actions pipelines: process unit test integration test process app build deploy to
dev/UAT/prod with environment gates
Process deployment automation: Flowable REST deployment API called from pipeline; blue/green process
version rollout strategy
Container packaging of Flowable Spring Boot apps; AWS ECS/EKS deployment coordinated with Backend
Engineer's service deployments
Maven / Gradle build for process apps: BAR generation, process resource inclusion, shared library
versioning
Security, PII & Regulatory Compliance
Task-level access control: candidate users/groups mapped to LDAP/AD roles via Flowable
IDM; integration with OAuth2/OIDC JWT claims for task authorisation
PII in process variables: field-level encryption of Emirates ID, account numbers, and biometric references
stored in Flowable variable history
Flowable history table PII masking: post-completion variable scrubbing aligned to UAE PDPL data
minimisation requirements
CBUAE audit trail requirements: complete, immutable event history for regulated processes (KYC, AML,
loan approval)



- configurable retention periods
PCI-DSS scope awareness: ensure card data never enters Flowable process variables; tokenised
references only
Secrets management: Flowable DB credentials and REST connector credentials sourced from AWS
Secrets Manager; no hardcoded values
Process Modelling Standards & Governance

BPMN naming conventions, swimlane discipline, element ID standards, and documentation attributes -
establish and enforce team guidelines
Spec-Driven Process Development: author process spec documents (narrative + BPMN XML) and ADRs
before implementation; align with OpenAPI specs co-authored with Backend Engineer
Process versioning policy: when to increment version vs. patch; in-flight instance migration scripts; sunset
of deprecated versions
Agentic SDLC: write structured process specs that guide Git Hub Copilot for delegate scaffolding; review
AI-generated BPMN for correctness
BANKING PROCESS DOMAIN KNOWLEDGE
Hands-on experience modelling one or more of the following banking process domains is strongly preferred:
Customer Onboarding & KYC: identity verification, document collection, AML screening, risk scoring,
approval workflows, regulatory SLAs
Loan Origination: application intake, credit assessment, underwriting, conditional approval, disbursement,
exception handling
Trade Finance: Letter of Credit lifecycle, document presentation, discrepancy handling, bank-to-bank
messaging workflows
Payments & Settlements: payment initiation, sanction screening, nostro reconciliation, exception
management
Compliance & Audit: CBUAE regulatory reporting workflows, internal audit trails, breach escalation and
resolution processes
Customer Service & Complaints: case management (CMMN), SLA-driven escalation, multi-channel
resolution tracking
BEHAVIOURAL & QUALIFIED COMPETENCIES
Process Ownership - treats every deployed process as a live product; monitors SLA health proactively;
advocates for process quality in every review.
Collaborative Bridge-Builder - works fluently with both technical engineers (Backend, QA, Dev Ops) and
non-technical stakeholders (business analysts, compliance, operations).
Analytical & Detail-Oriented - models edge cases, exception paths, and compensation flows with the
same rigour as happy paths.
Regulatory Mindset - understands that banking processes carry legal and regulatory weight; never
sacrifices auditability for convenience.
Communicator - translates BPMN complexity into plain language for business audiences; writes clear
process documentation and runbooks.
Continuous Learner - keeps pace with Flowable platform releases, BPM industry patterns, and UAE
regulatory changes.
QUALIFICATIONS & EXPERIENCE
6+ years of professional software engineering experience; 4+ years hands-on with Flowable (or Activiti,
Camunda with willingness to migrate to Flowable).
Proven delivery of end-to-end BPM solutions in production - not just modelling, but embedding,
deploying, and operating process engines at scale.
Strong Java / Spring Boot development capability - sufficient to implement delegates, REST clients, and
tests without Backend Engineer assistance.
Experience in banking, fintech, insurance, or other regulated financial services domain is strongly
preferred.
Bachelor's or Master's degree in Computer Science, Engineering, or related field (or equivalent
professional experience).
Experience in an Offshore Development Center or distributed engineering model is an advantage.
OMG BPMN certification or Flowable training certification is a plus.

NICE TO HAVE
Experience with Flowable Work (low-code process app platform) and Flowable Engage
Exposure to intelligent process automation: integrating ML inference or LLM-based agents as service tasks
within BPMN processes
Knowledge of SWIFT messaging standards (MT/MX) relevant to trade finance and correspondent banking
workflows
Familiarity with CBUAE Open Banking API framework and its compliance workflow implications
Event Sourcing patterns for process state reconstruction and audit
Experience with RPA tools (UiPath, Automation Anywhere) as a complement to BPM for legacy system
integration

📌 Senior Flowable Process Engineer (Bengaluru)
🏢 TRIGENT SOFTWARE PRIVATE
📍 Bengaluru