---
id: wiki-2026-0508-bpm
title: BPM (Business Process Management)
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Business Process Management, Workflow Automation, Process Orchestration]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [enterprise, workflow, bpmn, orchestration]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: BPMN 2.0 / Java / TypeScript
  framework: Camunda 8 / Temporal / AWS Step Functions
---

# BPM (Business Process Management)

## 매 한 줄
> **"매 business process 를 매 explicit model 로 만들어 매 measure / improve / automate."**. 1990s 의 BPR (re-engineering) → 2000s BPMS workflow engine → 2010s BPMN 2.0 표준 → 2026 현재 매 cloud-native orchestration (Camunda 8, Temporal, Step Functions) 가 매 microservice + AI agent 의 process backbone. 매 별도로 BPM = Beats Per Minute (music tempo) 도 동음이의 — 매 본 문서는 매 business process 중심.

## 매 핵심

### 매 BPM lifecycle
1. **Design**: BPMN diagram, swim lanes, gateway logic.
2. **Modeling**: simulation, validation.
3. **Execution**: workflow engine 이 매 instance 실행.
4. **Monitoring**: KPI, SLA, bottleneck.
5. **Optimization**: process mining, AI suggestions.

### 매 BPMN 2.0 element
- **Activity** (rounded rect): task — user task, service task, script task.
- **Event** (circle): start, intermediate, end (timer, message, error).
- **Gateway** (diamond): exclusive (XOR), parallel (AND), inclusive (OR).
- **Sequence flow** (arrow).
- **Pool / Lane**: organizational boundary.
- **Data object**: process variable.

### 매 응용
1. Loan approval workflow (origination → underwriting → decision).
2. Order-to-cash (e-commerce → fulfillment → invoicing).
3. Employee onboarding (HR forms → IT provisioning → training).
4. Insurance claim processing (intake → adjuster → payout).
5. AI agent orchestration (매 LLM agent 의 매 multi-step workflow).

## 💻 패턴

### Camunda 8 — BPMN service task (Zeebe)
```typescript
import { ZBClient } from 'zeebe-node';

const zbc = new ZBClient();

zbc.createWorker({
  taskType: 'charge-credit-card',
  taskHandler: async (job) => {
    const { orderId, amount, customerId } = job.variables;
    try {
      const result = await stripe.charges.create({
        amount, currency: 'usd', customer: customerId,
      });
      return job.complete({ chargeId: result.id, paid: true });
    } catch (e) {
      return job.fail(`Stripe error: ${e.message}`);
    }
  },
});
```

### BPMN 2.0 XML — order process (sketch)
```xml
<bpmn:process id="OrderProcess" isExecutable="true">
  <bpmn:startEvent id="Start" />
  <bpmn:serviceTask id="ValidateOrder" name="Validate Order"
                    zeebe:taskDefinition type="validate-order" />
  <bpmn:exclusiveGateway id="StockGateway" name="In stock?" />
  <bpmn:serviceTask id="ChargeCard" zeebe:taskDefinition type="charge-credit-card" />
  <bpmn:userTask id="ManualReview" name="Manual review" />
  <bpmn:endEvent id="End" />
  <bpmn:sequenceFlow source="Start" target="ValidateOrder" />
  <bpmn:sequenceFlow source="ValidateOrder" target="StockGateway" />
  <bpmn:sequenceFlow source="StockGateway" target="ChargeCard">
    <bpmn:conditionExpression>=stockAvailable</bpmn:conditionExpression>
  </bpmn:sequenceFlow>
  <bpmn:sequenceFlow source="StockGateway" target="ManualReview">
    <bpmn:conditionExpression>=not(stockAvailable)</bpmn:conditionExpression>
  </bpmn:sequenceFlow>
</bpmn:process>
```

### Temporal — code-first workflow
```typescript
import { proxyActivities, sleep } from '@temporalio/workflow';
import * as activities from './activities';

const { validateOrder, chargeCard, shipOrder } =
  proxyActivities<typeof activities>({
    startToCloseTimeout: '1 minute',
    retry: { maximumAttempts: 5 },
  });

export async function orderWorkflow(order: Order): Promise<void> {
  await validateOrder(order);
  const charge = await chargeCard(order.amount, order.customerId);
  await sleep('5 minutes');  // hold before fulfillment
  await shipOrder(order.id, charge.id);
}
```

### AWS Step Functions — state machine JSON
```json
{
  "StartAt": "Validate",
  "States": {
    "Validate": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123:function:Validate",
      "Next": "InStock?"
    },
    "InStock?": {
      "Type": "Choice",
      "Choices": [
        { "Variable": "$.inStock", "BooleanEquals": true, "Next": "Charge" }
      ],
      "Default": "ManualReview"
    },
    "Charge": { "Type": "Task", "Resource": "arn:.../Charge", "End": true },
    "ManualReview": { "Type": "Task", "Resource": "arn:.../HumanReview", "End": true }
  }
}
```

### Process mining — discover from logs
```python
import pm4py

log = pm4py.read_xes("orders_event_log.xes")
process_tree = pm4py.discover_process_tree_inductive(log)
bpmn = pm4py.convert_to_bpmn(process_tree)
pm4py.view_bpmn(bpmn)

# Conformance check
diagnostics = pm4py.conformance_diagnostics_token_based_replay(log, bpmn)
print(f"Fitness: {diagnostics['fitness']:.2f}")
```

### Saga pattern (compensation)
```typescript
export async function bookTripSaga(req: TripReq) {
  const compensations: Array<() => Promise<void>> = [];
  try {
    const flight = await bookFlight(req);
    compensations.push(() => cancelFlight(flight.id));
    const hotel = await bookHotel(req);
    compensations.push(() => cancelHotel(hotel.id));
    const car = await bookCar(req);
    return { flight, hotel, car };
  } catch (e) {
    for (const undo of compensations.reverse()) await undo();
    throw e;
  }
}
```

### Human task (UserTask) form
```typescript
zbc.createWorker({
  taskType: 'manual-approval',
  taskHandler: async (job) => {
    // 매 push to UI inbox; resolve when human submits decision
    await pushToInbox({
      taskId: job.key,
      assignee: job.customHeaders.assignee,
      formSchema: job.customHeaders.formKey,
    });
    // job is completed by REST callback when human acts
  },
});
```

## 매 결정 기준
| 상황 | Engine |
|---|---|
| Visual BPMN, business analyst editing | Camunda 8 / Activiti |
| Code-first, complex retry/long-running | Temporal |
| AWS-only stack, simple flow | Step Functions |
| Open-source self-host, light | n8n / Prefect |
| AI agent multi-step | Temporal + LangGraph |

**기본값**: matrix:
- enterprise w/ analyst → Camunda 8
- engineer-driven, durability-critical → Temporal
- serverless on AWS → Step Functions

## 🔗 Graph
- 부모: [[Workflow-Automation]] · [[Enterprise-Architecture]]
- 변형: [[Saga-Pattern]] · [[Process-Mining]] · [[State-Machine]]
- 응용: [[Camunda]] · [[Temporal]] · [[AWS-Step-Functions]] · [[Order-Management]]
- Adjacent: [[Microservices]] · [[Event-Driven-Architecture]] · [[Choreography-vs-Orchestration]]

## 🤖 LLM 활용
**언제**: long-running multi-step process, human-in-loop required, audit trail 필수, retry/compensation 복잡, AI agent multi-tool orchestration.
**언제 X**: 매 simple synchronous CRUD, 매 sub-100ms latency 필수, 매 stateless transform.

## ❌ 안티패턴
- **BPMN diagram = code 동기화 안 됨**: 매 visual model 만 update, 실제 code drift.
- **Workflow engine 의 business logic 과다**: 매 service task 안에 매 거대 conditional → 매 BPM diagram 의 의미 상실.
- **No timeout / no retry**: 매 stuck instance pile up.
- **Saga 의 compensation 누락**: 매 partial state 영구 leak.
- **매 모든 thing 을 workflow**: 매 simple op 도 workflow → 매 latency / debugging cost 폭증.

## 🧪 검증 / 중복
- Verified (BPMN 2.0 OMG spec, Camunda 8 / Temporal 2026 docs, "Process Mining" by van der Aalst).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — BPM (business process) full content with Camunda/Temporal patterns |
