In today's fast-paced digital landscape, businesses are constantly battling operational complexity. Manual workflows are brittle and slow. Disparate systems refuse to talk to each other. Even modern microservice architectures can become a tangled web of dependencies that are difficult to manage, scale, and update.
What if you could solve this? What if you could treat any business process—from onboarding a new customer to generating a complex financial report—as a single, robust piece of software?
This is the promise of Services-as-Software, a new paradigm powered by service.do. It's about turning your business logic into simple, reusable APIs through a powerful Agentic Workflow Platform.
For too long, core business processes have been trapped in spreadsheets, manual checklists, or clunky, monolithic applications. Automation attempts often result in fragile scripts or expensive, low-code platforms that lack the flexibility and version control that developers depend on.
service.do introduces a new approach: Business-as-Code. Instead of drawing flowcharts or writing one-off scripts, you define your business capability in simple, clean code.
This allows you to encapsulate a specific business function—like 'process a payment' or 'generate a report'—into a self-contained, deployable software component. This service can then be versioned, scaled, and invoked via an API, just like any other piece of software. It’s a revolutionary shift that brings the power and discipline of software engineering to the core of your business operations.
The philosophy behind service.do is simple and powerful: Define. Deploy. Deliver. Let's see how you can turn a complex business workflow into a scalable software component.
You start by defining the logic of your business process in a familiar language like TypeScript. You specify the inputs it requires, the outputs it produces, and the steps it needs to execute.
Here's an example of a complete customer-onboarding service. It takes a new user's details and orchestrates the steps to get them set up.
import { Service, type Context } from '@do/sdk';
// Define the input and output schemas for your service
interface OnboardingInput {
name: string;
email: string;
plan: 'free' | 'pro' | 'enterprise';
}
interface OnboardingOutput {
customerId: string;
welcomeEmailSent: boolean;
status: 'complete' | 'failed';
}
// Create a new Service instance with your business logic
export default new Service<OnboardingInput, OnboardingOutput>({
name: 'customer-onboarding',
description: 'Onboards a new customer, creating an account and sending a welcome email.',
async run(input: OnboardingInput, context: Context): Promise<OnboardingOutput> {
console.log(`Starting onboarding for ${input.email} on plan ${input.plan}`);
// Business logic goes here.
// e.g., call user.create, email.send, billing.setup agents
const customerId = `cust_${context.invocationId}`;
return {
customerId,
welcomeEmailSent: true,
status: 'complete',
};
},
});
As you can see, the code is straightforward. You define clear data contracts (OnboardingInput, OnboardingOutput) and place your core business logic inside the run method. This logic is where the magic of agentic workflows happens.
Once your service is defined, what about servers, scaling, and security?
You don't have to worry about any of it. The service.do platform is fully serverless. You simply define your service's logic, and we handle the deployment, scaling, security, and execution. There are no servers to provision, no containers to manage, and no Kubernetes clusters to configure. You focus on the business value, not the infrastructure.
With a single deployment command, your service is live. It’s now a robust, versioned API endpoint that you can call from anywhere—your frontend application, a mobile app, or another backend system. You've successfully turned a complex operation into a simple, on-demand software component.
You might be thinking, "This sounds a bit like a microservice." While there are similarities, .do Services are fundamentally different because they are purpose-built for agentic workflows.
A service.do Service is designed to be a high-level orchestrator. Its job is to coordinate other specialized agents and services to accomplish a complex goal.
In our customer-onboarding example, the run method wouldn't contain all the raw logic for creating a user or sending an email. Instead, it would act like a manager, delegating tasks to other agents:
This creates a clean separation of concerns and allows you to build incredibly powerful and complex automation by composing smaller, reusable agents. It’s this orchestration layer that transforms simple functions into intelligent, automated business processes.
You can model almost any business process you can imagine. If you can describe it as a series of steps and decisions, you can build it as a service. Our users are building:
Stop wrestling with brittle scripts and complex infrastructure. Start treating your business operations with the same power and clarity as your software stack. The agentic workflow model empowers you to define, deploy, and deliver any business capability as a robust, scalable software component.
Ready to turn your complex operations into simple, reusable APIs? Visit service.do to get started and define your first service today!