Durable Workflows
for Kubernetes

Build resilient, long-running workflows with regular Go code. Native Kubernetes integration with zero external dependencies.

Get Started View on GitLab

deploy.go

func Deploy(ktx *kontinue.ExecutionContext, args *Args) (*DeployResult, error) {
    // Store results natively, which are memoized if the workflow
    // is resumed from failure
    clusterMetadata, _ := kontinue.Store(ktx, func() (*Order, error) {
        return fetchClusterMetadata(args.ClusterName)
    })
    // Execute child workflows
    res, _ := kontinue.Execute[UpdateResult](ktx, UpdateComponentFn,
        &UpdateArgs{Cluster: clusterMetadata.Target, Env: "test"},
        &kontinue.ExecuteOptions{},
    )
    // Resumable sleep built-in
    _ = kontinue.Sleep(ktx, 1 * time.Hour)

    res, _ = kontinue.Execute[UpdateResult](ktx, UpdateComponentFn,
        &UpdateArgs{Cluster: clusterMetadata.Target, Env: "prod"},
        &kontinue.ExecuteOptions{},
    )

    return &DeployResult{Envs: []string{"test", "prod"}}, nil
}

Built for Production

Everything you need to build resilient, scalable workflows in Kubernetes.

Durable by Design

Every workflow step is automatically persisted. Your workflows resume exactly where they left off after any failure.

Kubernetes Native

All state is stored in Kubernetes resources. No external databases, queues, or services required.

Automatic Retries

Configurable retry policies with exponential backoff. Failed activities automatically retry without workflow restart.

Timers & Scheduling

Sleep for days, weeks, or months. Schedule recurring executions with cron expressions. All persisted and fault-tolerant.

Developer Friendly

Write workflows as regular Go code. No YAML, no DSLs. Full IDE support, debugging, and testing capabilities.

Execellent Tooling

Debug your workflows with the built-in UI or CLI tools, or monitor execution with standard Kubernetes tools.

How It Works

From code to production in three simple steps.

Define Your Workflow

Write workflows as regular Go functions. Use kontinue.Execute to call child workflows.

func Deploy(ktx *kontinue.ExecutionContext, args *Args) (*Res, error) {
    // Execute child workflows
    result, _ := kontinue.Execute[TestResult](
      ktx,
      "run-tests",
      &TestArgs{...},
      &kontinue.ExecuteOptions{},
    )

    return &Res{...}, nil
}

Register with a Worker

func main() {
    w := worker.NewWorker()

    worker.RegisterFunction(
      w,
      "deploy",
      Deploy,
      &function.Options{
        Description: "Run a deployment workflow with tests"
        Arguments:   function.ArgumentMetadata(&Args{}),
    })

    w.Run(ctx, &worker.Options{Namespace: "default"})
}

Execute with Confidence

Start workflows via the CLI, UI, client library or by applying Kubernetes resources. They automatically survive failures and resume from their last checkpoint.

// Spawn a workflow
exec, err := client.Spawn(ctx, "deploy", &Args{
    Cluster: "test-use1",
}, &client.SpawnOptions{})

// Wait for completion
result, err := client.Wait[OrderResult](ctx, exec.Name)

Ready to Build Resilient Workflows?

Get started with kontinue today and build workflows that never fail. Open source, Kubernetes native, and production ready.

Read the Docs Star on GitLab

Durable Workflows for Kubernetes