workflow.do - Orchestrate Complex Business Logic as Code

Automating a single task is one thing. Sending a notification, creating a user, updating a database record—these are the solved problems of modern development. But what happens when your business process isn't just one task, but a dozen? When it involves conditional logic, error handling, and passing data between steps?

Too often, these complex processes become a tangled web of brittle scripts, hard-to-maintain serverless functions, and cron jobs that no one dares to touch. State is managed in temporary files, error handling is an afterthought, and versioning the entire process feels impossible.

While action.do gives you the power to execute flawless, atomic actions—the fundamental verbs of your business—workflow.do provides the grammar to compose them into a powerful narrative. It’s how you turn a collection of single-responsibility tasks into a robust, version-controlled, and testable business process.

Beyond Simple Execution: The Challenge of Orchestration

Executing a single, atomic action is powerful because of its reliability. It either succeeds completely or fails entirely. But real-world automations are sequences. Consider a standard user onboarding process:

1. Create a user record in the primary database.
2. If successful, add the user to your CRM.
3. If that succeeds, provision their initial resources.
4. Finally, send a welcome email.

If step #2 fails, you can't just stop. You need a way to roll back step #1 or at least flag the user's state as incomplete. You need to manage the flow, handle failures gracefully, and maintain state across every step. This is the job of an orchestrator, and building one from scratch is a significant engineering challenge.

Introducing workflow.do: Your Business Logic as Code

workflow.do is the orchestration layer built on top of the atomic actions you define. It lets you chain these actions together, manage state, and handle complex logic, effectively turning your most sophisticated business processes into code.

Think of it this way:

• action.do are the LEGO bricks: Each is a perfect, single-purpose unit like send-email, create-user, or charge-card.
• workflow.do is the instruction manual: It tells you exactly how to connect the bricks in the right sequence, with the right logic, to build the entire spaceship.

This is the core of Business-as-Code: treating your operational processes with the same rigor as your application code.

How it Works: A Conceptual Example

While action.do executes a single command, a workflow.do definition describes the entire sequence, including how data flows from one step to the next.

Let's model our user onboarding process. You would have already defined atomic actions for create-user, add-user-to-crm, and send-welcome-email. Now, you orchestrate them:

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

const dō = new Dō({ apiKey: 'YOUR_API_KEY' });

// Define a multi-step workflow for user onboarding
const signupWorkflow = dō.workflow.define({
  name: 'new-user-onboarding-flow',
  trigger: { type: 'api' }, // Can be triggered by a webhook or API call
  steps: [
    {
      id: 'createUser',
      action: 'create-user-db',
      input: {
        email: '{{ trigger.body.email }}', // Data from the initial trigger
        name: '{{ trigger.body.name }}',
        plan: 'free-tier',
      },
    },
    {
      id: 'syncToCrm',
      action: 'add-user-to-crm',
      input: {
        // Use the output from the previous step
        userId: '{{ steps.createUser.output.userId }}',
        email: '{{ trigger.body.email }}',
      },
    },
    {
      id: 'sendWelcome',
      action: 'send-welcome-email',
      input: {
        userId: '{{ steps.createUser.output.userId }}',
        template: 'new-user-welcome',
      },
    },
  ],
  // Define what happens if any step fails
  onFailure: {
    action: 'notify-devops-team',
    input: { message: 'Onboarding failed for {{ trigger.body.email }}' }
  }
});

// To run the workflow:
// await signupWorkflow.execute({ body: { email: 'user@example.com', name: 'Alex' } });

This simple definition unlocks tremendous power:

1. Declarative Orchestration: The logic is clear, readable, and defined in one place. You can see the entire flow at a glance.
2. Automatic State Management: Notice how the userId from the createUser step is seamlessly passed as input to the next steps using the {{ steps.createUser.output.userId }} syntax. workflow.do manages this state transfer for you.
3. Built-in Resilience: The onFailure block defines a clear, automated response if any action in the chain fails. No more silent failures. You can build sophisticated retry logic, compensation actions (rollbacks), and conditional paths.

The Benefits of a Workflow-Driven Approach

When you model your agentic workflows and automations this way, you move from fragile scripting to professional software engineering.

• Maintainability: Is the welcome email template changing? You only need to update the send-welcome-email action. Is the business logic changing? You update the declarative workflow file. Complexity is isolated.
• Testability: Each atomic action can be unit-tested. The entire workflow can be integration-tested by triggering it and asserting the final state, creating a reliable test suite for your business processes.
• Version Control: Your entire business process lives in code. It can be tracked in Git, reviewed by peers, and deployed through CI/CD pipelines, just like any other critical piece of software.
• Visibility and Debugging: With a centralized orchestrator, you get a complete, step-by-step log of every workflow execution. When something goes wrong, you can pinpoint the exact failing action and its input data, dramatically reducing debugging time.

Build Your Business on a Foundation of Code

Stop scripting and start orchestrating. By combining the transactional integrity of action.do with the intelligent orchestration of workflow.do, you can build automations that are not just powerful, but also reliable, scalable, and a pleasure to maintain.

This is the future of agentic workflows and Business-as-Code. It's time to treat your business logic like the critical asset it is.

Ready to turn your complex processes into reliable code? Explore the documentation and start building with workflow.do today.