Olmec Dynamics
A
·6 min read

Automate Calendly to Google Sheets and Slack Using Make.com

Automate Calendly bookings to Google Sheets and send Slack alerts in Make.com, with scheduled, canceled, and rescheduled upsert handling.

Introduction

You probably already have the same workflow pain we see in real teams: a new Calendly booking happens, someone copies the invitee name, email, and time into Google Sheets, then someone posts a Slack message so the team knows what is booked. When the meeting is canceled or rescheduled, that manual process repeats and you end up with duplicates or half-updated rows.

This post shows how to build a practical Cross-Platform Automation (XPA) that connects Calendly to Google Sheets and Slack using Make.com. By the end, you will have a scenario that automatically upserts the booking into your sheet and posts a clear Slack alert for each lifecycle event.

What You'll Need

  • Make.com account. A paid plan is often needed for higher volume and stronger run logging.
  • Calendly account with the ability to receive event triggers (built-in automations or webhooks depending on your setup).
  • Google Sheets access to edit a spreadsheet and worksheet.
  • Slack access to post to the channel you choose.
  • A Google Sheet with columns like:
    • event_id (unique key)
    • event_type (scheduled, canceled, rescheduled)
    • invitee_name
    • invitee_email (optional for Slack)
    • start_time
    • end_time
    • meeting_link
    • invitee_timezone

How It Works (The Logic)

Here is the logic in plain English.

  • Trigger: A Calendly booking event fires for a lifecycle change (scheduled, canceled, rescheduled).
  • Action 1: Make.com reads the payload and performs an upsert into Google Sheets using event_id as the match column.
  • Action 2: Make.com posts a formatted Slack message (channel alert) using the same mapped fields.

The upsert key is the whole point. Without a stable match value in Sheets, reschedules and cancellations turn into duplicate rows.

Step-by-Step Setup

1) Pick the upsert key, then add it to your sheet

  1. Ensure your Google Sheet has a column named event_id.
  2. In your Calendly trigger payload test, locate the unique identifier field you will map into event_id.

Gotcha: use the identifier that stays consistent for the lifecycle updates you care about. Many teams assume the “event” ID matches across all updates, but some implementations generate different IDs per lifecycle action. If that happens, you must pick a different match field (for example, a recurring event resource identifier). The upsert concept stays the same.

2) Create the Make.com scenario

  1. In Make.com, go to Scenarios and create a new scenario.
  2. Add a Calendly module as the Trigger.
  3. Select the trigger option that covers the lifecycle events you want. If your trigger option covers only scheduled events, either:
    • build separate scenarios for canceled and rescheduled, or
    • use a webhook-based approach so all lifecycle events come through to the same scenario.

3) Add the Google Sheets upsert step

  1. Add a Google Sheets module after the trigger.

  2. Choose the action that updates a row or inserts if it is missing (upsert behavior).

  3. Configure:

    • Spreadsheet: your target file
    • Worksheet: the tab
    • Match column: event_id

  4. Map fields from Calendly into your columns:

    • event_id → event_id
    • lifecycle type → event_type
    • invitee name → invitee_name
    • invitee email → invitee_email
    • meeting start → start_time
    • meeting end → end_time
    • meeting URL or location → meeting_link
    • timezone → invitee_timezone

4) Add the Slack notification

  1. Add a Slack module after the Google Sheets step.
  2. Choose an action to send a channel message.
  3. Select your channel, for example #bookings.
  4. Build a short message string like:
    • Event: {event_type}
    • When: {start_time} ({invitee_timezone})
    • Who: {invitee_name}
    • Link: {meeting_link}

Gotcha: if invitee email is sensitive, omit {invitee_email} from the Slack string. Keep it in Sheets for reporting.

5) (Optional) Filter Slack notifications by event type

If you want Slack alerts only for scheduled and rescheduled:

  • Add a filter right after the Calendly trigger.
  • Allow when event_type equals scheduled OR equals rescheduled.

Keep the upsert step running for all lifecycle changes if you want a complete audit trail.

6) Test each lifecycle path

Run test events and verify behavior:

  1. Create a booking, confirm:
    • a row is inserted into Google Sheets
    • Slack posts once
  2. Reschedule the same booking, confirm:
    • the same row updates (same event_id match)
    • Slack posts the rescheduled message
  3. Cancel the booking, confirm:
    • the sheet updates correctly
    • Slack posts the canceled message

7) Check for duplicates and missing fields

After a few tests, scan your sheet:

  • Do you have multiple rows with the same event_id?
  • Is meeting_link empty when you expect it populated?

If duplicates appear, adjust the upsert match column strategy.

Real-World Business Scenario

A coaching business uses Calendly for discovery calls. Their admin team had two tasks: update a Google Sheet for reporting, and notify the team in Slack when a call is scheduled. Cancellations and time changes caused messy overwrites and weekend cleanup.

With this Make.com XPA:

  • scheduled, canceled, and rescheduled events update the correct Google Sheet row via event_id
  • Slack receives a consistent alert message for each lifecycle change
  • reporting stays accurate without manual edits

Common Variations

  1. Slack channels per event type

    • scheduled to #bookings
    • canceled to #bookings-canceled
    • rescheduled to #bookings-updates

  2. Assign internal owner based on Calendly event type

    • add an owner field in Sheets
    • post in the channel tied to that owner

  3. Daily Slack digest from Google Sheets

    • a second Make scenario reads rows from the sheet grouped by day
    • posts a single digest instead of real-time pings

Fit with Cross-Platform Automation (XPA)

What you built here is a clean XPA pattern: Calendly lifecycle trigger, Google Sheets system-of-record upsert, and Slack notification. If you want the practical design rules behind building XPAs that stay maintainable, you can review the Cross-Platform Automation (XPA) overview.

Olmec Dynamics builds and maintains automations like this for teams that care about data correctness and operational sanity. If you want this wired exactly to your Calendly fields, sheet columns, and Slack formatting, you can see more of our work at Olmec Dynamics.