In today's complex application landscape, it's rare to rely on a single database. You might use a relational database for core transactions, a key-value store for caching, and a search engine for fast text queries. While this "polyglot persistence" approach is powerful, it introduces a significant management challenge. Each data resource comes with its own API, configuration quirks, and scaling patterns. The result? Spiraling complexity, brittle scripts, and a lot of time spent on manual infrastructure wrangling.
What if you could manage your entire, distributed data fleet with the same simplicity as writing a single function?
That's the promise of databases.do. We're transforming how you interact with your data infrastructure by allowing you to manage it all as code. Provision, query, and scale distributed databases through a single, powerful API, and turn complex data operations into simple, repeatable workflows.
As your services grow, so does your collection of data resources. The problem isn't just having multiple databases; it's the operational overhead that comes with them:
This friction slows down development teams and makes it difficult to maintain a reliable, scalable data infrastructure.
At .do, we believe in the "Services as Software" model. Instead of treating your data services as a collection of separate, opaque boxes, databases.do allows you to interact with them as a single, programmable entity.
This is the crucial difference between database.do (singular) and databases.do (plural). While database.do might refer to a single data resource instance, databases.do refers to the management of the entire collection. It's the agentic workflow platform that orchestrates all your data resources, giving you a single point of control for your whole fleet.
With databases.do, you define your infrastructure declaratively, as code. This means you can:
Talk is cheap. Let's look at how easy it is to list every database in your project, regardless of type or location, using the .do SDK.
import { databases } from '@do/sdk';
// List all databases within your project
async function listAllDatabases() {
try {
const allDbs = await databases.list();
console.log('Available Databases:', allDbs);
return allDbs;
} catch (error) {
console.error('Failed to retrieve databases:', error);
}
}
listAllDatabases();
That's it. One function call, databases.list(), gives you a complete overview. No more juggling different SDKs or parsing varied command-line outputs. This is the power of unified API access for database management.
databases.do is an agentic workflow platform that allows you to manage collections of data resources as code. It provides a unified API to provision, query, and scale multiple databases, abstracting away the underlying infrastructure complexity.
database.do refers to a single data resource or instance. databases.do refers to the management of a collection of these resources, allowing you to perform operations across multiple databases at once, like listing all available databases or applying a configuration change to a group of them.
The .do platform is designed to be extensible. You can manage various types of data resources, including SQL, NoSQL, and graph databases, by integrating the appropriate drivers and defining them within your agentic workflows. This enables truly scalable databases tailored to your needs.
You can start by installing the .do SDK and authenticating your account. From there, you can use the databases agent to list existing data resources or define and provision new ones using simple code.
Ready to stop wrangling and start building? Managing your data resources shouldn't be a chore. With databases.do, you can bring the power of code, automation, and simplicity to your entire data fleet.
Here’s how to begin your journey:
Stop managing databases one by one. Start managing your data fleet as one. Welcome to the future of database management.