In today's business landscape, specialization is king. We have best-in-class SaaS tools for everything: Salesforce for CRM, Stripe for payments, Slack for communication, HubSpot for marketing. This "SaaS sprawl" gives us powerful capabilities, but it also creates a significant challenge: how do we make these independent systems talk to each other to execute a single, cohesive business process?
Too often, the answer involves manual data entry, copy-pasting between tabs, or building brittle, point-to-point integrations that are a nightmare to maintain. These "solutions" are slow, error-prone, and simply don't scale.
What if you could orchestrate all these tools with the same rigor and reliability you apply to your core software products? What if you could define a complex business process—like customer onboarding—as a single, version-controlled, and instantly deployable piece of software?
This is the promise of service.do and the Services-as-Software paradigm.
Let's look at a common scenario: onboarding a new customer. In a typical company, this "simple" process might look like this:
Every manual handoff is a potential point of failure. Data can be entered incorrectly, steps can be missed, and the customer is left waiting. The process is opaque, impossible to track in real-time, and creates data silos that prevent a unified view of the customer journey.
The service.do platform transforms this messy workflow into a clean, automated, and reliable Agentic Workflow. The guiding principle is Business-as-Code: defining your business logic in simple, readable code that the platform then executes for you.
Instead of manually connecting tools, you define a single Service that orchestrates "agents" representing each SaaS tool. An agent is a pre-built connector that knows how to securely communicate with a specific application's API.
Let's rebuild our onboarding process the service.do way.
Our goal is to create a single customer-onboarding service. When invoked, this service will automatically perform all the necessary steps across our SaaS stack.
The mantra is simple: Define. Deploy. Deliver.
Using the service.do SDK, you define the inputs, outputs, and logic for your workflow in TypeScript. It's clean, expressive, and lives in your version control system (like Git) alongside your other code.
import { Service, type Context } from '@do/sdk';
// Define the input and output schemas for your service
interface OnboardingInput {
name: string;
email: string;
salesforceDealId: string;
plan: 'free' | 'pro' | 'enterprise';
}
interface OnboardingOutput {
customerId: string;
stripeSubscriptionId: string;
status: 'complete' | 'failed';
message: string;
}
// Create a new Service instance with your business logic
export default new Service<OnboardingInput, OnboardingOutput>({
name: 'customer-onboarding',
description: 'Orchestrates the full customer onboarding process across multiple SaaS tools.',
async run(input: OnboardingInput, context: Context): Promise<OnboardingOutput> {
try {
// 1. Create the customer in Stripe and start their subscription
const subscription = await context.agents.stripe.createSubscription({
email: input.email,
plan: input.plan,
});
// 2. Add the new customer to our CRM
await context.agents.salesforce.updateContact({
dealId: input.salesforceDealId,
stripeId: subscription.customerId,
status: 'Onboarding Complete',
});
// 3. Send a personalized welcome email
await context.agents.sendgrid.sendEmail({
to: input.email,
templateId: 'welcome-template',
templateData: { name: input.name },
});
// 4. Notify the team in Slack
await context.agents.slack.postMessage({
channel: '#new-customers',
text: `🎉 New customer onboarded! ${input.name} (${input.email}) on the ${input.plan} plan.`,
});
return {
customerId: subscription.customerId,
stripeSubscriptionId: subscription.id,
status: 'complete',
message: 'Customer onboarded successfully.',
};
} catch (error) {
// The platform provides robust error handling and retry logic
console.error('Onboarding failed:', error);
return { status: 'failed', message: error.message };
}
},
});
Once you've defined your service, you deploy it with a single command. The service.do platform takes care of everything else. There are no servers to manage, containers to build, or infrastructure to configure.
Your business process is now a robust, scalable API Service. It's instantly available, secure, and ready to be invoked.
You can now trigger this entire workflow from anywhere:
You've successfully transformed a complex, manual process into a simple, reusable, on-demand software component.
You might be thinking, "Can't I do this with a low-code tool or by building my own microservice?" While similar in goal, the service.do approach offers distinct advantages.
Now, expand this concept. Imagine defining all your core operations as service.do services:
By encapsulating each business capability into a standardized software service, you create a composable enterprise. Your entire operation becomes a collection of powerful, reusable APIs that can be combined and orchestrated to drive efficiency and innovation.
Stop wrestling with disconnected tools and start building a more connected, automated, and scalable business.
Ready to turn your complex workflows into simple APIs? Visit service.do to learn more and define your first service today.
Q: What is a 'Service-as-Software'?
A: It's the practice of encapsulating a specific business function or workflow—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.
Q: How is a .do Service different from a microservice?
A: While similar, .do Services are purpose-built for agentic workflows. They are designed to orchestrate other agents and services to complete complex business tasks. They are defined in simple code (Business-as-Code) and managed entirely by the .do platform, abstracting away infrastructure concerns.
Q: Do I need to manage servers to run my services?
A: No. The .do platform is fully serverless. You simply define your service's logic in code, and we handle the deployment, scaling, security, and execution. You focus on the business value, not the infrastructure.