Show HN: DBOS TypeScript – Lightweight Durable Execution Built on Postgres
20 comments
·January 16, 2025qianli_cs
Hello! I'm a co-founder at DBOS here and I'm happy to answer any questions :)
peterkelly
How do you persist execution state? Does it hook into the Python interpreter to capture referenced variables/data structures etc, so they are available when the state needs to be restored?
mnembrini
About workflow recovery: if I'm running multiple instance of my app that uses DBOS and they all crash, how do you divide the work of retrying pending workflows?
qianli_cs
Each workflow is tagged by the executor ID that runs it. You can command each new executor to handle a subset of the pending workflows. This is done automatically on DBOS Cloud. Here's the self-hosting guide: https://docs.dbos.dev/typescript/tutorials/development/self-...
sarahdellysse
Hi there, I think I might have found a typo in your example class in the github README. In the class's `workflow` method, shouldn't we be `await`-ing those steps?
qianli_cs
Nice catch. Fixing it :)
Dinux
Hai, really cool project! This is something I can actually use.
ilove196884
I know this this might sound scripted or can be considered cliche but what is the use case for DBOS.
qianli_cs
The main use case is to build reliable programs. For example, orchestrating long-running workflows, running cron jobs, and orchestrating AI agents with human-in-the-loop.
DBOS makes external asynchronous API calls reliable and crashproof, without needing to rely on an external orchestration service.
CMCDragonkai
Could you genericise the requirement in postgresql and provide a storage interface we could plug into? I think I have a use for this in Polykey (https://GitHub.com/MatrixAI/Polykey) but we use rocksdb (transactional key value embedded db).
CMCDragonkai
Also this reminds me of orthogonal persistence https://wiki.c2.com/?TransparentPersistence
Did you do literature research of Smalltalk?
KraftyOne
That's definitely worth considering! The core algorithms can work with any data store. That said, we're focused on Postgres right now because of its incredible support and popularity.
psadri
Where is the state stored? In my own pg instance? Or is it stored somewhere in the cloud? Also, a small sample code snippet would be helpful.
KraftyOne
The state can be stored in any Postgres instance, either locally or in any cloud.
For code, here's the bare minimum code example for a workflow:
class Example {
@DBOS.step()
static async step_one() {
...
}
@DBOS.step()
static async step_two() {
...
}
@DBOS.workflow()
static async workflow() {
await Example.step_one()
await Example.step_two()
}
}
Then we have a bunch more examples in our docs: https://docs.dbos.dev/.
Or if you want to try it yourself download a template:
npx @dbos-inc/createpsadri
Are there any constraints around which functions can be turned into steps? I assume their state (arguments?) need to be serializable?
Also, what happens with versioning? What if I want to deploy new code?
KraftyOne
Yeah, the arguments and return values of steps have to be serializable to JSON.
For versioning, each workflow is tagged with the code version that ran it, and we recommend recovering workflows on an executor running the same code version as what the workflow started on. Docs for self hosting: https://docs.dbos.dev/typescript/tutorials/development/self-.... In our hosted service (DBOS Cloud) this is all done automatically.
jauntywundrkind
Loved the Supabase coverage from a month ago, showing under the hood what DBOS is storing & how the data flow works on it. It made real what DBOS was for me, clicked; before DBOS felt very abstract to me.
https://supabase.com/blog/durable-workflows-in-postgres-dbos https://news.ycombinator.com/item?id=42379974
purpleinfs
nice work
Hi HN - Peter from DBOS here with my co-founder Qian (qianl_cs)
Today we want to share our TypeScript library for lightweight durable execution. We’ve been working on it since last year and recently released v2.0 with a ton of new features and major API overhaul.
https://github.com/dbos-inc/dbos-transact-ts
Durable execution means persisting the execution state of your program while it runs, so if it is ever interrupted or crashes, it automatically resumes from where it left off.
Durable execution is useful for a lot of things:
- Orchestrating long-running or business-critical workflows so they seamlessly recover from any failure.
- Running reliable background jobs with no timeouts.
- Processing incoming events (e.g. from Kafka) exactly once
- Running a fault-tolerant distributed task queue
- Running a reliable cron scheduler
- Operating an AI agent, or anything that connects to an unreliable or non-deterministic API.
What’s unique about DBOS’s take on durable execution (compared to, say, Temporal) is that it’s implemented in a lightweight library that’s totally backed by Postgres. All you have to do to use DBOS is “npm install” it and annotate your program with decorators. The decorators store your program’s execution state in Postgres as it runs and recover it if it crashes. There are no other dependencies you have to manage, no separate workflow server–just your program and Postgres.
One big advantage of this approach is that you can add DBOS to ANY TypeScript application–it’s just a library. For example, you can use DBOS to add reliable background jobs or cron scheduling or queues to your Next.js app with no external dependencies except Postgres.
Also, because it’s all in Postgres, you get all the tooling you’re familiar with: backups, GUIs, CLI tools–it all just works.
Want to try DBOS out? Initialize a starter app with:
Then build and start your app with: Also check out the docs: https://docs.dbos.dev/We'd love to hear what you think! We’ll be in the comments for the rest of the day to answer any questions you may have.