Integrating Slack: A Practical Guide to Building a .do Notification Service

In the world of automated workflows and agentic systems, real-time feedback is not just a luxury; it's a necessity. Whether you're tracking new user sign-ups, monitoring system health, or celebrating a completed sale, instant notifications are key to staying informed. Slack has become the de facto command center for many teams, making it the perfect destination for these critical alerts.

But how do you build a notification system that is reliable, reusable, and seamlessly integrates into your larger business processes?

Enter action.do. Instead of writing one-off scripts or managing complex serverless functions, you can define your notification logic as an atomic action—a granular, single-responsibility task that executes flawlessly as a powerful API endpoint.

Today, we'll walk through how to build a robust send-slack-message action using action.do, transforming a simple task into a cornerstone of your "Business-as-Code" strategy.

What is an Atomic Action? A Quick Refresher

Before we dive in, let's clarify what we mean by an "atomic action" in the context of action.do.

An atomic action is a self-contained, single-responsibility task designed to either complete successfully or fail entirely, leaving no messy partial states. It's the smallest indivisible unit of work in your workflow.

Think of actions like:

• send-email
• create-user-record
• charge-credit-card
• And, the focus of our guide: send-slack-message

This "all or nothing" principle is what makes your automations robust. You can be certain a notification was sent, or you'll know precisely why it failed, allowing for automated retries or escalations.

Prerequisites

To follow along, you'll need:

• A action.do account and your API key.
• A Slack workspace where you have permission to add apps.
• Basic familiarity with Node.js/TypeScript and API concepts.

Step 1: Create a Slack Incoming Webhook

First, we need to give our action a secure way to post messages to a specific Slack channel. Slack's Incoming Webhooks are perfect for this.

1. Navigate to the Slack App Directory and add the "Incoming WebHooks" app to your workspace.
2. Choose a default channel for the webhook to post to (you can override this later) and click "Add Incoming WebHooks Integration".
3. Slack will generate a unique Webhook URL. It will look something like https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX.
4. Copy this URL. Treat it like a password! We will store it securely as a secret in the action.do environment.

Step 2: Define the send-slack-message Action

This is where the "Business-as-Code" philosophy shines. On the action.do platform, you define the logic for your action. This includes its name, its expected inputs, and the code to execute.

Let's define our action conceptually.

• Action Name: send-slack-message
• Secrets: We'll create a secret named SLACK_WEBHOOK_URL and paste our webhook URL there. This prevents hardcoding sensitive information.
• Input Schema: We'll define what data our action needs to run:
  • text (string, required): The message content.
  • channel (string, optional): The Slack channel to post in (e.g., #alerts).
  • username (string, optional): The name the bot will post as.
• Action Logic (Node.js/TypeScript):

/*
  This represents the code you would write inside the action.do
  platform for the 'send-slack-message' action.
*/
import { fetch } from 'undici';

// The handler function that action.do runs
export default async function handler({ input, secrets }) {
  // Securely access the webhook URL from environment secrets
  const SLACK_WEBHOOK_URL = secrets.SLACK_WEBHOOK_URL;
  
  const { text, channel, username } = input;

  if (!text) {
    throw new Error('Input validation failed: "text" is a required input.');
  }

  // Construct the payload for the Slack API
  const payload = {
    text,
    channel, // Slack uses the webhook's default if this is omitted
    username: username || 'Do Bot',
  };

  const response = await fetch(SLACK_WEBHOOK_URL, {
    method: 'POST',
    body: JSON.stringify(payload),
    headers: { 'Content-Type': 'application/json' },
  });

  if (!response.ok) {
    const errorText = await response.text();
    // Throwing an error ensures the action fails atomically
    throw new Error(`Slack API request failed: ${errorText}`);
  }

  // A successful return object signals completion
  return { success: true, message: 'Notification sent successfully.' };
}

By defining this once, you now have a hardened, reusable API endpoint for sending any Slack message, available across all your applications.

Step 3: Execute the Action from Your Application

With the send-slack-message action defined and waiting, calling it from your application codebase is incredibly simple. Using the @do-sdk/core, you can trigger it with a clean, declarative call.

Here’s how you might use it in a TypeScript application to announce a new user sign-up.

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

// Initialize the SDK with your API key
const dō = new Dō({ apiKey: 'YOUR_API_KEY' });

async function notifyOnNewUser(userId: string) {
  console.log(`Triggering Slack notification for new user: ${userId}`);
  
  try {
    // Define and execute the single, atomic action
    const result = await dō.action.execute({
      name: 'send-slack-message',
      input: {
        channel: '#signups',
        username: 'Signup Bot',
        text: `🎉 A new user just joined! Welcome user-id: ${userId}`,
      },
    });

    console.log('Action executed successfully!', result);
    // { success: true, transactionId: 'txn_abc_123' }

  } catch (error) {
    console.error('Failed to execute Slack notification action:', error);
  }
}

// Example usage within your application's logic
notifyOnNewUser('user-b2d9-4c7a');

That's it! You've successfully decoupled your notification logic from your core application code.

From Atomic Action to Powerful Workflow

The real power of action.do is revealed when you start composing these atomic actions into larger, more complex processes using workflow.do. Our send-slack-message action is no longer just a utility; it's a fundamental building block.

Consider a complete new user onboarding workflow:

1. create-user: An action that adds the user to your database.
2. send-welcome-email: An action to send a personalized welcome message.
3. send-slack-message: Our new action to notify the team internally.
4. provision-trial-account: An action that sets up a trial environment for the user.

By chaining these single-responsibility actions, you create a robust, observable, and easily maintainable service. If the email fails, it doesn't stop the Slack message. If the database write fails, the entire workflow stops before side effects occur, thanks to the transactional integrity of atomic actions.

Why Not Just Use a Serverless Function?

While a serverless function can achieve a similar outcome, action.do is a higher-level abstraction designed specifically for business logic and agentic workflows. It provides:

• Built-in Orchestration: Easily chain actions into complex workflows without boilerplate code.
• State Management & Logging: Every execution is tracked with a transaction ID, inputs, and outputs.
• Simplified Security: Manage secrets and context without building your own infrastructure.
• Focus on Business Logic: You write the code for what you want to do, and action.do handles the how of executing it reliably.

Build, Execute, Automate

You've just built your first atomic notification service—a reusable, reliable, and scalable component for all your automation needs. By thinking in terms of small, composable actions, you lay the foundation for powerful "Business-as-Code" that can grow and adapt with your organization.

Ready to build more robust automations? Get started with action.do and turn your business logic into powerful API endpoints.