workflow-orchestration-patterns

Design durable Temporal workflows with saga patterns and determinism constraints.

Updated Feb 26, 2026
One-click install
npx skills add https://github.com/TheGreatL/KanbanBoard --skill workflow-orchestration-patterns-thegreatl
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: workflow-orchestration-patterns
Source: https://github.com/TheGreatL/KanbanBoard/tree/main/.agents/skills/workflow-orchestration-patterns
Command: npx skills add https://github.com/TheGreatL/KanbanBoard --skill workflow-orchestration-patterns-thegreatl

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill provides a comprehensive guide to designing and implementing robust, durable workflows for distributed systems, ensuring reliability and fault tolerance in complex processes.

Core Features & Use Cases

  • Workflow vs. Activity Separation: Understand the distinct roles and constraints of orchestration logic versus external interactions.
  • Saga Pattern: Implement distributed transactions with compensation logic for reliable rollbacks.
  • Entity Workflows: Manage the lifecycle of individual entities with persistent, stateful workflows.
  • Parallel Execution: Design fan-out/fan-in patterns for efficient parallel task processing.
  • Async Callbacks: Handle external events and human approvals gracefully.
  • Determinism & State Management: Ensure workflow consistency and automatic state preservation.
  • Resilience: Configure retries, handle idempotency, and use heartbeats for long-running tasks.
  • Use Case: Orchestrating a multi-step e-commerce order fulfillment process that involves inventory checks, payment processing, shipping, and customer notifications, with built-in error handling and compensation for each step.

Quick Start

Use the workflow-orchestration-patterns skill to understand how to implement the saga pattern for distributed transactions.

Frequently Asked Questions about workflow-orchestration-patterns

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I implement the saga pattern for distributed transactions in microservices?

To implement the saga pattern for distributed transactions, you design workflows with compensation logic for each step to ensure reliable rollbacks. This approach manages complex business logic across microservices while maintaining fault tolerance and reliable execution.

How do I build durable workflows for long-running processes in distributed systems?

Build durable workflows for distributed systems by separating orchestration logic from external interactions as activities. This pattern ensures automatic state preservation, consistency, and fault tolerance for reliable execution of complex business logic.

What is the difference between a workflow and an activity when orchestrating microservices?

In microservice orchestration, a workflow defines the deterministic orchestration logic and state management, while an activity handles external interactions. Separating these roles ensures workflow consistency and automatic state preservation across distributed systems.

How do I handle state management and determinism constraints in distributed workflow orchestration?

Handle state management and determinism constraints in distributed workflow orchestration by isolating external interactions into activities. This ensures workflow consistency, enables automatic state preservation, and satisfies the determinism requirements for reliable execution.

What's the best way to configure retries and handle idempotency for long-running tasks?

The best way to configure retries and handle idempotency for long-running tasks is to use heartbeats and compensation logic within a durable workflow. This resilience approach ensures fault tolerance and reliable execution of complex processes.

Do I need a specific framework to manage entity workflows and handle external events?

Managing entity workflows and handling external events requires a framework that supports durable execution and async callbacks. Using a system like Temporal provides the necessary state persistence, fault tolerance, and parallel execution capabilities for these processes.