Open-Source Control Plane for DBOS

Take Durable Workflows from Local Dev
to Production on Your Own Terms

Relay is a self-hostable control plane for DBOS Transact applications. Deploy a single binary with zero-dependency embedded storage or clustered PostgreSQL, connect unmodified SDK apps in seconds, and run distributed workflows with automatic retries, step memoization, and recovery on your own infrastructure.

Deploy in 60 Seconds Read Docs GitHub Repository

Embedded Console

Relay Visual Workflow Family DAG View with cubic bezier curves and child workflows

Interactive SVG Workflow Family DAG linking root execution steps to child workflows with outcome-colored cubic bezier curves. Live Sync Real-time workflow events and state updates

Architectural Advantages

Built for Pragmatic Production Teams

Operate durable DBOS Transact applications on your own infrastructure with standard tooling.

Drop-in Protocol Parity

Fully implements the Conductor executor WebSocket protocol across all 32 wire message types and HTTP REST schemas. Unmodified DBOS Python, TypeScript, and Go applications connect out of the box.

Visual Workflow Family DAG

Inspect distributed workflows with an interactive SVG renderer. Graphs multi-level workflow family trees, cubic bezier curves connecting parent steps to child workflows, and interactive pan and zoom controls.

Declarative GitOps Management

Manage applications, queues, cron schedules, alert rules, and API keys as code. The relay apply and export commands integrate directly into automated deployment pipelines.

Built-in Alerting Engine

Autonomous in-process evaluator monitors WorkflowFailure, SlowQueue, and UnresponsiveApplication states with SSRF-hardened dispatch to Webhooks, Slack, and PagerDuty channels.

Dual-Engine Storage

Runs as one statically compiled binary or minimal container. Supports pure-Go embedded SQLite for instant zero-dependency local evaluation, and PostgreSQL for multi-node high-availability production clusters.

Zero Direct App DB Queries

Relay respects clean application boundaries. It never executes raw SQL against an application's internal database schema, communicating strictly through the standard executor protocol.

Deployment Freedom

Why Non-Enterprises Choose Relay

A direct comparison of operating Relay on your own infrastructure versus generic closed cloud alternatives.

Operational Capability	Relay (Open Source & Self-Hosted)	Closed Enterprise Cloud
Self-Hostable Anywhere	✓ Single binary on bare metal, VPS, K8s, or Docker	Closed cloud SaaS only
Storage Options	✓ Embedded SQLite (instant eval) or PostgreSQL (HA clusters, air-gapped)	Proprietary multi-tenant cloud storage
Interactive Web Dashboard	✓ Embedded console with SVG Workflow Family DAG	Hosted SaaS portal only
Declarative GitOps & Automation	✓ Built-in CLI (relay apply & export with YAML)	Manual portal configuration
Integrated Alerting Rules	✓ Built-in Slack, PagerDuty, Webhooks with SSRF guard	Requires commercial enterprise tier
OpenMetrics / Prometheus	✓ First-class /v1/metrics scrape endpoint	Proprietary telemetry export
Licensing & Freedom	✓ Permissive MIT License	Commercial enterprise agreement
Application Code Changes	✓ Zero (Point conductor_url and run)	✓ Zero

Quickstart

Up and Running in 60 Seconds

Start the Relay control plane with your storage engine of choice, then connect your existing DBOS application.

Step 1

Start the Relay Control Plane

Choose pure-Go embedded SQLite for instant zero-dependency local evaluation, or PostgreSQL for high-availability production clusters.

# 1. Download and run the standalone binary with embedded SQLite
curl -fsSL https://github.com/abn/relay/releases/latest/download/relay-linux-amd64 -o relay
chmod +x relay

# 2. Start Relay with pure-Go embedded storage (no PostgreSQL required)
./relay serve --embedded

# 3. Open http://localhost:8090 in your browser to view the web dashboard

# 1. Start Relay with Docker pointing to your PostgreSQL instance
docker run -d \
  --name relay \
  -p 8090:8090 \
  -e RELAY_DATABASE_URL="postgres://relay:password@postgres:5432/relay?sslmode=disable" \
  -e RELAY_LISTEN_ADDR="0.0.0.0:8090" \
  ghcr.io/abn/relay:latest serve

# 2. Open http://localhost:8090 in your browser to view the web dashboard

# 1. Download and run the standalone binary
curl -fsSL https://github.com/abn/relay/releases/latest/download/relay-linux-amd64 -o relay
chmod +x relay

# 2. Run migrations and start the control plane backed by PostgreSQL
RELAY_DATABASE_URL="postgres://user:pass@localhost:5432/relay" ./relay migrate up
RELAY_DATABASE_URL="postgres://user:pass@localhost:5432/relay" ./relay serve

# 3. Open http://localhost:8090 in your browser to view the web dashboard

Step 2

Connect Your DBOS Applications

Point your unmodified Python, TypeScript, or Go application at Relay over WebSocket using standard Conductor configuration.

import os
from dbos import DBOS, DBOSConfig

# Configure unmodified DBOS app pointing to your Relay instance
config: DBOSConfig = {
    "name": "checkout-service",
    "system_database_url": os.environ["DATABASE_URL"],
    "conductor_url": "ws://localhost:8090",
    "conductor_key": os.environ.get("RELAY_API_KEY", ""),
}

DBOS(config=config)
DBOS.launch()

import { DBOS } from "@dbos-inc/dbos-sdk";

// Set environment variables for your DBOS runtime
process.env.DBOS__CONDUCTOR_URL = "ws://localhost:8090";
process.env.DBOS__CONDUCTOR_KEY = process.env.RELAY_API_KEY;

await DBOS.launch();

package main

import (
    "os"
    "github.com/dbos-inc/dbos-transact-golang/dbos"
)

func main() {
    // Configure unmodified DBOS Go application pointing to Relay
    dbos.Launch(dbos.Config{
        AppName:         "checkout-service",
        SystemDBURL:     os.Getenv("DATABASE_URL"),
        ConductorURL:    "ws://localhost:8090",
        ConductorAPIKey: os.Getenv("RELAY_API_KEY"),
    })
}

Take Durable Workflows from Local Dev to Production on Your Own Terms