From Microservices to Atomic Actions: Granularity in System Design

The history of software architecture is a story of abstraction and granularity. We began with monoliths, giant, all-in-one applications that were simple to start but became unwieldy to scale and maintain. In response, we broke them apart into microservices—smaller, independent services that promised agility and resilience. This evolution was a clear step forward, but as we push the boundaries of automation and agentic workflows, a new, more fundamental unit of work is emerging: the atomic action.

This journey from monoliths to microservices was about finding the right-sized "building block" for applications. We're now realizing that for business processes and automation, the right-sized block is even smaller. It's the single, indivisible task.

The Shrinking Building Block: From Services to Actions

Microservices excel at defining boundaries around business capabilities (e.g., a "user service" or "payment service"). But what happens inside those services? They are composed of many smaller operations:

Update a database record.
Make a single API call.
Send a specific email.
Run a shell command.

In traditional systems, these operations are just lines of code buried within a larger service. They lack independent identity, observability, and reliability guarantees. A failure midway through a function can leave the system in an inconsistent state.

This is where the concept of an atomic action becomes revolutionary.

What is an Atomic Action?

An atomic action is a single, indivisible operation that either completes successfully or fails entirely, leaving no partial state. This guarantees data integrity and reliability in your workflows.

Think of it as the transaction of business logic. It's the smallest possible unit of execution that has meaning. action.do is built on this principle, offering a platform where actions are:

Reliable: Actions can be configured with automatic retries and robust error handling, ensuring that transient failures don't derail your entire workflow.
Atomic: The all-or-nothing guarantee is fundamental. An action to send-welcome-email either succeeds perfectly or fails cleanly, without leaving orphaned data or sending a partial message.
Auditable: Every single execution is logged and tracked. You get a complete, transparent audit trail for every task, which is critical for compliance, debugging, and understanding your business processes.

From Function Call to Managed Action

You might be thinking, "Isn't this just a function call?" That's a fair question. The difference lies in the layer of management and observability that action.do provides.

Calling a simple function is like firing a bullet in the dark. You hope it hits the target, but you have no built-in tracking or recovery mechanism. Executing an action with action.do is like launching a guided missile: it's tracked, its status is known at all times, and it has a clear, predefined mission.

Let's see what this looks like in practice.

import { DotDo } from '@do-platform/sdk';

const client = new DotDo({ apiKey: 'YOUR_API_KEY' });

// Execute a predefined action, 'send-welcome-email'
async function sendWelcomeEmail(userId: string) {
  const result = await client.action('send-welcome-email').execute({
    userId: userId,
    template: 'new-user-template-2024',
  });

  console.log(`Action completed with status: ${result.status}`);
  return result;
}

Notice you're not just invoking code; you're executing a named, versioned, and managed task: 'send-welcome-email'. The platform handles the underlying complexity, giving you back a simple, auditable result. This elevates a simple task to a first-class, managed service within your architecture.

Building Complex Workflows from Atomic Units

The power of atomic actions truly shines when you start composing them. action.do is designed to be the fundamental building block for larger systems.

While a single atomic action handles one task flawlessly, you can use an orchestration agent or a tool like workflow.do to chain these actions together. This creates powerful, complex, and incredibly resilient services.

Agentic Workflow: An AI agent needs to book a flight. It executes a series of atomic actions: search-flights, select-seat, process-payment, send-confirmation-email. If any action fails, the orchestrator knows exactly where the process broke down and can decide to retry, roll back, or alert a human.
Business Process Automation: Onboarding a new employee involves updating HR systems, creating an email account, and assigning to a project board. Each of these steps can be a distinct, auditable atomic action, chained together to form a robust onboarding workflow.

By focusing on the perfection of the single step, you build a foundation of trust and reliability that makes the entire journey more resilient.