Automate HubSpot deal.updated to Google Sheets and Slack Using Make.com

Automate HubSpot deal.updated to Google Sheets and Slack Using Make.com

If you track deal changes manually, you already know the pain. Someone updates a deal in HubSpot, and hours later you realize the pipeline stage, amount, or owner changed, but your Google Sheet and Slack channel never did.

With Cross-Platform Automation (XPA), you can wire HubSpot deal.updated events into Google Sheets for an audit trail, then send a Slack alert only for meaningful changes. By the end, you will know how to build a Make.com scenario that stays reliable as volume grows.

What You'll Need

• HubSpot: access to configure webhook subscriptions for deal events (deal.updated).
• Make.com: a plan that supports the modules used below, including an HTTP-style webhook receiver (custom webhook trigger).
• Google Sheets: a spreadsheet tab where you will write your log rows.
• Slack: permission to post messages to the channel you will alert.

Prerequisites you should plan for:

• You will use webhooks as the trigger path (not polling the HubSpot API).
• You will implement idempotency so retries do not create duplicate rows.

If you want the broader XPA wiring principles behind this pattern, see Cross-Platform Automation (XPA).

How It Works (The Logic)

When HubSpot fires a deal.updated webhook, Make receives the payload. Make then:

1. Extracts deal identifiers and the fields you care about.
2. Creates an idempotency key so the same update cannot write duplicates.
3. Writes to Google Sheets using a search-and-upsert flow.
4. Posts to Slack only if the change matches your alert rules.

Step-by-Step Setup

1) Design your Google Sheets schema for upserts

Create (or update) a tab with columns like:

• idempotency_key (text)
• event_time (date-time)
• deal_id (number)
• deal_name (text)
• deal_stage (text)
• deal_amount (number)
• deal_owner (text)
• changed_fields (text)
• slack_message (text, optional)

Important detail: Google Sheets does not enforce a unique constraint, so your automation must emulate uniqueness by searching the idempotency_key before writing.

2) Create a Make.com scenario with a webhook trigger

In Make.com:

1. Create a new scenario.
2. Add a Webhooks module as the trigger.
3. Choose the option that gives you a webhook URL to receive incoming POST requests.
4. Save and copy the webhook URL.

Gotcha: activate the scenario, then test from HubSpot. If you test while the scenario is off, Make will not receive the webhook.

3) Subscribe HubSpot to deal.updated events

In HubSpot:

1. Configure a webhook subscription for deal events.
2. Select the event type deal.updated.
3. Set the target URL to your Make.com webhook URL.
4. Ensure the payload contains the deal properties you need (or be ready to fetch them in a later Make step).

If your webhook payload is missing fields, plan an extra Make step to fetch deal properties from HubSpot before writing to Sheets.

4) Normalize the webhook payload in Make

Back in Make.com:

1. Add a module to parse the JSON body.
2. Map out at least:
   • deal_id
   • event_time (or an equivalent timestamp from the payload)
   • deal_stage
   • deal_amount
   • deal_owner

Where possible, also map any payload fields that describe what changed.

5) Generate an idempotency key

Create a single string that uniquely represents the update you want to log. Common patterns:

• If the payload provides a unique webhook event ID, use event_id directly.
• Otherwise build it from stable ingredients, for example:
  • deal_id + event_time + deal_stage + deal_amount

In Make, build the string with a formatter module (or Set variables) so it is consistent every time.

This is what keeps retries safe.

6) Upsert into Google Sheets (search, then update or add)

Add a Google Sheets section that does:

1. Search for a row where idempotency_key equals the key you computed.
2. Route by result:
   • If a match exists, update that row.
   • If no match exists, add a new row.

Field mapping tips:

• Always write idempotency_key, event_time, and deal_id.
• Overwrite “current value” columns like deal_stage, deal_amount, deal_owner.
• Write changed_fields so you have an audit reason, not just the final state.

Gotcha: on very large sheets, search can slow down. If you anticipate high volume, keep a dedicated “deal_change_log” tab, and consider splitting logs by month.

7) Add Slack alerts, but only for meaningful changes

Add a Slack module after the Sheets step, but wrap it in an if condition.

Example alert rules:

• Alert when deal_stage changed.
• Alert when deal_owner changed.
• Alert when deal_amount changed.

Message contents you should include:

• Deal name
• New stage and amount
• Owner
• A link back to the deal in HubSpot (optional but useful)

If you cannot reliably detect “old vs new” from the webhook payload, use changed_fields from the payload or track the last known values in Sheets and compare before posting.

8) Test end-to-end and validate deduping

1. In HubSpot, edit a deal in a way that triggers deal.updated.
2. In Make, run a test and confirm:
   • Exactly one row is created for the unique key.
   • If you re-run the scenario test, it updates the existing row instead of adding duplicates.
   • Slack posts only when the change matches your rules.

Real-World Business Scenario

A mid-market B2B services team used HubSpot for their sales pipeline, but their operations reporting lived in Google Sheets. Every stage change created a manual chore, someone updated the sheet, and someone posted in Slack so stakeholders knew something moved.

After implementing this Make.com XPA, every deal.updated event landed in the Google Sheets log with an audit timestamp. Slack alerts triggered only when stage or owner changed, so the channel stayed readable during active weeks. The result was fewer reconciliation questions and faster, more defensible weekly reporting.

Common Variations

1. Route Slack by pipeline or amount

   • Only alert for specific pipelines (for example, “Enterprise”) or only when deal_amount exceeds a threshold.

2. Write a daily summary row per deal instead of per update

   • Bucket changes by date, upsert once per deal per day.

3. Create tasks in ClickUp or Monday.com on specific transitions

   • For example, when a deal moves to “Proposal Sent,” create an internal follow-up task.

How this fits your XPA stack

You built an XPA that turns HubSpot deal.updated webhooks into a deduplicated Google Sheets change log and targeted Slack alerts. This kind of event-driven plumbing is the foundation for forecasting dashboards, internal audit trails, and downstream task automation.

If you want help mapping your exact HubSpot properties to a clean Sheets schema, we build these Cross-Platform Automation (XPA) workflows for teams, and you can see what we do here for examples and approaches.