How to Automatically Create ClickUp Tasks When Calendly Is Booked Using Make.com and Slack

Introduction

If you run scheduling through Calendly, you have probably felt the gap right after someone books. Your calendar is updated, but your delivery team still has to manually create a ClickUp task, then post a reminder in Slack so the right person can prepare.

That lag is the kind of admin work that breaks consistency, leads to missed prep, and turns Slack into a stream of “did you see this?” messages.

In this Cross-Platform Automation (XPA) guide, you will build a simple Make.com scenario that triggers on Calendly bookings, creates a ClickUp task, and posts a Slack notification with the key details.

What You’ll Need

• Calendly account, plus access to the event type you are automating
• ClickUp workspace permission to create tasks in the target Space, Folder, or List
• Slack permission to post into the channel you will notify
• Make.com account to build and run the scenario

Prerequisites in Make.com:

• Connected accounts for Calendly, ClickUp, and Slack
• A confirmed mapping test run so the scenario has real booking payload data to work with

No special paid features are required for a basic low-volume build, but you will need a working Make.com plan that can run scenarios reliably at your booking frequency.

How It Works (The Logic)

Here is the flow in plain English:

Calendly booking created triggers the scenario in Make.com. Make.com reads the attendee and meeting details from the booking payload, creates a ClickUp task with the right title, due date, and description, then posts a Slack message that includes the ClickUp task link.

A small dedupe guard prevents duplicate task creation if Make.com retries the trigger.

Step-by-Step Setup

1) Create a new Make.com scenario

• In Make.com, create a new scenario
• Add Calendly as the first module
• Choose the trigger that fires on new booking for the specific event type you want

Gotcha: if you have multiple Calendly event types, do not start by broadening the trigger. One event type, one workflow, predictable task content.

2) Test the Calendly trigger and inspect the payload

Run the scenario once (test mode) using a real booking.

Confirm the payload includes what you plan to map. At minimum, you want:

• Attendee name and email
• Booking start time, including timezone context
• Event type or meeting title
• Notes and any custom question answers (if you use them)

If fields are missing, fix the Calendly event configuration first, then re-test.

3) Add a filter to prevent task spam (optional but practical)

Immediately after the Calendly trigger, add a filter module.

Common rules:

• Only continue if attendee email is not empty
• Only continue if a custom question equals a target value, for example meeting purpose is Discovery

If you skip this and your Calendly event is used for different purposes, your ClickUp list turns into a dump.

4) Create the ClickUp task

Add a ClickUp module to create a task.

Configure it like this:

• Space/List: choose the exact destination where you want tasks to land
• Task name: {{Attendee Name}} - {{Event Type}}
• Due date: use the booking start time, or booking start time minus a buffer (for example 60 minutes)
• Description: include the details your team needs at a glance

Description template that works well in practice:

• Meeting: {{Event Type}}
• When: {{Booking Start}}
• Attendee: {{Attendee Name}} ({{Attendee Email}})
• Notes: {{Booking Notes}}

Gotcha: verify timezone handling. If ClickUp due dates look “off by hours,” it is almost always a timezone mapping issue between Calendly and Make.com.

5) Add a simple dedupe guard

Even with a “new booking” trigger, retries or connection interruptions can create duplicates.

Use booking identity as your dedupe key.

Implementation options:

• Preferred simple approach: store and check booking ID in a small Google Sheet (light audit log), then only create the task if that booking ID has not been logged
• Alternative simple approach: search ClickUp tasks for the booking ID before creating

If you want the simplest build that still holds up, use the booking ID + Google Sheets audit log.

6) Post the Slack notification with the ClickUp task link

Add a Slack module to post a message.

Channel: your target channel, for example #client-meetings or #sales-ops.

Message format:

• New booking created
• {{Attendee Name}} booked {{Event Type}}
• When: {{Booking Start}}
• Task: {{ClickUp Task URL}}

The key detail is the ClickUp task URL. Without it, Slack becomes a ping, not a handoff.

7) Test end-to-end

Do a full test booking in Calendly and run the scenario.

Check:

• Exactly one ClickUp task is created
• Due date matches the meeting start time you expect
• Description contains attendee email and notes (if collected)
• Slack message includes a working ClickUp task link

8) Turn it on and monitor the first few runs

For the first day or two, check Make.com execution logs for:

• Missing fields (blank timezone, blank email)
• Filter mismatches (everything stops passing through)
• Duplicate task creation (tighten dedupe if needed)

Real-World Business Scenario

A consultancy team uses Calendly for discovery calls. With this setup, each booking creates a task in ClickUp under their “Client Prep” list, due at the meeting start time. Slack gets one clean notification per booking with the task link and attendee details.

The win is practical: no one waits for manual task creation, prep happens on time, and Slack stays useful because it always points to the authoritative ClickUp task.

Common Variations

1) Route different ClickUp Lists by Calendly event type

If you have multiple event types, add a router step in Make.com:

• Discovery event type creates tasks in List A
• Implementation event type creates tasks in List B

2) Add meeting-prep subtasks automatically

After the main task is created, add additional ClickUp actions to create subtasks like:

• Review attendee context
• Confirm agenda
• Draft next-step email

3) Notify only for qualified bookings

Use filters based on Calendly custom questions:

• Only notify Slack if a specific requirement is answered
• Only create tasks if a lead is in the right region or budget band

Keeping scheduling and delivery in sync

You now have a working Calendly to ClickUp and Slack handoff built in Make.com, where each booking produces the task your team needs and a Slack message that actually points to next actions.

Olmec Dynamics builds these Cross-Platform Automation (XPA) workflows for real teams that want fewer admin gaps between scheduling, delivery, and follow-up. If you want help building or hardening this kind of integration, see what we do here.