Process Manager

A wedding involves dozens of vendors, caterer, florist, photographer, DJ, venue. Each works independently, but someone needs to coordinate the overall flow: book the venue first, then confirm the caterer based on venue capacity, then schedule the photographer based on the timeline, and if any vendor cancels, adjust the rest.

That coordinator is a process manager. In messaging systems, it's a component that tracks the state of a multi-step business process, sends commands to the right services at the right time, and handles the responses to decide what happens next.

Without a process manager, multi-step workflows become a tangled web of event handlers, each guessing what the others have done. With one, the workflow is explicit, traceable, and manageable.

Consider an order fulfillment flow: reserve inventory, charge payment, ship order, send confirmation. These steps must happen in sequence. If payment fails, inventory must be released. If shipping fails, payment must be refunded. A process manager tracks this state machine and ensures each step triggers the next, or the appropriate compensation if something goes wrong.

The process manager maintains a state machine for each process instance (e.g., each order):

States: [Created] → [InventoryReserved] → [PaymentCharged] → [Shipped] → [Completed]
 ↘ [InventoryFailed] ↘ [PaymentFailed] ↘ [ShipmentFailed]
 ↓ ↓ ↓
 [Cancelled] [ReleasingInventory] [Refunding]
 ↓ ↓
 [Cancelled] [Cancelled]

The process manager:

1. Receives an initiating event (OrderPlaced)
2. Sends a command to the first service (ReserveInventory)
3. Waits for a response event (InventoryReserved or InventoryFailed)
4. Based on the response, transitions to the next state and sends the next command
5. On failure at any step, executes compensating commands (release inventory, refund payment)

class OrderProcessManager {
 async handle(event: DomainEvent, state: OrderState) {
 switch (state.status) {
 case 'created':
 if (event.type === 'OrderPlaced') {
 await commandBus.send(new ReserveInventory(event.orderId, event.items));
 return { ...state, status: 'reserving_inventory' };
 }
 break;
 case 'reserving_inventory':
 if (event.type === 'InventoryReserved') {
 await commandBus.send(new ChargePayment(event.orderId, state.amount));
 return { ...state, status: 'charging_payment' };
 }
 if (event.type === 'InventoryFailed') {
 return { ...state, status: 'cancelled', reason: 'out_of_stock' };
 }
 break;
 // ... More states
 }
 }
}

Process manager vs. Choreography: In choreography, each service reacts to events independently, no central coordinator. In orchestration (process manager), a central component directs the flow. Choreography is simpler for straightforward flows. Process managers are essential for complex flows with conditional branches, timeouts, and compensating actions.