The Shift to Services-as-Software: Packaging Your Business Logic as Atomic Actions

In the world of software development and business automation, complexity is the enemy. Monolithic applications and brittle, tangled scripts make it difficult to adapt, scale, and maintain processes. The promise of "Business-as-Code" is to tame this complexity, but how do we get there? The answer lies in thinking smaller. Much smaller.

The future of automation isn't about writing bigger scripts; it's about defining smaller, more intelligent building blocks. This is the core philosophy behind action.do: a platform for creating powerful, agentic workflows by packaging your business logic into atomic actions. It represents a fundamental shift towards treating your operations as Services-as-Software.

The Building Block of Automation: What is an Atomic Action?

An atomic action is the smallest, indivisible unit of work in a system. It's a self-contained, reusable function designed to perform one single task reliably and predictably.

Think of it like a Lego brick. A single brick is simple, but when you combine them, you can build anything. In the world of workflow orchestration, an atomic action is your brick.

• send-an-email
• create-a-user
• query-a-database
• charge-a-credit-card

Each of these is a perfect candidate for an action.do. It performs a single, well-defined job, takes specific inputs, and produces a predictable output. By encapsulating any single, repeatable task as a self-contained Action, you can chain them together to create powerful, intelligent automations.

From Code to Action: A Practical Example

Defining an Action on the .do platform is designed to be as straightforward as writing a function. You focus on the core logic, and the platform handles the rest.

Here’s a simple example in TypeScript showing how to define an Action that sends a welcome email to a new user.

import { Action } from '@do-sdk/core';

// Define a new Action to send a welcome email
const sendWelcomeEmail = new Action({
  name: 'send-welcome-email',
  description: 'Sends a standardized welcome email to a new user.',
  handler: async (inputs: { email: string; name:string }) => {
    console.log(`Preparing to send email to ${inputs.email}...`);

    // Logic to connect to an email service (e.g., SendGrid, SES)
    // const emailSent = await emailService.send({
    //   to: inputs.email,
    //   subject: `Welcome, ${inputs.name}!`,
    //   body: 'We are so glad you joined us...'
    // });

    const result = { success: true, messageId: `msg_${Date.now()}` };
    console.log('Email sent successfully:', result.messageId);
    return result;
  },
});

// Execute the action via the .do SDK
async function run() {
  const execution = await sendWelcomeEmail.run({
    email: 'alex@example.com',
    name: 'Alex',
  });
  console.log('Execution Result:', execution);
}

run();

Let's break this down:

1. Define: We create a new Action, giving it a unique name and a human-readable description. This makes it discoverable.
2. Handler: The handler is an async function containing your core business logic. It receives typed inputs and returns a result. This is where you'd put your API automation logic, like calling the SendGrid or AWS SES API.
3. Run: Executing the action is as simple as calling .run() with the required inputs.

More Than a Function: Why Actions are Supercharged

You might be thinking, "Isn't this just a serverless function?" While similar, Actions on .do are supercharged for the world of Business as Code.

Unlike traditional serverless functions, .do Actions are automatically instrumented with the features you'd otherwise have to build yourself:

• Automatic Logging & Instrumentation: Every execution is logged with its inputs, outputs, and duration.
• Built-in Error Handling & Retries: Configure robust retry policies directly on the Action, ensuring resilience.
• Versioning: Safely update your Actions without breaking existing workflows.
• Discoverability & Composition: Actions are designed to be found and used by other developers and even AI agents, creating a composable ecosystem.

This turns your business logic from isolated code into managed, reliable, and reusable components.

Building Complexity from Simplicity

The true power emerges when you orchestrate these atomic actions. While an Action is designed to be atomic, you can compose them within a workflow.do file to handle complex processes.

This pattern promotes a clear separation of concerns. Instead of an Action calling another Action directly, a Workflow directs the flow of data between them.

Example Workflow: New User Onboarding

1. Action: create-user-in-db
2. Action: send-welcome-email (our example from above)
3. Action: add-user-to-crm
4. Action: post-notification-to-slack

A workflow orchestrates these four independent, reusable Actions to complete a complex business process. This architecture is modular, easy to debug (you can pinpoint exactly which Action failed), and incredibly flexible.

What Can You Build with Actions? DO MORE, FASTER.

Virtually any task you can script can become an Action. If you can code it, you can turn it into a reusable building block for your automation library. Common use cases include:

• Third-Party API Interactions: Create Actions for Stripe (create-charge), Slack (send-message), or Salesforce (create-lead).
• Database Operations: Build a library of actions like fetch-user, update-order-status, or delete-product.
• Data Transformations: resize-image, convert-csv-to-json, sanitize-user-input.
• Machine Learning: run-model-inference, get-text-embedding, classify-image.

By building a catalog of these atomic actions, you are creating a true platform of Services-as-Software. You're not just writing code; you're building a library of executable business capabilities that can be combined and recombined to meet any challenge. This is the foundation for building powerful, scalable, and truly agentic workflows.