Real-Time Sales Alerts: Salesforce, Make.com & Slack Guide

Imagine your Sales team lands a big deal, but Marketing and Customer Success are out of the loop, scrambling to catch up. In a fast-moving SaaS company, everyone needs to know when a major deal is close to closing—so Marketing can plan campaigns, Customer Success can prepare onboarding, and Leadership can track wins. In this guide, we’ll walk you through how to build a system to share these updates instantly using Salesforce, Make.com, Slack, and Airtable.

In addition to Slack-based alerting, organizations often explore multi-channel communication strategies such as WhatsApp integration for customer and internal communication.

Why This Matters

When a deal in Salesforce hits a key stage (like “Proposal/Price Quote” or “Negotiation/Review”) or is worth over $50,000, teams need to act fast. Without automation, you’re stuck with manual emails or meetings, which are slow and error-prone. Here’s what we wanted to achieve:

Instant Alerts: Send a message to a Slack channel (e.g., #big-deals) with deal details like Account Name, Amount, and Close Date.
Track Everything: Save a record of each alert in Airtable for easy searching and reporting.
Use Salesforce: Pull data directly from Salesforce, the central hub for deal information.

What You’ll Get

Sales: Motivation from team-wide visibility.
Marketing: Time to prepare announcements.
Customer Success: Early heads-up for onboarding.
Leadership: A clear log of all major deals and notifications.

How It Works

The system connects four tools:

Salesforce: Detects when a deal meets our criteria and sends data to Make.com.
Make.com: Receives the data, posts a Slack message, and logs the event in Airtable.
Slack: Notifies teams instantly in a channel.
Airtable: Stores a record of each alert for future reference.

Let’s build it together!

Step-by-Step Setup

Step 1: Set Up Salesforce to Detect Deal Updates

Salesforce is where your deal data lives. We’ll create a small piece of code (called a trigger) to watch for updates to Opportunities (Salesforce’s term for deals) and send details to Make.com when a deal hits the right stage or amount.

Create the Salesforce Trigger

Go to Salesforce Setup:
- Log in to Salesforce and click the gear icon in the top-right corner.
- Select Setup.
Find the Developer Console:
- In Setup, search for “Developer Console” in the Quick Find box.
- Click Developer Console to open a new window.

Create a New Trigger:

In the Developer Console, click File > New > Apex Trigger.
Name it OpportunityWebhookTrigger.
Select Opportunity as the sObject.
Copy and paste this code:


                            
                                                           
    trigger OpportunityWebhookTrigger on Opportunity (after insert, after update) {
    Set opportunityIdsToProcess = new Set();

    for (Integer i = 0; i < Trigger.new.size(); i++) {
        Opportunity newOpp = Trigger.new[i];
        Opportunity oldOpp = Trigger.old != NULL ? Trigger.old[i] : NULL;

        Boolean stageChanged = newOpp.StageName != oldOpp?.StageName && 
                              (newOpp.StageName == 'Proposal/Price Quote' || newOpp.StageName == 'Negotiation/Review');
        Boolean amountCondition = newOpp.Amount != null && newOpp.Amount > 50000;

        if (stageChanged || amountCondition) {
            opportunityIdsToProcess.add(newOpp.Id);
        }
    }
    OpportunityWebhookHelper.sendWebhookCallout(new 
    List(opportunityIdsToProcess));
}

Save the Trigger:
- Click File > Save.
- Close the Developer Console.

What This Does:

The trigger watches for new or updated Opportunities.
It checks if the stage changes to “Proposal/Price Quote” or “Negotiation/Review” or if the Amount is over $50,000.
If either condition is true, it collects the Opportunity’s ID and passes it to a helper class.

helper class

Create the Helper Class

Open Developer Console Again:

Back in the Developer Console, click File > New > Apex Class.
Name it OpportunityWebhookHelper.

Copy and paste this code:


                            
                            public class OpportunityWebhookHelper {
    @future(callout=true)
    public static void sendWebhookCallout(List opportunityIds) {
        List oppList = [
          SELECT Id, Name, Amount, StageName, CloseDate,
                   AccountId, Account.Name,
                   OwnerId, Owner.Name,
                   LastModifiedDate
            FROM Opportunity
            WHERE Id IN :opportunityIds
        ];
        
        for (Opportunity opp : oppList) {
            HttpRequest req = new HttpRequest();
            req.setEndpoint('https://hook.eu2.make.com/juffga1kiej321h6komszi9yhdbycwvr');
            req.setMethod('POST');
            req.setHeader('Content-Type', 'application/json');
            
            Map payload = new Map();
            payload.put('AccountName', opp.Account != null ? opp.Account.Name : 'No Account');
            payload.put('Name', opp.Name);
            payload.put('OppotunityId', opp.Id);
            payload.put('Amount', opp.Amount != null ? opp.Amount : 0);
            payload.put('Owner', opp.Owner.Name);
            payload.put('Stage', opp.StageName);
            payload.put('CloseDate', opp.CloseDate);
            payload.put('Timestamps', opp.LastModifiedDate);
            
            String jsonBody = JSON.serialize(payload);
            req.setBody(jsonBody);
            
            try {
                Http http = new Http();
                HttpResponse res = http.send(req);
                System.debug('Webhook Sent. Status: ' + res.getStatusCode() + ', Body: ' + res.getBody());
            } catch (Exception e) {
                System.debug('Webhook Error: ' + e.getMessage() + ', Stack Trace: ' + e.getStackTraceString());
            }
        }
        System.debug('Future method completed.');
    }
}

Save the Class:
- Click File > Save.

What This Does:

The helper class takes the Opportunity IDs from the trigger.
It pulls details like Account Name, Amount, and Close Date from Salesforce.

It sends this data to Make.com in a format like:



   
                              {
  "AccountName": "Acme Corp",
  "Name": "Big Deal",
  "OppotunityId": "0065i00000AbCdE",
  "Amount": 60000,
  "Owner": "Jane Doe",
  "Stage": "Proposal/Price Quote",
  "CloseDate": "2025-06-30",
  "Timestamps": "2025-05-14T17:08:00Z"
}

pulls details

Step 2: Set Up Make.com to Connect Everything

Make.com is the glue that connects Salesforce to Slack and Airtable. It receives data from Salesforce, sends a Slack message, and logs the event in Airtable.

Create a Make.com Scenario

For organizations already using Make.com extensively, you can explore another practical implementation where Salesforce events trigger Slack notifications in an event management use case.

Log in to Make.com:
- Go to make.com and sign in.
- Click Create a new scenario.
Add a Webhook:
- Click the “+” button and search for Webhooks > Custom Webhook.
- Click Create a webhook.
- Copy the webhook URL (e.g.,
  https://hook.eu2.make.com/juffga1kiej321h6komszi9yhdbycwvr).
- Note: If you need a new URL, Make.com will generate one. Update the OpportunityWebhookHelper code with the new URL.
[Insert Screenshot Here: Show the Make.com webhook setup with the URL]
Test the Webhook:
- In Salesforce, update an Opportunity (e.g., set Stage to “Proposal/Price Quote” or Amount to $60,000).
- In Make.com, click Run once to capture the data.
- You should see the JSON payload with fields like AccountName, Name, and OppotunityId.
- If no data appears, check the Salesforce trigger (see Troubleshooting below).

Test the Webhook

Send a Slack Message

Add Slack Module:
- Click the “+” button after the webhook and select Slack > Send a Message.
Connect Slack:
- Click Add to connect your Slack account.
- Follow the prompts to authorize Make.com (you’ll need a Slack bot token with chat:write permission).
- Select the #big-deals channel (or create one in Slack).

Write the Message:



   

In the Text field, enter:
:tada: *Major Deal Alert!* :tada:
*Account*: {{1.AccountName}}
*Opportunity*: {{1.Name}}
*Amount*: ${{1.Amount}}
*Owner*: {{1.Owner}}
*Stage*: {{1.Stage}}
*Close Date*: {{1.CloseDate}}

The {{}} tags pull data from the webhook (e.g., 1.AccountName is the AccountName field).

Save and Test:
- Click OK and run the scenario.
- Check the #big-deals channel in Slack for the message.

Create a Slack Message Link

Add a Set Variable Module:
- Click the “+” button after the Slack module and select Tools > Set Variable.
- Set:
  - Variable name: slack_message_link
  - Variable value: https://slack.com/archives/{{2.channel}}/p{{replace(2.ts; "."; "")}}
- This formula uses:
  - 2.channel: The Slack channel ID (e.g., C1234567890).
  - 2.ts: The message timestamp (e.g., 1623456789.1234).
  - replace(2.ts; "."; ""): Removes the decimal point (e.g., 16234567891234).
- Example result: https://slack.com/archives/C1234567890/p16234567891234
Save:
- Click OK.

Log to Airtable

Set Up Airtable:
- In Airtable, create a new Base or use an existing one.
- Add a table named Deal Alerts with columns:
  - Opportunity ID (Text)
  - Account Name (Text)
  - Opportunity Name (Text)
  - Amount (Number)
  - Owner (Text)
  - Stage (Text)
  - Close Date (Date)
  - Timestamp (Date/Time)
  - Slack Message Link (URL)
  - Status (Single Select, with “Sent” as an option)
  - (Optional: Add columns like Deal Type or Region for future use)
Add Airtable Module:
- In Make.com, click the “+” button after the Set Variable module and select Airtable > Create a Record
- Connect your Airtable account (use an API key or OAuth from your Airtable account settings).
- Select your Base and the “Deal Alerts” table.
Map Fields:
- Map the webhook fields to Airtable columns:
  - Opportunity ID: {{1.OppotunityId}}
  - Account Name: {{1.AccountName}}
  - Opportunity Name: {{1.Name}}
  - Amount: {{1.Amount}}
  - Owner: {{1.Owner}}
  - Stage: {{1.Stage}}
  - Close Date: {{1.CloseDate}}
  - Timestamp: {{1.Timestamps}}
  - Slack Message Link: {{3.slack_message_link}}
  - Status: Type “Sent”
- If Airtable expects a specific date format, add a Tools > Format Date module before Airtable to convert CloseDate and Timestamps (e.g., to YYYY-MM-DD).
Save and Test:
- Run the scenario.
- Check Airtable to confirm a new record with all fields and a clickable Slack link.
Turn On the Scenario:
- Click the toggle at the bottom-left to set the scenario to “On”.
- Now, it will run automatically whenever Salesforce sends data.

[Insert Screenshot Here: Show the Make.com scenario overview with all modules connected]

Step 3: Test the Whole System

Update a Deal in Salesforce:
- Go to Salesforce and find an Opportunity.
- Set the Stage to “Proposal/Price Quote” or Amount to $60,000.
- Save the changes.

Check Slack:

Open the #big-deals channel in Slack.
Look for a message like:



   
 🎉 *Major Deal Alert!* 🎉

*Account*: Acme Corp
*Opportunity*: Big Deal
*Amount*: $60000
*Owner*: Jane Doe
*Stage*: Proposal/Price Quote
*Close Date*: 2025-06-30

Check Airtable:
- Open the “Deal Alerts” table in Airtable.
- Verify a new record with the Opportunity details, Slack link, and “Sent” status.
Click the Slack Link:
- In Airtable, click the Slack Message Link to ensure it opens the correct Slack message.

Check Slack

Slack Table

Step 4: Make It Live

Salesforce: The trigger is already active after saving in the Developer Console. For production, ask your Salesforce admin to move it using tools like Change Sets (search “Change Sets” in Setup).
Make.com: Keep the scenario “On” to process updates instantly.
Slack: Ensure all team members have access to the #big-deals channel.
Airtable: Share the “Deal Alerts” table with Leadership for reporting.

Tips and Tricks

Add More Fields: Want to track Deal Type or Region? Add them to the Salesforce helper class (payload.put('DealType', opp.SomeField);) and create matching Airtable columns.
Format Dates: If Airtable shows dates oddly, use Make.com’s Format Date module to adjust CloseDate or Timestamps.
Filter Alerts: In Make.com, add a filter after the webhook (e.g., only process deals where Stage is “Negotiation/Review”) to customize notifications.
Team Acces: Invite team members to the Slack channel and share the Airtable Base for collaboration.

While this solution leverages Make.com for automation, similar real-time alerting workflows can also be implemented using other low-code platforms like n8n.

This solution demonstrates how powerful real-time integrations can be when Salesforce is connected with platforms like Slack, Make.com, and Airtable. By automating deal alerts, organizations can improve collaboration, visibility, and responsiveness across teams.

To explore more Salesforce integration use cases, automation strategies, and best practices, visit our comprehensive Salesforce Integrations Expertise page.

Got questions? Feel free to drop an email to support@astreait.com

Automating Real-Time Sales Deal Alerts with Salesforce, Make.com & Slack

Why This Matters

What You’ll Get

How It Works

Step-by-Step Setup

What This Does:

What This Does:

Tips and Tricks