DBOS workflows make your program durable by checkpointing its state in Postgres. If your program ever fails, when it restarts all your workflows will automatically resume from the last completed step.

You add durable workflows to your existing TypeScript program by registering ordinary functions as workflows and steps:

async function stepOne() {
  DBOS.logger.info('Step one completed!');
}

async function stepTwo() {
  DBOS.logger.info('Step two completed!');
}

async function workflowFunction() {
  await DBOS.runStep(stepOne);
  await DBOS.runStep(stepTwo);
}
const workflow = DBOS.registerWorkflow(workflowFunction);

Workflows are particularly useful for

• Orchestrating business processes so they seamlessly recover from any failure.
• Building observable and fault-tolerant data pipelines.
• Operating an AI agent, or any application that relies on unreliable or non-deterministic APIs.

Read more ↗️

DBOS queues help you durably run tasks in the background. You can enqueue a workflow from a durable workflow and one of your processes will pick it up for execution. DBOS manages the execution of your tasks: it guarantees that tasks complete, and that their callers get their results without needing to resubmit them, even if your application is interrupted.

Queues also provide flow control, so you can limit the concurrency of your tasks on a per-queue or per-process basis. You can also set timeouts for tasks, rate limit how often queued tasks are executed, deduplicate tasks, or prioritize tasks.

You can add queues to your workflows in just a couple lines of code. They don't require a separate queueing service or message broker—just Postgres.

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

const queueName = 'example_queue';

async function taskFunction(task) {
  // ...
}
const taskWorkflow = DBOS.registerWorkflow(taskFunction, { name: 'taskWorkflow' });

async function queueFunction(tasks) {
  const handles = [];

  // Enqueue each task so all tasks are processed concurrently.
  for (const task of tasks) {
    handles.push(await DBOS.startWorkflow(taskWorkflow, { queueName })(task));
  }

  // Wait for each task to complete and retrieve its result.
  // Return the results of all tasks.
  const results = [];
  for (const h of handles) {
    results.push(await h.getResult());
  }
  return results;
}
const queueWorkflow = DBOS.registerWorkflow(queueFunction, { name: 'queueWorkflow' });

// Queue configuration is stored in Postgres, so register the queue after launch.
await DBOS.launch();
await DBOS.registerQueue(queueName);

Read more ↗️

Your workflows are stored as rows in a Postgres table, so you have full programmatic control over them. Write scripts to query workflow executions, batch pause or resume workflows, or even restart failed workflows from a specific step. Handle bugs or failures that affect thousands of workflows with power and flexibility.

// Create a DBOS client connected to your Postgres database
const client = await DBOSClient.create({ systemDatabaseUrl: process.env.DBOS_SYSTEM_DATABASE_URL! });

// Find all workflows that errored between 3:00 and 5:00 AM UTC on 2025-04-22
const workflows = await client.listWorkflows({
  status: 'ERROR',
  startTime: '2025-04-22T03:00:00Z',
  endTime: '2025-04-22T05:00:00Z',
});

for (const workflow of workflows) {
  // Check which workflows failed due to an outage in a service called from Step 2
  const steps = await client.listWorkflowSteps(workflow.workflowID);
  if (steps && steps.length >= 3 && steps[2].error instanceof ServiceOutage) {
    // To recover from the outage, restart those workflows from Step 2
    await client.forkWorkflow(workflow.workflowID, 2);
  }
}

Read more ↗️

Use DBOS to build reliable webhooks, event listeners, or Kafka consumers by starting a workflow exactly-once in response to an event. Acknowledge the event immediately while reliably processing it in the background.

For example:

async function handleMessage(request: Request): Promise<void> {
  const eventId = request.body['event_id'];
  // Use the event ID as an idempotency key to start the workflow exactly-once
  await DBOS.startWorkflow(messageWorkflow, { workflowID: eventId })(request.body['event']);
}

Read more ↗️

Schedule workflows using cron syntax, or use durable sleep to pause workflows for as long as you like (even days or weeks) before executing.

You can schedule a workflow in a few lines of code:

async function scheduledFunction(schedTime: Date, context: unknown) {
  DBOS.logger.info(`I am a workflow scheduled to run every 30 seconds`);
}

const scheduledWorkflow = DBOS.registerWorkflow(scheduledFunction, { name: 'scheduledWorkflow' });

// Schedules are stored in Postgres, so create the schedule after launch.
await DBOS.launch();
await DBOS.applySchedules([
  {
    scheduleName: 'every-30-seconds',
    workflowFn: scheduledWorkflow,
    schedule: '*/30 * * * * *',
  },
]);

You can add a durable sleep to any workflow with a single line of code. It stores its wakeup time in Postgres so the workflow sleeps through any interruption or restart, then always resumes on schedule.

async function reminderWorkflowFunction(email: string, timeToSleep: number): Promise<void> {
  await DBOS.runStep(() => sendConfirmationEmail(email));
  await DBOS.sleep(timeToSleep);
  await DBOS.runStep(() => sendReminderEmail(email));
}
const reminderWorkflow = DBOS.registerWorkflow(reminderWorkflowFunction);

Read more ↗️

Pause your workflow executions until a notification is received, or emit even