The .do Philosophy: Auditable, Atomic, and Composable Business Automation

In the world of software, we often talk about building complex systems from simple, reliable parts. We break down user interfaces into components and applications into microservices. So why do we still write business automation as long, brittle scripts that are hard to debug, impossible to audit, and terrifying to re-run?

The paradigm of "Business-as-Code" demands a better approach. It requires a methodology that treats business processes with the same rigor and discipline as production software. This is where the .do philosophy begins: with a single, powerful building block called action.do.

The Power of the Atomic Action

At the core of any robust system is the concept of atomicity. An atomic action is a single, indivisible operation that either completes successfully or fails entirely, leaving no messy, partial state behind.

Think about it:

• Sending a single, specific email.
• Making one API call to create a user.
• Writing a single record to a database.

These are atomic. In contrast, a script that tries to do all three is not. If it fails after creating the user but before sending the email, your system is now in an inconsistent state.

action.do is designed to define and execute only these single, atomic actions. This focus provides a guarantee: the task you requested was either done perfectly, or it wasn't done at all. There is no in-between. This simple guarantee is the foundation for building incredibly reliable systems.

Execution as Code: Simple, Clear, and Intentional

Building on this philosophy means interacting with your business logic should be as clear as calling a function. You shouldn't need to know the intricate details of your email provider's API; you should only need to declare your intent.

Here’s how you execute an action with the .do SDK:

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

// Initialize the .do client with your API key
const a = new Do(process.env.DO_API_KEY);

// Execute a specific, atomic action with parameters
const { result, error } = await a.action.execute({
  name: 'send-welcome-email',
  params: {
    userId: 'usr_12345',
    template: 'new-user-welcome-v2'
  }
});

if (error) {
  console.error('Action failed:', error);
} else {
  console.log('Action Succeeded:', result);
}

This code is declarative. It states what should happen (send-welcome-email) and provides the necessary context (userId, template), but it abstracts away the how. This separation makes your code cleaner, easier to read, and simpler to maintain.

The Pillars of Reliable Automation

Atomic actions form the foundation, but two other principles are crucial for building enterprise-grade, agentic workflows that you can trust.

1. Idempotency: The Safety to Retry

Idempotency ensures that executing the same action multiple times with the same parameters has the exact same effect as executing it just once. Why is this a game-changer? Because failures are inevitable. Networks drop, and services time out. In an idempotent system, you can simply retry a failed action without worrying about dangerous side effects, like sending a customer five duplicate invoices or creating three identical user accounts. It makes your system resilient and self-healing.

2. Auditability: A Perfect Record of Everything

Because every piece of work is a discrete, named action.do call with explicit parameters, you get a perfect audit trail automatically. Every execution—whether it succeeded or failed—is a log entry. This provides unparalleled visibility into your business processes. You can answer critical questions instantly:

• When was the welcome email sent to user usr_12345?
• What parameters were used?
• Which system initiated the action?

This is our mantra: Execute. Audit. Repeat.

From Actions to Workflows: Composing the Big Picture

Of course, a single action rarely accomplishes a complete business goal. Onboarding a new customer involves creating a record, sending an email, assigning a task in your CRM, and maybe adding them to a mailing list.

This is where composition comes in.

• action.do represents the individual, atomic steps—the unbreakable building blocks.
• workflow.do is the orchestrator. It defines a sequence or graph of these actions to achieve a larger business outcome.

You build robust workflow.do processes by composing them from reliable, auditable, and idempotent action.do components. This bottom-up approach ensures that even the most complex, multi-step agentic workflows are built on a foundation of trust and reliability.

Define Your Own Actions

The .do platform isn't a closed box. You can bring your own business logic to the table. By wrapping your existing functions or microservices, you can define your own custom actions. This turns your proprietary logic into a reusable, auditable, and idempotent component that can be seamlessly integrated into any workflow, creating a unified and powerful system for your entire Business-as-Code infrastructure.

Ready to build better business automation? Start with the fundamental building block. Start with action.do.