DurableStack is a background job runtime that uses your existing database to run deferred work, recurring jobs, and one-off tasks safely in distributed environments.
Execution is coordinated through your database, with lease-based distributed workers, retries, and built-in operational events for tracking what happens in production.
Start today with .NET or Node.js using the same durable execution model.
Configure DurableStack to use your existing SQL provider.
builder.Services.AddDurableStackPostgres(connectionString, options =>
{
options.WorkerName = $"orders-api-{Environment.MachineName}-{Environment.ProcessId}";
});Register recurring execution using cron syntax.
[DurableJob(Name = "email-dispatch", MaxAttempts = 3)]
[RecurringJob("* * * * *", TimeZone = "UTC")]
public sealed class EmailDispatchJob : IDurableJob
{
public Task ExecuteAsync(EmailDispatchArgs args, JobContext context, CancellationToken cancellationToken)
{
return Task.CompletedTask;
}
}
Hook DurableStack traces into your telemetry pipeline.
builder.Services.AddDurableStackOpenTelemetry();
builder.Services.AddOpenTelemetry()
.WithTracing(builder => builder
.AddSource("DurableStack")
.AddOtlpExporter());Queue a one-time job to run immediately.
var runId = await durableClient.EnqueueAsync<SendWelcomeEmailJob>(
new SendWelcomeEmailArgs { Email = "[email protected]" },
cancellationToken);Add tenant identity so telemetry can sync to hosted observability platform (app.durablestack.com).
builder.Services.AddDurableStackPostgres(connectionString, options =>
{
options.Eventing.TenantId = "tenant_123";
options.Eventing.ClientSecret = "your-client-secret";
});Trigger the same recurring job immediately when needed.
var runNowQueued = await scheduleAdmin.RunScheduledJobNowAsync(
jobName: "daily-summary",
cancellationToken);Configure DurableStack with your SQL provider.
import { createDurableStackPostgres } from "durablestack";
const { runtime } = await createDurableStackPostgres({
connectionString: process.env.DATABASE_URL!
});Register recurring execution using cron syntax.
runtime.registerRecurring(
"email-dispatch",
"* * * * *",
"UTC",
async () => {
// run the task
},
{ maxAttempts: 3 }
);Bridge runtime events into your telemetry pipeline.
// DurableStack emits runtime events that can be bridged to your OTel pipeline.
// Wire your event sink to your OpenTelemetry SDK/exporter.Queue a one-time job to run immediately.
const runId = await runtime.enqueue("send-welcome-email", {
email: "[email protected]"
});Add tenant identity so telemetry can sync to hosted Observation (app.durablestack.com).
const { runtime } = await createDurableStackPostgres(
{ connectionString: process.env.DATABASE_URL! },
{
eventing: {
tenantId: "tenant_123",
clientSecret: "your-client-secret"
}
}
);Trigger the same recurring job immediately when needed.
const runNowQueued = await runtime.runScheduledJobNow(
"daily-summary"
);DurableStack is designed to keep background execution predictable, safe, and observable as your application scales.
Uses your existing SQL Server, Postgres, SQLite, or MySQL database to coordinate all job scheduling and execution. No external queue or state system required.
Multiple application instances can run safely at the same time. DurableStack ensures only one worker executes a job using lease-based coordination.
Failed jobs are automatically retried with controlled backoff. If a worker crashes mid-execution, jobs are safely reclaimed and re-run.
Cron-style recurring jobs are materialized into durable execution slots, ensuring consistent execution even in multi-worker environments.
Emit structured runtime events into OpenTelemetry, custom sinks, or the hosted observability dashboard. Use what fits your stack.
No Redis, no RabbitMQ, no separate scheduler service. Everything runs directly from your application database and scales with your existing infrastructure.
Using the optional observability platform, configure alert rules and be notified if anything unexpected happens, such as job failure, an instance going offline, or a long-running execution.
Works across SQL Server, PostgreSQL, SQLite, and MySQL with consistent execution semantics across all providers.
DurableStack doesn't just run background jobs, it gives you a live view into how those jobs behave in production.
As your system scales, you don't have to stitch together logging, metrics, and job state across multiple tools. Execution and observability stay connected through the same runtime model.
You can start with a single worker and a few jobs, and immediately see the same system state you would see in a distributed production environment.
Track runs, success rates, failures, and worker health across all projects and tenants.
Create rules that notify you when failures spike, workers go offline, or jobs start retrying.
Drill into job history, outcomes, durations, and errors to understand what's happening.
Organize by tenants and projects with fine-grained access and clear separation.
Get an overview of system health, job runs, and worker status in real time.
Create rules and get notified when failures spike, workers go offline, or issues occur.
See every job run, its status, attempts, duration, and any errors.
Manage tenants and projects with secure secrets and scoped access.
Click any image to view a larger screenshot.