The Future is Agentic: Building Your First Automated Service

In today's fast-paced digital landscape, business operations are growing more complex. Manual processes, disconnected systems, and inconsistent workflows create bottlenecks, slow down growth, and introduce human error. What if you could treat your business operations just like software? What if every critical process—from onboarding a customer to generating a financial report—was a robust, versioned, and scalable component you could call on demand?

This is the promise of an Agentic Workflow, a paradigm where complex business tasks are automated by intelligent services. Welcome to the world of Services-as-Software, where you can define any business capability, deploy it as a simple API, and deliver value consistently and at scale.

At service.do, we believe in turning your operations into code. Let's explore what that means and build your first automated service in just a few minutes.

What is a "Service-as-Software"?

Think about a common business task, like processing a new customer payment. This single task might involve multiple steps: validating payment details, calling a payment gateway, updating the customer's record in a CRM, creating an invoice, and sending a confirmation email.

Traditionally, this logic is either handled manually or buried deep within a monolithic application, making it hard to change or reuse.

Service-as-Software transforms this entire workflow into a self-contained, deployable software component. This "service" has a clear job, defined inputs (e.g., customer ID, amount), and defined outputs (e.g., transaction status). It can be versioned, tested, scaled, and invoked via an API, just like any other piece of software. You are literally turning your business processes into reusable, on-demand digital assets.

Building Your First Service: Customer Onboarding

Let's get practical. One of the most critical services for any business is customer onboarding. It's the first impression you make and often involves multiple systems. With service.do, you can define this entire workflow in simple, readable code.

Our platform lets you focus purely on the business logic. We handle the rest: deployment, scaling, security, and execution. It's fully serverless.

Here’s how you would define a customer-onboarding service using our TypeScript SDK:

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}`);

    // This is where your agentic workflow comes to life.
    // You can orchestrate other agents or call external APIs.
    // e.g., await agents.crm.createUser({ name: input.name, email: input.email });
    // e.g., await agents.billing.setupSubscription({ email: input.email, plan: input.plan });
    // e.g., await agents.email.sendWelcomeEmail({ to: input.email });

    const customerId = `cust_${context.invocationId}`;

    // Return a structured, predictable result
    return {
      customerId,
      welcomeEmailSent: true,
      status: 'complete',
    };
  },
});

Let's break this down:

1. Define the Contract: The OnboardingInput and OnboardingOutput interfaces create a clear, strongly-typed contract. You know exactly what data the service needs to run and what to expect back. This is the foundation of reliable automation.
2. Implement the Business Logic: The run function is the heart of your service. This is where you define the step-by-step process. Notice the comments—this is where you would orchestrate other services or "agents" to perform specific tasks like creating a user, setting up billing, or sending an email. This is the core of an Agentic Workflow: one service coordinating others to achieve a complex goal.
3. Deploy and Deliver: Once you write this code, the service.do platform takes over. It's instantly deployed as a secure, scalable API endpoint. No servers to manage, no infrastructure to provision. You just defined your business logic, and we turned it into a production-ready service.

How is This Different from a Microservice?

While they share similarities, a .do Service is purpose-built for agentic workflows and business process orchestration. They are designed from the ground up to be the connective tissue between other agents and services, focused on executing a complete business task.

Key differences:

• Business-Centric: They are defined as Business-as-Code, focusing on the what and why of the process, not just the how of the technology.
• Orchestration-Native: They are designed to call and coordinate other services to achieve an outcome.
• Fully Managed: The service.do platform abstracts away all infrastructure, allowing you to focus solely on the business value you're creating.

What Else Can You Build?

The possibilities are limited only by your operational needs. If you can describe a business process as a series of steps, you can build it as a service on service.do.

Imagine creating services for:

• Data Enrichment Pipelines: Take a new lead's email, enrich it with company data from Clearbit, and update your CRM.
• Automated Financial Reporting: At the end of each month, trigger a service that pulls data from Stripe, QuickBooks, and your internal database to generate a P&L report and send it to your exec team.
• Lead Qualification Systems: Automatically score new leads based on their a series of inputs and route them to the correct sales representative.
• Dynamic Content Generation: Create a service that takes a topic, generates an article outline using an AI agent, finds relevant images, and drafts a blog post.

Define. Deploy. Deliver.

The shift to Services-as-Software represents a fundamental change in how we build and scale modern businesses. By encapsulating your core operations into automated, on-demand services, you move from fragile manual processes to resilient, scalable, and efficient systems. You empower your entire organization to build, innovate, and deliver value faster than ever before.

Ready to turn your business logic into powerful software? Get started with service.do today and define your first automated service.