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

In any modern business, communication is key. Whether it's a new lead in your CRM, a completed payment, or a critical system alert, getting the right information to the right people at the right time is crucial. Workflows and automations often end with a notification, and for many teams, the hub for that real-time information is Slack.

But building notification logic directly into every single application or script is inefficient. It leads to duplicated code, maintenance headaches, and a lack of centralized control. What if you could build your Slack notification logic once and reuse it across any workflow?

This is the power of the .do platform. By encapsulating tasks into atomic, reusable units, you can build robust and scalable systems. In this guide, we'll walk you through a practical example: creating a centralized Slack notification service using a single action.do.

The Power of an Atomic Notification Action

Before we dive into the code, let's understand why using an action.do for this is a game-changer. An atomic action is the smallest indivisible unit of work on the .do platform. It's a self-contained function designed to do one thing and do it well.

For our Slack notifier, this means:

• Reusability: Define the send-slack-message action once. Use it in your user onboarding workflow, your payment processing agent, or your system monitoring alerts.
• Maintainability: If you need to update your message formatting or change how you authenticate with Slack, you only need to edit one action. Every workflow that uses it will automatically get the update.
• Observability: Every time your action is executed, the .do platform logs the inputs, outputs, and execution status. You have a perfect audit trail of every notification sent, without writing a single line of logging code.

Prerequisites

To follow along, you'll need two things:

1. A .do Platform API Key: You can get this from your account dashboard.
2. A Slack Incoming Webhook URL: This is a simple way to post messages from apps into Slack. You can create one in just a few clicks. Follow the official Slack guide to generate your URL. For security, we'll store this URL as an environment variable named SLACK_WEBHOOK_URL.

Step 1: Define the send-slack-message Action

The first step is to define the "what" and the "how" of our action. We'll give it a name, describe what it does, define its inputs, and then provide the handler code that performs the logic.

We'll use the @do-platform/sdk to create our new action. The action will take a single string input, message, and send it to the Slack channel configured in our webhook.

import { Do } from '@do-platform/sdk';
import fetch from 'node-fetch'; // Or any other HTTP client

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

// Retrieve the secure webhook URL from environment variables
const slackWebhookUrl = process.env.SLACK_WEBHOOK_URL;

if (!slackWebhookUrl) {
  throw new Error('SLACK_WEBHOOK_URL environment variable not set.');
}

// Define our new atomic action for sending Slack messages
const slackNotifierAction = await-do.action.create({
  name: 'send-slack-message',
  description: 'Sends a formatted message to a predefined Slack channel via webhook.',
  inputs: {
    message: 'string', // The text content of the message to send
  },
  handler: async (inputs) => {
    try {
      const response = await fetch(slackWebhookUrl, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({ text: inputs.message }),
      });

      if (!response.ok) {
        // Slack API did not return a 2xx response
        const errorText = await response.text();
        console.error('Slack API error:', errorText);
        return { success: false, error: `Slack API returned status ${response.status}` };
      }

      // The message was sent successfully!
      return { success: true };

    } catch (error) {
      console.error('Failed to send Slack message:', error);
      return { success: false, error: error.message };
    }
  }
});

console.log('Action created:', slackNotifierAction.id);

With this code, we've registered a new, reusable building block in our .do environment. The platform now knows about an action named send-slack-message, understands its inputs, and has the versioned code ready to execute on demand.

Step 2: Execute the Action in a Workflow

Defining an action is only half the story. Its true power is unlocked when it's executed as a step in a larger agentic workflow.

As a core principle, actions on the .do platform are atomic and don't call each other. They are orchestrated by higher-level .workflow.do agents.

Imagine a simple user onboarding workflow. The steps might be:

1. Create a user record in the database (create-user-in-db action).
2. Enrich the user's profile with external data (enrich-user-profile action).
3. Send a notification to the #signups channel (send-slack-message action).

Executing our new action within that workflow would be as simple as this:

// This is a conceptual example of a step within a larger workflow.
// Your workflow agent would orchestrate these calls.

const newUserEmail = 'new-customer@example.com';

// ...previous steps in the workflow succeed...

console.log('Notifying team about new signup...');

// Execute our reusable Slack action
const notificationResult = await-do.action.run('send-slack-message', {
  message: `🎉 New user signed up! Email: ${newUserEmail}`
});

if (notificationResult.success) {
  console.log('Slack notification sent successfully.');
} else {
  console.error('Failed to send Slack notification:', notificationResult.error);
}

Notice how clean this is. The orchestration logic doesn't need to know anything about HTTP requests, webhook URLs, or JSON payloads. It simply invokes the named action with the required inputs. Our send-slack-message action is now a reliable, observable, and composable tool in our automation arsenal.

From a Single Action to Business-as-Code

You've just built more than a simple notifier; you've created a piece of Services-as-Software. This atomic action is a durable, managed component that can be composed into countless business processes.

By building your automation on a foundation of small, single-purpose actions, you create a system that is easier to understand, debug, and scale. This is the future of agentic workflows.

Ready to start building your own atomic units of automation? Define. Execute. Repeat.