2nd/10_Wiki/Topics/Architecture/BPM.md

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

id	title	category	status	canonical_id	aliases	duplicate_of	source_trust_level	confidence_score	verification_status	tags	raw_sources	last_reinforced	github_commit	tech_stack
wiki-2026-0508-bpm	BPM (Business Process Management)	10_Wiki/Topics	verified	self	Business Process Management Workflow Automation Process Orchestration	none	A	0.9	applied	enterprise workflow bpmn orchestration		2026-05-10	pending	language framework BPMN 2.0 / Java / TypeScript 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)

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)

<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

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

{
  "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

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)

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

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
• 변형: State-Machine
• 응용: Temporal
• Adjacent: Microservices · Event-Driven-Architecture

🤖 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