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.

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.

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.

What you can build with DBOS

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

Start for Free

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

Gartner Cool Vendor 2024 - Badge
2024 Gartner® Cool Vendor™
Enabling Efficient Cloud Operations
DBOS Transact Workflow Example

FAQs

Follow the future of cloud architecture

Improve your knowledge of
durable application architecture.

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