Skip to main content

Make.com + Slack: Build Smart Team Notification and Workflow Bots

· 11 min read
Yassine El Haddad
Yassine El Haddad
Software Developer & Automation Specialist

I build production AI agents, web scrapers, and automation pipelines. Most of what I publish here comes from the actual problems they run into: proxies that get banned, anti-bot stacks that fingerprint your client, RAG that drifts when the underlying data moves. Stack: Python, TypeScript, Go, FastAPI, LangChain, Crawlee, Playwright, deployed on AWS, GCP, and Cloudflare.

Most teams use Slack for communication but still rely on someone manually typing status updates, copying alerts from one tab to another, or pasting reports into channels. Make.com eliminates that entirely — you can connect Slack to any app or data source and send precisely targeted messages without writing a single line of code.

This guide covers everything from basic message sending to building interactive bots that respond to button clicks, watch channels for keywords, and aggregate standup updates into a single daily summary.

Why Make.com Is the Right Tool for Slack Automation​

Make.com has a dedicated Slack module with over 30 actions and triggers. Unlike simpler tools like Zapier, Make lets you build multi-step branching logic — filter duplicate alerts, aggregate multiple updates before sending, and route messages to different channels based on conditions. The visual scenario editor makes the flow easy to debug and maintain.

What you can automate with Make.com + Slack:

Use CaseTriggerOutcome
Error alertsMonitoring app → Make webhookSlack #alerts message with severity
Daily standup digestSchedule (every weekday 9am)Collected responses posted as one message
New lead notificationsCRM or form submissionPersonalized Slack DM to sales rep
Channel keyword monitoringNew Slack messageTagged response or external action
Interactive approvalsSlack button click → Make webhookTrigger downstream workflow

Best for: Teams that want smart, noise-reducing notifications — not just raw data blasts.

Setting Up the Slack Connection in Make.com​

Before building any scenario, you need to connect your Slack workspace.

  1. In Make.com, open any scenario and add a Slack module.
  2. In the module's connection field, click Add and follow the OAuth flow to authorize Make in your Slack workspace.
  3. Grant the required scopes — at minimum: chat:write, channels:read, users:read.

Make stores the connection and reuses it across all scenarios. If you need to post to multiple workspaces, add a separate connection for each.

Scenario 1: Send a Formatted Slack Message​

The most common pattern: trigger an action in App A → send a message to Slack.

Example: Send a Slack alert every time a new row is added to a Google Sheet.

Steps:

  1. Add trigger: Google Sheets → Watch Rows (polls for new rows every 15 minutes).
  2. Add action: Slack → Create a Message.
  3. In the message body, map the sheet columns into your text:
New lead received:
*Name:* {{name}}
*Email:* {{email}}
*Source:* {{source}}
  1. Set Channel to #leads.
  2. Enable Link Names to auto-hyperlink @mentions.

Key fields in the Slack Create a Message module:

FieldWhat It Does
ChannelID or name of the target channel
TextPlain message body (supports *bold*, _italic_, <URL|label>)
BlocksJSON for Block Kit layouts (see next section)
Thread TimestampPosts as a reply in a thread
Username / IconOverride the bot name and avatar per message

Scenario 2: Rich Messages with Block Kit​

Slack's Block Kit lets you build structured messages with sections, dividers, buttons, and input fields. Make.com supports the full Block Kit spec via the Blocks field in the message module.

Why Use Block Kit?​

Plain text messages get buried. Block Kit messages are visually scannable — they stand out in busy channels and communicate priority at a glance.

Block Kit JSON Example​

Paste this into the Blocks field to send a formatted alert card:

[
  {
    "type": "header",
    "text": {
      "type": "plain_text",
      "text": "🚨 New High-Priority Support Ticket"
    }
  },
  {
    "type": "section",
    "fields": [
      {
        "type": "mrkdwn",
        "text": "*Ticket ID:*\n{{ticket_id}}"
      },
      {
        "type": "mrkdwn",
        "text": "*Priority:*\n{{priority}}"
      },
      {
        "type": "mrkdwn",
        "text": "*Customer:*\n{{customer_name}}"
      },
      {
        "type": "mrkdwn",
        "text": "*Subject:*\n{{subject}}"
      }
    ]
  },
  {
    "type": "actions",
    "elements": [
      {
        "type": "button",
        "text": { "type": "plain_text", "text": "View Ticket" },
        "url": "{{ticket_url}}",
        "style": "primary"
      }
    ]
  }
]

Replace {{ticket_id}}, {{priority}}, etc. with Make.com variable mappings from your trigger module.

Use the Slack Block Kit Builder to design your layout visually, then paste the JSON into Make.

Scenario 3: Interactive Buttons That Trigger Make Workflows​

Static alerts are one thing. Interactive Slack messages let team members take action from inside Slack — approve a request, assign a task, or trigger a workflow — without switching apps.

Architecture​

Event occurs → Make builds a Slack message with action buttons
→ Team member clicks button in Slack
→ Slack sends payload to a Make.com webhook
→ Make processes the response and executes downstream actions

Building the Interactive Flow​

Part A — Send the message with a button:

  1. Create a scenario with your event trigger (e.g., new Typeform submission).
  2. Add Slack → Create a Message.
  3. In the Blocks JSON, include an actions block with a button element. Set the value to a unique identifier (e.g., the submission ID) and action_id to something descriptive like approve_request.
{
  "type": "actions",
  "elements": [
    {
      "type": "button",
      "text": { "type": "plain_text", "text": "✅ Approve" },
      "style": "primary",
      "action_id": "approve_request",
      "value": "{{submission_id}}"
    },
    {
      "type": "button",
      "text": { "type": "plain_text", "text": "❌ Reject" },
      "style": "danger",
      "action_id": "reject_request",
      "value": "{{submission_id}}"
    }
  ]
}

Part B — Receive the button click:

  1. Create a second scenario with a Webhooks → Custom Webhook trigger.
  2. Copy the webhook URL and add it to your Slack App's Interactivity & Shortcuts settings under Request URL.
  3. When a user clicks the button, Slack posts a payload JSON object to that webhook. Make receives it and parses the action_id and value.
  4. Use a Router module to branch on action_id:
    • approve_request → send confirmation DM + update database
    • reject_request → send rejection DM + log reason

Note: Slack requires the webhook endpoint to respond within 3 seconds. Make's webhook trigger handles this correctly — it acknowledges the request immediately and continues processing asynchronously.

Scenario 4: Watch a Slack Channel for Keywords​

Make.com can listen to a Slack channel and trigger workflows when specific keywords appear — useful for monitoring #support for urgent words, tracking #sales for competitor mentions, or routing requests based on content.

Setup:

  1. Add trigger: Slack → Watch Public Channel Messages (or Watch Private Channel Messages with appropriate scopes).
  2. Add a Filter (the funnel icon between modules).
  3. In the filter condition: Text → Contains → urgent (or your keyword).

Advanced pattern — route by keyword:

Add a Router module after the trigger and create a branch for each keyword category:

  • Branch 1: text contains "urgent" or "down" → post to #alerts with @oncall mention
  • Branch 2: text contains "invoice" or "billing" → forward to finance team channel
  • Branch 3: all other messages → no action (branch with no further modules)

This transforms your general channel into an intelligent triage system without requiring users to change their behavior.

Scenario 5: Daily Standup Digest Bot​

This is the pattern from Make's writing prompt: collect async standup updates throughout the day and post a single consolidated summary — not 10 individual messages clogging the channel.

Architecture​

Scheduled trigger (9am) → Slack message asking for standup updates
→ Team members reply in thread
→ Second scenario (5pm) → Make reads all thread replies → GPT summarizes → posts digest

Implementation​

Morning prompt (Scenario A):

  1. Trigger: Schedule → Every Day (set to 9:00am weekdays).
  2. Action: Slack → Create a Message in #standup: 
    🌅 *Daily Standup* — {{formatDate(now; "MMMM D, YYYY")}}
    Reply in thread with: Yesterday | Today | Blockers
  3. Use Slack → Get a Message to retrieve the ts (timestamp) of the message you just sent — you'll need this to read replies later.
  4. Store the ts in a Make Data Store keyed by today's date.

Afternoon digest (Scenario B):

  1. Trigger: Schedule → Every Day (set to 5:00pm weekdays).
  2. Action: Make Data Store → Get a Record to retrieve today's thread ts.
  3. Action: Slack → Get All Replies using the stored ts and channel ID.
  4. Action: OpenAI → Create a Completion — pass all replies as context and prompt: 
    Summarize these team standup updates into a brief digest. 
    Group by person. Keep it under 300 words.
  5. Action: Slack → Create a Message in #standup with the AI summary.

Result: One clean digest message per day instead of 10 fragmented thread replies.

Scenario 6: Aggregate Alerts to Reduce Noise​

Receiving a Slack notification for every single monitoring event is exhausting. Smart teams batch alerts: collect events over a time window and send one consolidated message instead.

The Aggregator Pattern​

Make.com's Array Aggregator and Text Aggregator modules are built for this. Combine them with a scheduled trigger and a data store:

  1. Collect events: When an alert fires (from any source), use Make Data Store → Add/Replace a Record to append it to an array stored by date.
  2. Scheduled digest: Every hour (or every morning), trigger a second scenario.
  3. Retrieve and format: Use Make Data Store → Get a Record to pull the array, then Array Aggregator to flatten it into a single message.
  4. Post once: Send the consolidated list to Slack with a count summary.
⚠️ 7 monitoring alerts in the past hour:
• [14:02] CPU spike on server-03 (92%)
• [14:15] Error rate exceeded 5% threshold
• [14:31] Disk usage warning: /var at 87%
• [14:44] Response time p99 > 2s for /api/checkout
...

Deduplication: Before appending to the data store, use a Filter to check if the same alert already exists for the current window. This prevents repeated identical alerts from flooding the digest.

Make.com Slack Scenario: Comparison of Approaches​

ApproachBest ForComplexityRequires Custom Slack App?
Basic message (Create a Message)Simple alerts, notificationsLowNo
Block Kit formattingRich cards, structured dataLowNo
Interactive buttonsApproval flows, user actionsMediumYes (for interactivity)
Channel keyword monitoringTriage, routing, monitoringMediumNo
Standup digest botAsync team updatesHighNo
Aggregated alert batchingNoise reduction, monitoringMediumNo

Make.com Slack Pricing and Operation Limits​

Make.com charges based on operations — each module execution in a scenario counts as one operation. Here's how common Slack scenarios use operations:

ScenarioOperations per Run
Send one Slack message2 (trigger + action)
Block Kit message with button2–3
Interactive button with router4–6
Standup digest (collect + summarize + post)6–10
Keyword watch + routing (per message)3–5

Make's Free plan includes 1,000 operations/month. The Core plan starts at $9/month for 10,000 operations. For active teams running multiple Slack scenarios, the Core plan is usually sufficient.

Start building for free →

Connecting Make.com + Slack + Apify for Data-Driven Notifications​

If your team monitors web data — competitor prices, job postings, social mentions — you can build a pipeline where Apify scrapes the data and Make.com formats and delivers it to Slack.

Example: Daily competitor price change alert

  1. Apify scrapes competitor product pages on a schedule.
  2. Apify webhook fires on completion → Make.com scenario triggers.
  3. Make filters results for price changes > 5%.
  4. Make sends a Slack Block Kit message to #pricing listing changed items.

This pattern is covered in detail in the Apify + Make.com Integration guide.

FAQ​

How do I send a Slack message from Make.com?​

Add a Slack → Create a Message module to any scenario in Make.com. Connect your Slack workspace via OAuth, select the target channel, and map your message content from the trigger data. No Slack app creation is required for sending messages.

Can Make.com build Slack bots?​

Yes. For simple bots (sending messages, posting updates), no Slack app is needed — Make's built-in Slack connection handles it. For interactive bots (buttons, slash commands, message menus), you need to create a Slack app, enable Interactivity, and point the Request URL at a Make.com webhook. Make handles the full bot logic in the scenario.

How do I automate Slack notifications with Make?​

Create a Make scenario with any trigger (scheduled, webhook, database change, form submission) and connect it to a Slack → Create a Message action. Use filters to control when messages fire and the Text Aggregator module to batch multiple events into a single notification.

Does Make.com support Slack slash commands?​

Not natively through the Slack module — slash commands require a custom Slack app. You configure the slash command's Request URL to point to a Make.com Custom Webhook trigger. When a user runs the slash command, Slack sends the payload to Make, which processes it and can respond via the Slack API using an HTTP module with the response_url.

Can Make.com read messages from a Slack channel?​

Yes. The Slack → Watch Public Channel Messages and Watch Private Channel Messages triggers poll for new messages at your scenario's scheduled interval. Use filters to act only on messages matching specific criteria (keywords, users, channels).

What's the difference between Make.com and Zapier for Slack automation?​

Make.com supports multi-step branching logic, aggregators, and complex routing that Zapier's linear Zap structure doesn't. For simple one-trigger-one-action Slack notifications, either tool works. For batching, deduplication, interactive workflows, or scenarios with 5+ steps, Make.com is the better choice.

Next Steps​