DBOS Go v1.9 is out!
This release brings two major enterprise features to Go:
- Workflow suspension: Suspend workflows waiting for notifications or timers without consuming worker resources.
- Sharded Postgres: Scale durable workflows across multiple Postgres databases.
It also includes several bug fixes and improvements to workflow recovery, cancellation, and connection pool management.
Upgrade note: This release bumps the Go version to 1.26 and updates several dependencies, including pgx. The pgx upgrade changes how special characters in connection strings are handled, so check your connection strings before upgrading.
Full release notes:
github.com/dbos-inc/dbos-tra…
Just released DBOS TypeScript 5.6 and Python 3.6!
Both releases include bug fixes and performance improvements, particularly faster workflow retention.
We also made a behavior change to how workflow management operations (cancel, resume, fork, and rewind) interact with queues.
Previously, these operations would remove a workflow's queue association. Now, workflows retain their original queue, so resuming, rewinding, or forking a workflow automatically re-enqueues it on that queue. You can also specify a different queue when resuming, rewinding, or forking.
Cancelled or terminated workflows still don't occupy queue slots until they're resumed and re-enqueued.
We made this change based on consistent feedback that the previous behavior was unintuitive. Thanks to everyone who raised it!
Release notes:
Python: github.com/dbos-inc/dbos-tra…
TS: github.com/dbos-inc/dbos-tra…
Durable Stories is back for Ep. 02: What Just Happened?! Observability for Large-Scale Systems and Agents.
AI makes software easier than ever to build. But does it make software easier to understand, test, and operate reliably?
Join us on Dec 8 for a conversation with Liz Fong-Jones (Honeycomb), @seldo , and @qianl_cs about how observability and testing are evolving in the age of AI.
luma.com/dbos-o11y
If you've read this blog post before, the updates are mostly in the "Reliability and Security" section. Because security is becoming more challenging today, you want to minimize the attack surface and trim dependencies.
"If an application already depends on Postgres, adopting durable execution does not add any new points of failure to the system nor introduce new surface area to secure."
Durable execution just needs Postgres.
I just refreshed our blog post about this because I think the message remains incredibly timely.
Developers are building lots of systems, particularly agentic ones, right now, and it’s critical that those systems are reliable. Durable execution makes reliability easier by checkpointing a program’s progress in a database so it can use them to recover from any failure.
Traditionally, you did durable execution via external orchestration: use a central orchestrator to manage workflow execution across a fleet of worker servers, dispatching tasks to them and recording whether the tasks completed.
That kind of central orchestrator was always complex and tricky to manage. But increasingly, it’s a liability. It’s a single point of failure for all your systems, breaking everything if it’s down. It’s also a security vulnerability, as workflow history likely contains sensitive data that you need to protect.
To fix this, replace your workflow orchestrator with Postgres. The core idea of durable execution is to checkpoint program state in a database. But if durable execution is about databases, then there’s no reason to have a separate orchestrator server. Instead, it’s simpler and more efficient to use the database itself as an orchestrator and have applications checkpoint state to it directly. This cuts out a potentially-vulnerable single point of failure for a Postgres server you already know how to manage.
I write about this more in the blog post:
👇
Durable execution just needs Postgres.
I just refreshed our blog post about this because I think the message remains incredibly timely.
Developers are building lots of systems, particularly agentic ones, right now, and it’s critical that those systems are reliable. Durable execution makes reliability easier by checkpointing a program’s progress in a database so it can use them to recover from any failure.
Traditionally, you did durable execution via external orchestration: use a central orchestrator to manage workflow execution across a fleet of worker servers, dispatching tasks to them and recording whether the tasks completed.
That kind of central orchestrator was always complex and tricky to manage. But increasingly, it’s a liability. It’s a single point of failure for all your systems, breaking everything if it’s down. It’s also a security vulnerability, as workflow history likely contains sensitive data that you need to protect.
To fix this, replace your workflow orchestrator with Postgres. The core idea of durable execution is to checkpoint program state in a database. But if durable execution is about databases, then there’s no reason to have a separate orchestrator server. Instead, it’s simpler and more efficient to use the database itself as an orchestrator and have applications checkpoint state to it directly. This cuts out a potentially-vulnerable single point of failure for a Postgres server you already know how to manage.
I write about this more in the blog post:
👇
Great to see the Fujitsu team putting together a hands-on tutorial on building reliable workflows with DBOS and Fujitsu Enterprise Postgres.
One highlight is how DBOS users, especially those running sovereign or on-premises deployments, can benefit from Fujitsu Enterprise Postgres' Transparent Data Encryption to meet their security requirements.
Durable Stories just shipped its first episode!
Yesterday we talked about Postgres, and it was a great kickoff:
→ 300+ signups
→ two brilliant guests
→ sharp questions from the audience
Huge thanks to @kelvich and @levpgdog for bringing perspectives you only get from building this stuff for real, and to @qianl_cs for steering the conversation.
And to the DBOS community: thank you for showing up, asking the great questions, and sticking around.
If you didn’t make it yesterday, the recording is here: youtu.be/Kop0yFM83sM
Durable Stories just shipped its first episode!
Yesterday we talked about Postgres, and it was a great kickoff:
→ 300+ signups
→ two brilliant guests
→ sharp questions from the audience
Huge thanks to @kelvich and @levpgdog for bringing perspectives you only get from building this stuff for real, and to @qianl_cs for steering the conversation.
And to the DBOS community: thank you for showing up, asking the great questions, and sticking around.
If you didn’t make it yesterday, the recording is here: youtu.be/Kop0yFM83sM
Happens on THURSDAY! Join us for the first episode of Durable Stories “Postgres, Postgres Everywhere.”
We’ll get into the hard parts:
→ Scaling past connection limits and sharding without rewriting your app
→ Separating storage and compute, and what serverless changes for teams
→ Keeping workflows and AI agents durable when processes crash mid-run
→ Where Postgres starts to strain, and how teams push through it
With:
• @kelvich , Principal Software Engineer of Databricks
• @levpgdog , Founder of PgDog
• @qianl_cs , Co-founder & CEO of DBOS, Inc.
🗓Thursday, Nov 12
🕚 11 AM PST / 2 PM EST / 8 PM CET
Bring your questions, we’ll put them to the panel: luma.com/dbos-aola
Fun optimization story!
Was recently working on optimizing workflow cron scheduling, so that a single application can support millions of workflow schedules.
The way it worked originally was that each cron schedule was executed by its own thread, which calculated the next schedule fire time, slept until that time, then fired the schedule.
The problem with this design is that one thread per schedule scales poorly. To manage millions of schedules, we need a single thread that can dispatch every schedule. This thread has to keep track of all the schedules, figure out which ones are firing next, wait till their scheduled time, fire them, and repeat for the next schedules to fire.
The key to making this single thread efficient is choosing the right data structure to store the schedules. We chose a min-heap, sorted by next fire time. The dispatch thread builds this min heap from schedule records stored in Postgres. Then, using the min-heap, the dispatch thread repeatedly:
1. Pops the next item off the min-heap. Because the min-heap is sorted by next fire time, this is always the next schedule to fire. Popping an item from a min-heap only takes O(log N) time.
2. Waits until that schedule is ready to fire.
3. Iterates through the min-heap to find all other schedules that fire at that time.
4. Fires all the schedules in a batch.
5. Computes the next fire time for each of these schedules, and inserts them back into the min-heap.
Because min-heaps have exactly the performance properties we need, O(log N) pushes and pops, this approach lets a single process easily handle millions of workflow schedules.
Also, if durable workflow state lives in the same database as application state, you can get the best of both worlds: workflows and durable entities, without introducing a separate state store.
Busy release day at DBOS! We just released DBOS Rust 0.6.
This is a major update, bringing a bunch of new capabilities to Rust:
- Durable streams and scheduled workflows
- Debouncing and workflow patching
- Workflow rewind
- Portable and custom serialization
- Support for the smol and async-global-executor runtimes
We've also significantly expanded our Rust documentation, with a dedicated section on the DBOS docs site, including programming guides, tutorials, and API references. Every feature is now documented on docs.rs as well.
Note that 0.6 introduces breaking changes to both the API and system database for users upgrading from 0.5.
Full release notes: github.com/dbos-inc/dbos-tra…
Just released DBOS TypeScript 5.5 and Python 3.5, with three big new features:
1. Workflow suspension. Workflows that are sleeping or waiting for notifications can now be suspended, consuming zero compute resources (no threads, memory, or queue slots). Their state is safely stored in Postgres, and they're automatically re-enqueued and resumed when the deadline or notification arrives.
2. External storage. You can now store workflow and step checkpoints in external storage, such as S3 or a local filesystem. This makes it much easier to build workflows that process large objects or datasets without overwhelming Postgres.
3. Cron scheduler at massive scale. We've significantly optimized the DBOS cron scheduler. It can now efficiently handle millions of scheduled workflows.
All three improvements help DBOS support larger, longer-running, and more demanding workloads while keeping infrastructure overhead low.