SERIES_OVERVIEW // CURRICULUM_MAP

Learn Java BPMN with Camunda BPM Platform 7

// Kaufman-style skill map untuk menguasai Java BPMN dengan Camunda 7 dari mental model, executable BPMN, engine internals, sampai production judgment.

This track is ordered for sequential learning. Start from the first part if you want the full mental model, or jump directly into a chapter if you already know the foundations.

START FROM PART 01 JUMP TO LATEST PART

Total Parts

Reading Load

680

MIN TOTAL

Estimated Commitment

11.3 HOUR LEARNING TRACK

35 PARTS680 MIN TOTALadminanti-patternsapi-designapproval-workflowarchitectureasync-continuation

Curriculum Map

Ordered progression from foundations to advanced topics

PART 0120 MIN

Kaufman Skill Map

Kaufman-style skill map untuk menguasai Java BPMN dengan Camunda 7 dari mental model, executable BPMN, engine internals, sampai production judgment.

PART 0220 MIN

Platform Reality and Version Strategy

Strategi platform Camunda 7: lifecycle, CE vs EE, versioning, deployment style, architecture trade-off, dan migration-aware design.

PART 0316 MIN

Workflow Engine Mental Model

Build the runtime mental model of Camunda 7 as a persistent workflow engine: process definitions, instances, executions, activity instances, tokens, jobs, variables, wait states, and operational state.

PART 0417 MIN

BPMN Executable Subset

Learn the executable BPMN subset that matters in Camunda 7: process structure, events, tasks, gateways, subprocesses, sequence flows, extension attributes, model contracts, readability rules, and executable modeling anti-patterns.

PART 0517 MIN

Token Flow and Gateway Semantics

Deep dive into token flow and gateway semantics in Camunda 7: exclusive, parallel, inclusive, event-based gateways, default flows, deadlocks, race conditions, testing, and production-grade modeling rules.

PART 0619 MIN

Events Deep Dive: Timers, Messages, Signals, Errors, Escalations

Advanced Camunda 7 BPMN event semantics: timer, message, signal, error, escalation, boundary events, event subprocess, correlation, retry policy, and production failure modeling.

PART 0718 MIN

User Task and Human Workflow Engineering

Advanced Camunda 7 user task and human workflow engineering: task lifecycle, assignment, candidate groups, claim/delegate/complete, forms, SLA, audit, authorization, and operational anti-patterns.

PART 0818 MIN

Subprocess, Call Activity, and Process Modularization

Advanced Camunda 7 subprocess and call activity engineering: embedded subprocess, event subprocess, transaction subprocess, reusable process modules, version binding, variable mapping, lifecycle coupling, and modular workflow anti-patterns.

PART 0917 MIN

DMN and Business Rule Integration

Advanced Camunda 7 DMN and business rule integration: decision table modeling, Business Rule Task semantics, DecisionService API, hit policies, versioning, testing, auditability, and rule-engine anti-patterns.

PART 1015 MIN

Process Engine API: Repository, Runtime, Task, History, Management

Advanced Camunda 7 Process Engine API guide: ProcessEngine, RepositoryService, RuntimeService, TaskService, HistoryService, ManagementService, ExternalTaskService, DecisionService, query patterns, application boundaries, and API anti-patterns.

PART 1117 MIN

Command Context, Transactions, Wait States, and Async Boundaries

Command context, transaction boundary, wait state, rollback semantics, asynchronous continuation, and production-grade transaction design in Camunda 7.

PART 1220 MIN

Job Executor Internals: Acquisition, Locking, Retries, and Priorities

Deep dive into Camunda 7 job executor internals, job acquisition, locking, retries, failed jobs, priorities, exclusive jobs, cluster behavior, and operational tuning.

PART 1316 MIN

Variables, Serialization, Scope, and Data Contracts

Deep dive into Camunda 7 process variables, variable scopes, serialization, typed values, transient variables, data contracts, schema evolution, data minimization, and production anti-patterns.

PART 1420 MIN

History, Audit, and Operational Trace

Deep dive into Camunda 7 history, audit, runtime vs historic tables, history levels, HistoryService, user operation log, history cleanup, TTL, regulatory evidence, and operational trace design.

PART 1517 MIN

Incidents, Errors, and Recovery Model

Incident, error, retry, and recovery model for Camunda 7 production systems, including failed jobs, BPMN errors, external task failures, custom incidents, operational runbooks, and anti-patterns.

PART 1613 MIN

Spring Boot Embedded Engine

Spring Boot embedded Camunda 7 engine setup, architecture boundaries, dependency strategy, configuration, auto-deployment, datasource, transactions, bean integration, testing profile, and production anti-patterns.

PART 1715 MIN

Delegation Code: JavaDelegate, Listeners, Expressions, Field Injection

Delegation code engineering in Camunda 7: JavaDelegate, delegate expression, method expression, execution listener, task listener, field injection, variable mapping, transaction side effects, exception semantics, and production-safe coding boundaries.

PART 1816 MIN

Service Task Implementation Patterns

Production-grade service task implementation patterns in Camunda 7: thin delegates, synchronous vs asynchronous execution, side-effect isolation, idempotency, outbox, command handlers, retry policy, connectors, external calls, and anti-patterns.

PART 1922 MIN

External Task Pattern

External Task Pattern in Camunda 7: pull-based workers, fetch-and-lock, topic design, lock duration, retries, BPMN errors, idempotency, worker scaling, and production anti-patterns.

PART 2023 MIN

REST API and Remote Engine Integration

Camunda 7 REST API and remote engine integration: process start, message correlation, user task completion, external task operations, API boundary, authentication, client abstraction, and anti-patterns.

PART 2117 MIN

Testing Camunda Processes

Testing Camunda 7 processes with unit, integration, scenario, failure-path, timer, message, user task, external task, and migration-aware testing strategies.

PART 2222 MIN

Architecture Styles: Embedded, Shared Engine, Remote Engine, Camunda Run

Camunda 7 architecture styles: embedded engine, shared engine, remote engine, Camunda Run, process application deployment, classloader concerns, scaling, ownership, upgrade model, and anti-patterns.

PART 2322 MIN

Database, Persistence, and Performance Engineering

Camunda 7 database, persistence, and performance engineering: ACT_* schema mental model, runtime/history separation, query discipline, job table pressure, history cleanup, indexing strategy, capacity risks, and production anti-patterns.

PART 2417 MIN

Concurrency, Optimistic Locking, Parallelism, and Race Conditions

Camunda 7 concurrency, optimistic locking, parallelism, and race-condition engineering: transaction boundaries, async continuations, exclusive jobs, parallel gateways, multi-instance behavior, external task variables, message correlation races, and idempotent design.

PART 2516 MIN

Message Correlation and Event-Driven Integration

Message correlation and event-driven integration in Camunda 7: business keys, correlation keys, message subscriptions, outbox/inbox, duplicate and late event handling, targeted delivery, event adapters, and production-safe integration boundaries.

PART 2616 MIN

Long-Running Processes, Saga, Compensation, and Consistency

Long-running processes, saga design, compensation, cancellation, timeouts, consistency, and recovery in Camunda 7: how to model business transactions without confusing BPMN transaction subprocesses with ACID transactions.

PART 2719 MIN

Microservices Boundaries and Process Ownership

Microservices boundaries, process ownership, orchestration versus choreography, service autonomy, data ownership, deployment ownership, and failure responsibility when using Camunda 7 in distributed systems.

PART 2821 MIN

BPMN Pattern Catalog for Real Systems

A production-oriented BPMN pattern catalog for Camunda 7 covering approval, maker-checker, SLA escalation, retry and recovery, async orchestration, event-driven continuation, cancellation, reopening, split-aggregate, and batch-triggered workflows.

PART 2926 MIN

Regulatory and Complex Case Management Patterns

Regulatory and complex case management patterns for Camunda 7 BPMN systems, including enforcement lifecycle modelling, evidence workflows, escalation, defensible audit, cross-entity impact, and human override design.

PART 3028 MIN

Dynamic Workflows, Change Management, and Process Instance Modification

Dynamic workflow and change management in Camunda 7, covering process versioning, instance migration, instance modification, restart, suspension, hotfixing, compatibility, and operational governance.

PART 3125 MIN

Anti-Patterns and Common Pitfalls

Camunda 7 anti-patterns and common pitfalls for production BPMN systems, including modeling, transaction, data, integration, operation, and governance failure modes.

PART 3221 MIN

Cockpit, Tasklist, Admin, and Operational Playbooks

Operational handbook for Camunda 7 Cockpit, Tasklist, Admin, incidents, failed jobs, variables, suspension, batch operations, and production runbooks.

PART 3322 MIN

Security, Authorization, and Data Protection

Security, authorization, tenancy, REST/webapp hardening, sensitive variables, audit, and data protection patterns for production Camunda 7 systems.

PART 3423 MIN

Observability, Metrics, and Reliability Engineering

Observability, metrics, SLOs, dashboards, alerting, reliability engineering, and capacity planning for Camunda 7 workflow platforms.

PART 3529 MIN

Capstone Production-Grade Camunda 7 System

Capstone end-to-end production-grade Camunda 7 system design using BPMN, DMN, Java/Spring, external tasks, human workflow, incidents, observability, security, and migration readiness.