Over the past month, the DBOS product team has focused on two areas: workflow observability and transactional application development. We introduced aggregate views in DBOS Conductor, workflow metrics export with integrations into popular observability platforms, role-based access control (RBAC), and bulk workflow fork operation from the UI. We expanded DBOS Transact with pluggable data sources, improved Java and Go feature parity, and SQLite backend support for Go. We also have new integrations with AI frameworks.
Here’s a summary of what’s new:
New in DBOS Transact open source libraries
- Pluggable data sources for DBOS Python
- Latency improvements for durable streams
- Bulk send operations
- DBOS Golang v0.17 with SQLite backend support
- DBOS Java v0.9 with transactional steps for Spring Boot
New in DBOS Conductor
- Multi-dimensional filtering and aggregate views
- Metrics export and integrations with observability platforms
- Role-Based Access Control (RBAC)
- Bulk workflow fork operations from the UI
New DBOS integrations
- DBOS plugin for Google ADK
Read on for the details.
New Features in DBOS Transact
Pluggable Data Sources for DBOS Python
When a workflow step performs database operations, running it as a transactional step guarantees exactly-once execution. DBOS achieves this by writing the step checkpoint in the same database transaction as the application's updates. This makes it much easier to build reliable applications that perform database writes without worrying about duplicate execution during failures or retries.
In the latest release, we've introduced pluggable data sources for DBOS Python. You can now define a datasource for any database and use it from any workflow. Previously, transactional steps could only be defined through the @DBOS.transaction decorator and were tied to a single configured database.
Datasources bring two major improvements:
- Native support for asynchronous transactional step functions.
- Support for multiple databases within the same application.
This means you can run durable, exactly-once transactional steps against any number of databases, whether your application uses synchronous or asynchronous Python. Importantly, these databases do not need to be the same database that DBOS uses to store workflow state.
For example:
Latency Improvements for Durable Streams
We've significantly improved the performance of durable streams by introducing a new optimization. DBOS.read_stream() now uses LISTEN/NOTIFY to receive new stream messages as soon as they are available, with polling retained as a fallback mechanism.
This improvement is particularly important for AI applications. Large language models often generate output tokens and deltas much faster than a typical polling interval. With a polling-based approach, updates can arrive in large bursts, creating a sluggish and unnatural user experience.
By leveraging LISTEN/NOTIFY, DBOS can now deliver stream updates (such as response outputs from an LLM) to subscribed clients immediately as they are written. The result is smoother, lower-latency generative response streaming that feels much closer to the real-time response experience users expect from modern AI applications.
Bulk Send Operations
We introduced a new bulk send API that makes it much more efficient to deliver messages to large numbers of workflow executions. Multiple messages can now be sent in a single transaction, reducing overhead and improving throughput for high-volume messaging workloads.
This is particularly useful for fan-out patterns where a single event needs to notify thousands of workflows. Examples include human-in-the-loop agent systems where an operator approves or rejects large batches of tasks, or customer notification systems that need to wake up workflows for many users at once.
Bulk sends are also fully atomic. If any message in the batch cannot be delivered, for example, because its destination workflow does not exist, the entire transaction is rolled back and no messages are sent. This guarantees consistency and eliminates the risk of partial delivery.
We've also added a new send_to_forks option. When enabled, each message is automatically delivered not only to its destination workflow, but also to all workflows recursively forked from that workflow. This makes it easy to broadcast signals, events, or configuration updates across an entire workflow lineage with a single API call.
Read the docs: Python, Java (TypeScript and Go support coming soon)
DBOS Golang v0.17 with SQLite Backend Support
The latest DBOS Transact for Go release continues to improve feature parity with the Python and TypeScript libraries, as well as adding SQLite backend support. It marks a major step toward the v1.0 release.
The new features include:
- Improved application versioning: Application versions are now persisted in the database, making them observable and controllable at runtime. Docs
- Added support for SQLite as a durability backend: SQLite is a great fit for local development, edge deployments, and lightweight applications that still need reliable recovery from failures.
- Deduplication policies: You can specify what happens when you enqueue a task whose deduplication ID already exists. Docs
Read the release notes.
DBOS Java v0.9 with Transactional Steps for Spring Boot
This release improves ergonomics for Java developers while continuing to close feature gaps with the Python and TypeScript libraries. It marks another major step toward the v1.0 release.
The new features include:
- Step Factories: Step factories are a new kind of step that execute as a single database transaction, committing both the step output and the DBOS checkpoint atomically. The base PostgresStepFactory is included in the core transact package, with concrete implementations for JDBC, JDBI, and jOOQ. Docs
- Dynamic Queues: Queues can now be created, updated, and deleted at runtime via the database rather than only at startup via code. Docs
- Debouncer: A debouncer collapses multiple workflow calls with the same key within a time window into a single execution using the most recently supplied arguments. Docs
- Transactional Step (Spring Boot integration): Annotate any Spring-managed method with @TransactionalStep to make it an idempotent DBOS step. Works with Spring JDBC, JDBI, jOOQ, and JPA/Hibernate. Docs
Read the release notes.
New Features in DBOS Conductor
Multi-Dimensional Filtering and Aggregate Views
DBOS Conductor UI now includes multi-dimensional filtering and aggregate views, making it much easier to understand what's happening across large numbers of workflow executions.
You can filter workflows by attributes such as status, application version, queue, workflow name, and time range, then view aggregated metrics and trends across the selected set. This helps you quickly identify failures, spot anomalies, and narrow your investigation to the workflows that matter most.
Here's a demonstration of workflow management in DBOS Conductor from the June DBOS User Group meeting:
Metrics Export and Integrations with Observability Platforms
DBOS Conductor now provides a Prometheus/OpenMetrics-compatible metrics endpoint, making it easy to integrate workflow telemetry into your existing observability stack.
Using the endpoint below, you can export metrics to any OpenMetrics-compatible backend, including Prometheus, Grafana, Datadog, OpenTelemetry Collector, Honeycomb, New Relic, and others:
https://cloud.dbos.dev/v1/metrics
The exported metrics provide visibility into every layer of your DBOS applications, including:
- Workflow throughput and outcomes
- Queue health and backlog
- Workflow and step latency
- Step throughput and outcomes
- Executor status
With these metrics, you can build custom dashboards and configure alerting rules tailored to your application's needs. Whether you are monitoring workflow success rates, detecting queue bottlenecks, or tracking latency regressions, DBOS metrics integrate seamlessly with the tools your team already uses.
The screenshot below shows an example Grafana dashboard built entirely from DBOS-exported metrics:
Here’s a demonstration of DBOS Conductor support for OpenMetrics:
Role-Based Access Control (RBAC)
DBOS Conductor now supports role-based access control (RBAC) for both users and API keys, making it easier to manage access across teams and environments.
Administrators can grant users and service accounts only the permissions they need, helping organizations enforce the principle of least privilege while maintaining operational flexibility. Whether you're giving developers access to workflow observability, allowing external operators to manage workflow executions, or provisioning API keys for observability platforms, RBAC provides fine-grained control over who can view and perform actions within Conductor.
For API keys:
For users:
Bulk Workflow Fork Operations from the UI
DBOS Conductor now supports bulk workflow fork operations directly from the UI. You can select multiple workflow executions and fork them in a single action, making it much easier to recover from failures or replay workflows after deploying a fix.
Workflows can be forked from a variety of starting points, including:
- the last failed step,
- the last completed step,
- a specific step ID,
- or a step name.
This allows execution to resume from exactly the point you choose, without rerunning work that has already completed successfully.
New Partnerships and Integrations
DBOS Plugin for Google ADK
We released the much-requested Google ADK + DBOS integration: durable execution for ADK agents, backed directly by your database.
The DBOS plugin brings production-grade reliability and orchestration to ADK agents:
- Durable execution: Automatically recover agents from crashes, deploys, or machine failures without losing progress.
- Built-in retries: Configure retry policies with exponential backoff for transient LLM or tool failures.
- Long-running agents: Run agents and tools for hours or even days.
- Human-in-the-loop workflows: Pause execution and resume later after human approvals.
- Scalable execution: Run workflows across distributed workers with durable queues and built-in rate limiting.
- Observability & management: Inspect, cancel, resume, and fork agent workflows for debugging and operations.
All powered by a database you own, no separate orchestration infrastructure required.
- Official Google ADK doc: https://adk.dev/integrations/dbos/
- DBOS ADK plugin repo: https://github.com/dbos-inc/dbos-google-adk
- DBOS doc: https://docs.dbos.dev/integrations/google-adk
Learn More about Durable Workflow Orchestration
If you like making systems reliable, we'd love to hear from you. At DBOS, our goal is to make durable workflows as easy to work with as possible. Check it out:
- Quickstart: https://docs.dbos.dev/quickstart
- GitHub: https://github.com/dbos-inc
- Discord community: https://discord.gg/eMUHrvbu67
