In a fast-paced development environment, friction is the enemy of progress. One of the most common sources of friction? Waiting for a database. A developer has a brilliant new feature idea, spins up a new branch, and then... hits a wall. They file a ticket with the DevOps or DBA team, wait for approval, wait for provisioning, and wait for credentials. Hours, or even days, can be lost.
What if you could eliminate that bottleneck entirely? Imagine empowering your developers with on-demand, secure access to the data resources they need, exactly when they need them. This is the promise of a self-service data platform. And with agentic workflows, it's not a dream—it's a programmable reality.
This post will guide you through how to build a secure, self-service portal for database provisioning using the .do Agentic Workflow Platform and the databases.do agent, transforming your data infrastructure into a true service for your developers.
Traditional database management is often centralized and manual. The process usually looks something like this:
This workflow is slow, error-prone, and creates a clear dependency that stifles developer velocity. Furthermore, it often leads to inconsistent environments, where a developer's local test database bears little resemblance to the production instance it will eventually use.
The databases.do agent provides a powerful abstraction layer—a control plane—for managing an entire fleet of databases. Instead of treating each database as a unique, manually-configured entity, you treat the entire collection as a single, programmable resource.
This is database fleet management as code.
By using the databases.do agent, you can create simple, repeatable, and secure workflows that allow developers to provision their own resources within predefined guardrails. The platform team sets the rules, and the developers get the freedom.
The key is the .do Agentic Workflow Platform, which allows you to interact with complex services through a simple, unified API. Let's see how you'd use it to manage your database fleet.
First, you access the databases.do agent using the .do SDK. This agent becomes your single point of contact for all fleet-level operations.
import { Do } from '@do-sdk/core';
// Initialize the .do client
const ado = new Do();
// Access the databases agent to manage your entire fleet
const myDatabases = ado.use('databases.do');
// Securely list all managed database instances across all clouds
const allInstances = await myDatabases.list();
console.log(allInstances);
// Example Output:
// [
// { id: 'db-prod-users-postgres', type: 'PostgreSQL', provider: 'AWS', status: 'available' },
// { id: 'db-staging-cache-redis', type: 'Redis', provider: 'GCP', status: 'available' },
// { id: 'db-dev-feature-x-mongo', type: 'MongoDB', provider: 'Azure', status: 'creating' }
// ]
With just a few lines of code, you have a complete, real-time inventory of your entire multi-cloud database estate.
Now for the magic. How does a developer get a new database? Instead of a ticket, they could use an internal CLI tool, a Slack bot, or a simple web portal that, under the hood, makes a single API call:
// (Code running inside your internal developer tool)
// Provision a new PostgreSQL instance for a feature branch
const newFeatureDb = await myDatabases.create({
type: 'PostgreSQL',
provider: 'AWS',
plan: 'dev-small', // A pre-defined instance size
tags: {
owner: 'dev-team-alpha',
branch: 'feature/new-checkout'
}
});
console.log(`Database ${newFeatureDb.id} is provisioning!`);
In this agentic workflow:
The days-long ticket queue has been replaced by a sub-second API call.
Yes. This is a core strength of the databases.do agent. It acts as a universal translator, providing a consistent API whether you're provisioning a PostgreSQL instance on AWS, a Redis cache on GCP, or a MongoDB cluster on Azure. Your developers don't need to know the intricacies of each cloud; they just ask for the database they need.
database.do is for managing a single database instance—running queries, managing schemas, etc. databases.do is the higher-level orchestrator for the entire fleet. You use databases.do to create or discover an instance, and then you might use database.do to interact with it.
Security is paramount. The .do platform provides centralized authentication and authorization. As the platform owner, you define the policies. For example, you can set a policy that states: "Users in the 'developers' group can only create databases using the 'dev-small' or 'dev-medium' plans and can only list or destroy databases they own."
Developers never handle raw cloud credentials. All actions are performed by the agent, which operates under the secure policies you've defined.
By adopting a "database as code" approach with databases.do, you're not just automating a task; you're fundamentally changing your development culture. You're removing roadblocks, empowering your teams, and enabling a true "you build it, you run it" mindset.
The result is faster innovation, more consistent environments from dev to production, and a happier, more productive engineering team.
Ready to turn your data infrastructure into a programmable, self-service platform? Explore databases.do and start building your agentic workflows today.