Unlock the Power of Services-as-Software with service.do

In today's digital landscape, businesses don't just sell products; they deliver services. From onboarding a new customer to processing an insurance claim or orchestrating a complex logistics chain, these multi-step processes are the lifeblood of your operation. Yet, how are they typically managed? Often, through a fragile web of manual handoffs, disconnected spreadsheets, brittle scripts, and endless email chains.

This approach doesn't scale. It’s opaque, error-prone, and slow to change.

What if you could treat a complex business service with the same discipline and power as you treat application code? What if you could define, version, test, and deploy a business process like a piece of software? This is the core principle behind Services-as-Software, a revolutionary approach to workflow orchestration. And service.do is the platform built to make it a reality.

The Problem with Traditional Workflows

If you're a developer or an engineering leader, you've seen the chaos firsthand:

• Lack of Visibility: When a process fails, it’s a fire drill to figure out where and why. There’s no central dashboard or log.
• Brittleness: A small change in one system can unexpectedly break the entire workflow.
• Manual Intervention: Critical steps often rely on a human to manually transfer data or click a button, introducing delays and potential for error.
• Disconnected Systems: Stitching together APIs from different domains requires custom glue code that is difficult to maintain and understand.

These challenges create technical debt and, more importantly, they stifle business agility. You can't innovate or respond to market changes quickly when your core processes are locked in a rigid, manual structure.

A New Paradigm: Business-as-Code

The Services-as-Software paradigm, also known as Business-as-Code, proposes a simple but powerful shift: define your business processes in code.

By representing workflows as version-controlled software artifacts, you gain the full power of modern software development practices:

• Version Control: Track every change, collaborate with your team, and roll back if needed using Git.
• Testing: Write automated tests for your business processes to ensure they work as expected.
• Modularity: Break down large, monolithic processes into smaller, reusable, and composable services.
• API-Driven: Expose any workflow as a simple, reliable API endpoint, making it easy to integrate and trigger.

service.do is the definitive Business-as-Code Orchestration platform, designed to help you go from complex, messy processes to simple, reliable software.

How It Works: A Customer Onboarding Example

Talk is cheap. Let's see how you can use service.do to define a customer onboarding service. This process typically involves multiple steps across different systems: identity verification, account creation, and communication.

With service.do, you define this entire orchestration as a clear, declarative workflow.

import { Service, Workflow } from '@do/sdk';

// Define the workflow for onboarding a new customer
const onboardCustomerWorkflow = new Workflow('onboard-customer-workflow', {
  steps: [
    {
      name: 'Verify Customer Identity',
      uses: 'identity.do/verify',
      inputs: {
        email: '{{ trigger.body.email }}',
        document: '{{ trigger.body.documentId }}'
      }
    },
    {
      name: 'Create User Account',
      uses: 'account.do/create',
      needs: ['Verify Customer Identity'],
      inputs: {
        email: '{{ steps.Verify Customer Identity.outputs.email }}',
        status: '{{ steps.Verify Customer Identity.outputs.status }}'
      }
    },
    {
      name: 'Send Welcome Email',
      uses: 'email.do/send',
      needs: ['Create User Account'],
      inputs: {
        to: '{{ steps.Create User Account.outputs.email }}',
        template: 'welcome-email'
      }
    }
  ]
});

// Expose the workflow as a callable service
export const OnboardCustomer = new Service('onboard-customer', {
  workflow: onboardCustomerWorkflow,
  // Make this service available via a public API endpoint
  trigger: 'api'
});

Let's break down what's happening here:

1. Define a Workflow: We create a Workflow that consists of several steps.
2. Orchestrate Steps: Each step performs a distinct action. The uses key calls a pre-built component (like identity.do/verify or email.do/send), promoting reusability.
3. Manage Dependencies: The needs key explicitly declares that the Create User Account step can only run after Verify Customer Identity is complete. The platform manages the state and execution order automatically.
4. Pass Data: Data flows seamlessly between steps. The output of one step (e.g., {{ steps.Verify Customer Identity.outputs.email }}) becomes the input for the next.
5. Expose as a Service: Finally, we wrap the Workflow in a Service and set the trigger to 'api'. Just like that, this entire complex business process is now available as a single, callable API endpoint.

No more glue code. No more manual handoffs. Just a clean, readable, and robust definition of your business service.

Diving Deeper: Your Questions Answered

What is a 'Service' in the context of .do?

A Service on the .do platform is a runnable business process, defined as code. It orchestrates a series of steps (a Workflow) to accomplish a specific business outcome, like onboarding a customer or processing a claim. Services are version-controlled, testable, and callable via simple APIs.

How are services different from simple functions or APIs?

While a traditional API might perform a single task (e.g., fetch user data), a Service orchestrates multiple, potentially long-running, steps across different domains. It manages state, dependencies, and error handling for the entire business process, providing a higher level of abstraction than a single function.

Can I chain multiple services together?

Absolutely. The platform is designed for composition. A step within one Service's Workflow can call another Service. This allows you to build highly complex, enterprise-grade processes from smaller, reusable, and maintainable service components.

How do I trigger a Service?

Services can be triggered in multiple ways. You can expose a Service as a public API endpoint for on-demand execution, schedule it to run at specific intervals, or trigger it based on events from other systems or .do domains.

From Fragile Scripts to Agentic Workflows

Adopting the Services-as-Software model with service.do delivers transformative benefits:

• Total Reliability: The platform manages state, retries, and error handling, ensuring your processes run to completion even when individual steps fail.
• Effortless Scalability: Execute thousands of workflows in parallel without worrying about the underlying infrastructure.
• Unprecedented Agility: Need to add a fraud check step? Simply add it to your workflow code, test it, and deploy. Your business logic is no longer brittle.
• Complete Observability: Get a complete, auditable log of every service execution, with deep insight into each step's inputs, outputs, and duration.
• Future-Ready: This compositional model is the foundation for building sophisticated agentic workflows, where AI agents can be orchestrated to perform complex business tasks.

It's time to stop wrestling with invisible, unmanageable processes. It's time to start delivering services as software.

Ready to transform your business operations? Visit service.do today to get started and turn your most complex services into simple, reliable software.