Workflow

The type-safe, event-driven workflow orchestration library that scales with your business.

Build robust, distributed workflows in Go with compile-time safety, automatic retries, and horizontal scaling out of the box.

// Define your business logic as type-safe state machines
b := workflow.NewBuilder[Order, OrderStatus]("order-processing")
b.AddStep(OrderCreated, ProcessPayment, PaymentProcessed)
b.AddStep(PaymentProcessed, FulfillOrder, OrderCompleted)

wf := b.Build(kafkaStreamer, sqlStore, roleScheduler)

Why Choose Workflow?

🎯 Type-Safe by Design

Unlike other orchestrators, Workflow leverages Go generics for compile-time guarantees. Catch errors before deployment, not in production.

// Your IDE knows exactly what data flows where
func processPayment(ctx context.Context, r *workflow.Run[Order, OrderStatus]) (OrderStatus, error) {
    // r.Object is typed as *Order, OrderStatus is your enum
    // Compiler catches mismatches before they cause runtime errors
}

⚡ Event-Driven Architecture

Built for modern distributed systems. Steps communicate through durable events, enabling:

• Loose coupling between workflow components
• Automatic retries with exponential backoff
• Horizontal scaling across multiple instances
• Fault tolerance that survives network partitions

🔧 Infrastructure Agnostic

Your choice of database, message queue, and coordination service. Start simple, scale when needed:

// Development: Everything in-memory
wf := b.Build(memstreamer.New(), memrecordstore.New(), memrolescheduler.New())

// Production: Battle-tested infrastructure
wf := b.Build(kafkastreamer.New(), sqlstore.New(), rinkrolescheduler.New())

📊 Built-in Observability

Production-ready monitoring without the setup overhead:

• Prometheus metrics for throughput, latency, and error rates
• Web UI for real-time workflow visualization
• Structured logging with correlation IDs
• Distributed tracing support

Perfect For

• Order Processing: Payment, inventory, fulfillment pipelines
• User Onboarding: Multi-step verification and activation flows
• Financial Operations: Transaction processing with compliance checks
• Data Processing: ETL pipelines with validation and cleanup
• Approval Workflows: Multi-stakeholder review processes

vs. The Alternatives

Feature	Workflow	Temporal	Zeebe/Camunda
Type Safety	✅ Compile-time (Go generics)	❌ Runtime validation	❌ Runtime (BPMN)
Architecture	✅ Event-driven state machines	⚠️ RPC-based activities	⚠️ Token-based execution
Infrastructure	✅ Your choice (adapters)	❌ Requires Temporal cluster	❌ Requires external engine
Deployment	✅ Library in your app	❌ Separate server/workers	❌ Separate engine
Learning Curve	✅ Native Go patterns	⚠️ New concepts & SDKs	❌ BPMN modeling
Language	✅ Go-native	⚠️ Multi-language via gRPC	⚠️ Multi-language

Quick Start

go get github.com/luno/workflow

package main

import (
    "context"
    "fmt"
    "github.com/luno/workflow"
    "github.com/luno/workflow/adapters/memstreamer"
    "github.com/luno/workflow/adapters/memrecordstore"
    "github.com/luno/workflow/adapters/memrolescheduler"
)

type TaskStatus int
const (
    TaskStatusUnknown   TaskStatus = 0
    TaskStatusCreated   TaskStatus = 1
    TaskStatusProcessed TaskStatus = 2
    TaskStatusCompleted TaskStatus = 3
)

type Task struct {
    ID   string
    Name string
}

func main() {
    b := workflow.NewBuilder[Task, TaskStatus]("task-processor")

    b.AddStep(TaskStatusCreated, func(ctx context.Context, r *workflow.Run[Task, TaskStatus]) (TaskStatus, error) {
        fmt.Printf("Processing: %s\n", r.Object.Name)
        return TaskStatusProcessed, nil
    }, TaskStatusProcessed)

    b.AddStep(TaskStatusProcessed, func(ctx context.Context, r *workflow.Run[Task, TaskStatus]) (TaskStatus, error) {
        fmt.Printf("Completed: %s\n", r.Object.Name)
        return TaskStatusCompleted, nil
    }, TaskStatusCompleted)

    wf := b.Build(memstreamer.New(), memrecordstore.New(), memrolescheduler.New())

    ctx := context.Background()
    wf.Run(ctx)
    defer wf.Stop()

    // Trigger a workflow
    runID, _ := wf.Trigger(ctx, "task-1", workflow.WithInitialValue(&Task{
        ID: "task-1",
        Name: "Process Invoice",
    }))

    // Wait for completion
    wf.Await(ctx, "task-1", runID, TaskStatusCompleted)
    fmt.Println("✅ Workflow completed!")
}

Enterprise Ready

Workflow provides enterprise-grade features:

• ✅ Exactly-once processing guarantees via transactional outbox pattern
• ✅ Built-in error handling with pause and retry mechanisms
• ✅ Comprehensive observability via Prometheus metrics and Web UI
• ✅ Horizontal scaling through role-based scheduling
• ✅ Infrastructure flexibility via pluggable adapters
• ✅ Production deployment patterns for various scales

Documentation

Topic	Description
Getting Started	Install and build your first workflow
Core Concepts	Understand Runs, Events, and State Machines
Architecture	Deep dive into system design and components
Steps	Build workflow logic with step functions
Callbacks	Handle external events and webhooks
Timeouts	Add time-based operations
Connectors	Integrate with external event streams
Hooks	React to workflow lifecycle changes
Configuration	Tune performance and behavior
Monitoring	Observability and debugging
Adapters	Infrastructure integration guide

Examples & Tutorials

Example	Description
Order Processing	Complete e-commerce workflow with payments & fulfillment

Community & Support

• 📚 Documentation - Comprehensive guides and examples
• 🐛 Issues - Bug reports and feature requests
• 💬 Discussions - Community Q&A

Installation

go get github.com/luno/workflow

# Production adapters (install as needed)
go get github.com/luno/workflow/adapters/kafkastreamer
go get github.com/luno/workflow/adapters/sqlstore
go get github.com/luno/workflow/adapters/rinkrolescheduler
go get github.com/luno/workflow/adapters/webui

License

MIT License

---

Ready to build reliable workflows? Get started in 5 minutes →