Reliable backends,
built effortlessly

Reliable backends,
built effortlessly

DBOS provides an open-source library for building reliable and observable programs.
Add a few annotations to your program to make it resilient to any failure.

Start your project
Durable execution
Event-driven processing
Cron jobs
Data pipelines
Reliable AI agents
Webhooks & notifications

Durable workflow orchestration

Write your business logic in normal code, with branches, loops, subtasks, and retries. The DBOS Transact library makes it resilient to any failure.

See an example
@DBOS.workflow()
def checkout_workflow(items):
   order = create_order()
   reserve_inventory(order, items)
   payment_status = process_payment(order, items)
   if payment_status == 'paid':
       fulfill_order(order)
   else:
       undo_reserve_inventory(order, items)
       cancel_order(order)

Event-driven processing

Consume Kafka messages exactly-once, no need to worry about timeouts or offsets.
See an example
@DBOS.kafka_consumer(config,["alerts-topic"])
@DBOS.workflow()
def process_kafka_alerts(msg: KafkaMessage):
  alerts = msg.value.decode()
  for alert in alerts:
    respond_to_alert(alert)

Cron jobs made easy

Schedule your durable workflows to run exactly once per time interval.
See an example
@DBOS.scheduled("0 * * * *") # Run once an hour
@DBOS.workflow()
def run_hourly(scheduled_time: datetime, actual_time: datetime):
   results = search_hackernews("serverless")
   for comment, url in results:
      post_to_slack(comment, url)

Resilient data pipelines

Build data pipelines that are reliable and observable by default.
DBOS durable queues guarantee all your tasks complete.
See an example
queue = Queue("indexing_queue")

@DBOS.workflow()
def indexing_workflow(urls: List[HttpUrl]):
  handles: List[WorkflowHandle] = []
  for url in urls:
     handle = queue.enqueue(index_document, url)
     handles.append(handle)
indexed_pages = 0
for handle in handles:
     indexed_pages += handle.get_result()
logger.info(f"Indexed {len(urls)} documents totaling {indexed_pages} pages")

Reliable AI agents

Enhance your AI workflows with DBOS, build reliable AI agents with automatic retries and no limit on how long they can run for.
See an example
@DBOS.step(retries_allowed=True, max_attempts=2)
def process_refund(item, reason):
    return f"Processed refund for item {item}, because {reason}"

@DBOS.step(retries_allowed=True, max_attempts=3)
def apply_discount(amount):
    return f"Applied discount of {amount}%"

refunds_agent = Agent(
    name="Refunds Agent",
    instructions="Help the user with a refund. If the reason is that it was too expensive, offer the user a refund code.",
    functions=[process_refund, apply_discount],
)

Webhooks & notifications

Effortlessly mix synchronous webhook code with asynchronous event processing. Reliably wait weeks or months for events, then use idempotency and durable execution to process them exactly once.
See an example
@slackapp.message()
def handle_message(request: BoltRequest) -> None:
  event_id = request.body["event_id"]
  with SetWorkflowID(event_id):
    DBOS.start_workflow(message_workflow,     request.body["event"])

"I love the design of DBOS. If you're a gamer, it's like having a “save point” in your programs. If a function fails, a new function can start, picking up at the last checkpoint."

Paul Copplestone
CEO & Co-Founder, Supabase.com

"With DBOS, developers can build applications in days that now take months with conventional approaches."

Matei Zaharia
Co-Founder, Databricks

“What took us 2 months to build using a labyrinth of AWS resources took just 2 days with DBOS.”

Thomas McNally Portrait
Thomas McNally
VP Technology, TMG.io

"DBOS isn't kidding when they say they make serverless simple. Their claims about speed and ease are right on."

Vince Fulco - Portrait
Vince Fulco
Co-Founder, Bighire.io

Make code durable and observable in minutes

Durable & observable  in minutes, not months.

Open Source DBOS Transact

Lightweight open source durable execution library.
Simply add a few annotations to your program to make it resilient to any failure.
Abstract away the complexity of dealing with crashes, network outages, flaky endpoints, and infrastructure nuances.
Built-in observability–emit OpenTelemetry traces and monitor the execution of your workflows in real time.
DBOS Transact Quickstart

Reliability at any scale, anywhere

Tooling and hosting to make your DBOS Transact production deployments a success, on any platform.

DBOS Pro — Run DBOS in production, effortlessly

Tooling to operate DBOS Transact applications anywhere.

  • Manage application deployment, versioning, scaling
  • Automatically detect and seamlessly recover interrupted workflows
  • View and manage your workflows from anywhere
Explore DBOS Pro

DBOS Cloud — Durable app hosting

A seriously fast serverless platform for DBOS Transact applications.

  • 25x better price-performance than AWS Lambda + Step Functions
  • Automatic app restart / resume with exactly-once processing
  • Deploy with a click, scale to millions.
Explore DBOS Cloud

The fastest path to production-ready

The fastest path to production-ready

Rooted in cutting-edge research >

Based on years of MIT and Stanford research, brought to you by the creators of Postgres, Apache Spark, and Chaos Engineering.

Works with your infrastructure >

DBOS is open source and standards-based. It fits your dev and production environments like a glove.

Your data is safe >

The safety and privacy of your code and data is a top priority for DBOS.
Start your project

What you can build with DBOS

Make backends more durable, cost-efficient, and easier to build.

Document Pipeline

Build a reliable and scalable document ingestion pipeline for a RAG-based chat agent.

Learn more

Fault-Tolerant Checkout

Use durable workflows to build an online storefront that's resilient to any failure.

Learn more

Stock Tracker

Track stock prices and receive alerts when they cross a threshold.

Learn more

AI-Powered Slackbot

Use DBOS and LlamaIndex to build an AI-powered Slackbot that answers questions.

Learn more

LLM-Powered Chatbot

Build a chatbot with DBOS, and deploy it
50x cheaper than AWS.

Learn more

Start for Free

Use the open source DBOS Transact library, free forever.
Try DBOS Pro fee for 30 days.

DBOS Pro Free Trial
Browse pricing plans
Gartner Cool Vendor 2024 - Badge
2024 Gartner® Cool Vendor™
Enabling Efficient Cloud Operations
DBOS Transact Workflow Example

FAQs

Will DBOS add support for other languages?

+

What happens if my monthly usage exceeds my subscription settings?

+

Can I run DBOS applications on-premises?

+

Follow the future of cloud architecture

Announcing V2.0 of DBOS Transact for TypeScript

DBOS Architecture
January 16, 2025

How to Make Your Apps Observable by Default

How To
August 25, 2024

Handling Workflow Failures with Forks

How To
May 19, 2025

Improve your knowledge of
durable application architecture.

Only valuable insights, no spam. Unsubscribe in a single click.

Build your reliable backend.
Effortlessly.

Contact sales
Start your project
DBOS radically simplifies cloud application devops and deployment.
Products
DBOS CloudDBOS TransactPricing PlansContact Us
Solutions
Cron Job PlatformDurable AI WorkflowsDurable Data PipelinesCloud Modernization
Developers
DocsQuickstart GuideExamplesTutorials
Company
About UsPrivacy PolicyTerms of ServiceCookies
Copyright © DBOS, Inc. 2025