In modern software development, the gap between a complex business process and a production-ready service is often filled with glue code, complex orchestration, and brittle automation scripts. We've all been there: chaining together different APIs, managing state, and handling errors for what should be a straightforward task. What if you could define that entire process as a simple, declarative configuration and instantly expose it as a robust, scalable API?
At devs.do, we're building the platform to make this a reality. We call it Business-as-Code. And the fundamental building block of this new paradigm is the 'Doer'.
A 'Doer' is a single-purpose, autonomous service that performs a specific task. Think of it like a serverless function, but for an entire workflow, not just a single piece of code. Developers define what a Doer needs to run (its inputs), what it's supposed to do (its workflow), and the devs.do platform handles the rest.
A Doer is defined by a few key properties:
The magic of a Doer lies in its workflow. This isn't a list of functions to call in an imperative script; it’s a declarative Agentic Workflow.
An Agentic Workflow is a sequence of tasks executed by specialized AI agents. Instead of writing complex code to clone a git repo, lint files, and run a security scan, you simply declare which agents you want to use and what data to pass between them. The platform handles the orchestration, error handling, and execution.
Let’s look at how you would define a Doer to analyze a git repository:
import { Doer, Client } from '@do-inc/sdk';
// Configure your client with an API key
const client = new Client({ apiKey: 'YOUR_API_KEY' });
// Define a new service (a "Doer")
const codeAnalysisService: Doer = {
name: 'code-analyzer.devs.do',
description: 'Analyzes a git repository for code quality.',
input: {
type: 'object',
properties: {
repoUrl: { type: 'string', description: 'The URL of the git repository.' },
},
},
// Define the agentic workflow
workflow: [
{ agent: 'git.clone', params: { url: '{{input.repoUrl}}' } },
{ agent: 'linter.run', params: { path: './cloned-repo' } },
{ agent: 'security.scan', params: { path: './cloned-repo' } },
],
};
// Deploy your new service to the .do platform
async function deployService() {
const deployedDoer = await client.create(codeAnalysisService);
console.log(`Service deployed successfully at: ${deployedDoer.url}`);
}
deployService();
In just three lines within the workflow array, we’ve defined a sophisticated process:
You declare what you want done, and the platform figures out how to do it. This is the essence of building Services-as-Software.
Defining the Doer is only half the story. The truly transformative part is turning that definition into a live, callable API endpoint. With the devs.do SDK, it’s a single function call:
const deployedDoer = await client.create(codeAnalysisService);
That's it. Your Doer is now deployed and available at a unique URL, ready to be integrated into your applications, CI/CD pipelines, or any other service.
This is what we mean by Business-as-Code. Your operational workflow is now a software artifact. It can be stored in Git, reviewed in pull requests, and deployed automatically, providing a level of reliability and scalability that brittle scripts can't match.
The 'Doer' primitive unlocks a new level of efficiency and power for developer tools and platforms.
Stop wrestling with glue code and start transforming your operations into scalable API services. The devs.do platform provides the runtime for this new paradigm, with SDKs available for TypeScript/JavaScript, Python, and Go.
Visit devs.do to get started and deploy your first 'Doer' in minutes!