What is Business-as-Code? The Next Evolution of Enterprise Automation

In the world of software development, we live by a code of rigor and discipline. We use version control like Git to track every change. We write comprehensive tests to prevent regressions. We structure our applications into services that are scalable, maintainable, and reliable.

So why, when it comes to our business operations, do we often resort to a tangled web of brittle scripts, manual processes, and fragile "glue code"?

The scripts that run month-end reports, the process for onboarding a new customer, the sequence of API calls that provisions a new environment—these are critical business functions. Yet, they rarely receive the same engineering discipline as our primary application code. They break silently, lack versioning, and become a nightmare to scale or modify.

It's time for a paradigm shift. What if we could treat our operational workflows as first-class software artifacts? This is the central premise of Business-as-Code, a revolutionary approach to enterprise automation.

The Cracks in Traditional Automation

For years, automation has meant writing scripts. A Python script here, a Bash script there, all held together by cron jobs and hope. This approach, while functional at a small scale, quickly accumulates technical debt.

The common pain points include:

• Brittleness: A small change to an API or data format can shatter the entire workflow.
• Lack of Visibility: The logic is hidden away on a server, often undocumented and understood by only one person.
• Difficult to Test: How do you reliably test a process that involves multiple third-party services and side effects?
• No Version Control: When a script is changed, the old version is often lost forever, making it nearly impossible to roll back to a known good state.
• Scalability Issues: A script designed to run once an hour may fail completely when it needs to run a thousand times a minute.

Business-as-Code addresses these problems head-on by applying modern software development principles to your operations.

Defining Business-as-Code

Business-as-Code treats your operational workflows as software artifacts. They can be version-controlled, tested, and deployed, providing greater reliability and scalability than brittle scripts or manual processes.

Instead of a scattered collection of scripts, your business process becomes a declarative piece of code stored in a repository. It has a clear input and output. Its execution is managed by a robust runtime, not a cron tab.

This is where devs.do enters the picture. It provides the runtime for this new paradigm, allowing developers to turn complex logic into scalable Services-as-Software.

How devs.do Implements Business-as-Code: Agentic Workflows

The core building block on the devs.do platform is the Agentic Workflow.

An Agentic Workflow is a sequence of tasks executed by specialized AI agents. Instead of writing complex imperative code, you simply declare the agents and the data to pass between them.

Think of it as assembling a team of specialists. You don't need to tell the git specialist how to clone a repository; you just tell it which repository to clone. You don't tell the security specialist how to scan for vulnerabilities; you just point it at the code.

The devs.do platform handles the orchestration, error handling, and execution, allowing you to focus on the business logic.

You define these workflows inside a unit called a "Doer"—a single-purpose, autonomous service that performs a specific task. By defining a Doer, you are codifying a piece of business logic and instantly turning it into a callable API endpoint.

From Theory to Practice: A Code Example

Let's see how simple it is to build a service that analyzes a git repository for code quality.

Here’s how you would define this as a "Doer" using the devs.do TypeScript SDK:

import { Doer, Client } from '@do-inc/sdk';

// Configure your client with an API key
const client = new Client({ apiKey: 'YOUR_API_KEY' });

// Define a new service (a "Doer")
const codeAnalysisService: Doer = {
  name: 'code-analyzer.devs.do',
  description: 'Analyzes a git repository for code quality.',
  input: {
    type: 'object',
    properties: {
      repoUrl: { type: 'string', description: 'The URL of the git repository.' },
    },
  },
  // Define the agentic workflow
  workflow: [
    { agent: 'git.clone', params: { url: '{{input.repoUrl}}' } },
    { agent: 'linter.run', params: { path: './cloned-repo' } },
    { agent: 'security.scan', params: { path: './cloned-repo' } },
  ],
};

// Deploy your new service to the .do platform
async function deployService() {
  const deployedDoer = await client.create(codeAnalysisService);
  console.log(`Service deployed successfully at: ${deployedDoer.url}`);
}

deployService();

Let's break this down:

1. Define the Contract: We give the service a name and define its input schema (repoUrl). This is our API contract.
2. Declare the Workflow: The workflow array is the heart of the service. It's a simple, readable list of steps. We declare that we want to clone a repo, run a linter, and then run a security scan. Note how we pass the input URL to the first agent using {{input.repoUrl}}.
3. Deploy: A single command, client.create(codeAnalysisService), takes this definition and deploys it to the devs.do platform, making it a live, scalable, and robust API endpoint.

This file can be checked into Git, peer-reviewed, and deployed through a CI/CD pipeline—just like any other critical piece of software.

The Future is Codified

By embracing Business-as-Code, you move beyond mere automation. You begin building a library of reusable, version-controlled, and testable business capabilities. Each "Doer" becomes a powerful building block—a Service-as-Software—that can be composed into even more complex workflows.

This isn't just about making operations more reliable; it's about fundamentally changing how you build and deliver business value. It's about empowering your developers to DEVELOP. AUTOMATE. DELIVER.

Ready to transform your operations into code? Visit devs.do to see how you can turn your complex business logic into powerful, scalable services.