How to Automatically Create ClickUp Tasks from Outlook Calendar Events and Post to Microsoft Teams Using Make.com

Introduction

If your team still copies meeting details from Outlook into ClickUp and then posts a Teams note, you know how handoffs break: missing attendee emails, wrong dates because of timezones, or duplicate tasks when someone edits the event. That adds small delays that compound across the week.

This guide shows a compact Make.com scenario you can build in under 20 minutes that watches an Outlook Calendar, creates or updates a ClickUp task for each event, and posts a short Teams message with the task link. What you will know by the end: the exact trigger to use, how to map key fields, and the minimal dedupe step so you do not create duplicates.

What You'll Need

• An Outlook Calendar you can watch (Microsoft 365 account)
• ClickUp workspace with permission to create tasks in the target List
• Microsoft Teams channel with an Incoming Webhook or a bot able to post messages
• A Make.com account with Outlook, ClickUp, and HTTP/Teams connections configured
• (Optional) A small Google Sheet or Make.com Data Store for a simple idempotency ledger

Notes: If you want near-instant triggers use the Outlook "Watch events" connector in Make.com. For low volume or testing you can poll, but webhooks/push are preferable. ClickUp custom fields may require numeric IDs; keep a mapping handy.

How It Works (The Logic)

Trigger (Outlook event created or updated) → Normalize the event (title, start time, attendees, location) → Simple dedupe: check if the Outlook event id is already linked to a ClickUp task → If not found create a task in ClickUp with the event details and save the task id back to your ledger → Post a concise Teams message with the ClickUp task link.

This keeps the handoff reliable and the Teams channel scannable.

Step-by-Step Setup

1. Decide which calendar events should create tasks

Before you build, define scope. Typical options:

• All events in a dedicated calendar (recommended for a single-team flow)
• Events containing a keyword in the title, such as "Project:" or "Client:"
• Events created by specific users

Keep it narrow at first to avoid noise.

2. Create a new Scenario in Make.com and add the Outlook trigger

• Module: Outlook 365, use "Watch events" and point it at the calendar you will monitor.
• Set it to trigger on event created and event updated if you want edits to update tasks.
• Run a test by creating a sample event so Make.com pulls a real payload to work with.

3. Extract and normalise the event fields

Map these fields into variables you will use later:

• event_id (Outlook event id)
• subject (event title)
• start_time (ISO string) and convert to your workspace timezone if needed
• end_time (ISO string)
• attendees list (name + email, if present)
• location or online meeting link
• body/notes (first 800 chars) for the task description

Timezone tip: Outlook timestamps include timezone metadata. Use Make.com date functions to convert to epoch milliseconds if ClickUp needs that format.

4. Implement a simple idempotency check

To prevent duplicate tasks when the same event triggers multiple times, store a mapping of Outlook event_id → ClickUp task_id. Use either:

• A small Google Sheet with columns: outlook_event_id, clickup_task_id, created_at
• Or Make.com Data Store keyed by outlook_event_id

Add a lookup step: if an entry exists for this event_id, skip task creation and optionally update the existing ClickUp task instead. If no entry exists, continue to create a task and write the new mapping after success.

This is the most important reliability step.

5. Create or update the ClickUp task

• Module: ClickUp, "Create a Task" for new events, or "Update a Task" if you found an existing mapping.
• Field mappings for Create:
  • Task name: "Meeting: {{subject}} — {{start_time_local}}"
  • Description: include a short block with event summary, attendees, and the event link. Example:

Event: {{subject}}
When: {{start_time_local}} to {{end_time_local}}
Attendees: {{attendee_emails}}
Location: {{location_or_link}}
Notes: {{body_snippet}}
Outlook event: {{outlook_event_link}}

• Due date or start date: map from start_time. If ClickUp expects epoch ms, convert it inside Make.com.
• Assignees: optional default or map using a small lookup from event owner email to ClickUp user ID
• Custom fields: map only if you have specific fields to populate (use exact custom field IDs)

Common gotcha: ClickUp connectors sometimes require numeric timestamps. Test one create step manually to confirm the date format.

6. Write the mapping back to your ledger

After a successful ClickUp create, add a row to your ledger storing outlook_event_id and the returned clickup_task_id and timestamp. If you used Data Store, write the key-value pair.

This write-back is essential so subsequent event updates map to the existing task instead of creating duplicates.

7. Post a short Microsoft Teams message with the task link

• Module: HTTP (POST) to your Teams Incoming Webhook URL or use a Teams connector if available.
• Keep the message tight. Example JSON body for a basic message:

{ "text": "New ClickUp task created from calendar event: Meeting: {{subject}}\nWhen: {{start_time_local}}\n<{{clickup_task_url}}|Open task>" }

If you use Adaptive Cards, include the task link and one-line summary. Post into the right channel and optionally thread the message if you want replies attached.

8. Test update and cancellation handling

• Create an event, confirm a ClickUp task is created and Teams message posted.
• Update the event time or title, confirm the scenario looks up the mapping and updates the ClickUp task instead of creating a new one.
• For cancellations, add a filter branch: when the Outlook event shows isCancelled true, update ClickUp task status to Cancelled or add a task comment and post a Teams note.

9. Turn on and monitor initial runs

Activate the scenario and monitor the first few dozen events. Check for:

• Missing attendee emails (optional fallback: put attendee names in the description)
• Wrong timezones (adjust conversion)
• Duplicates (tighten your ledger lookup and ensure you write mapping only after ClickUp returns success)

Real-World Business Scenario

A consultancy used this flow to ensure every client call generated prep work for the delivery lead. Every booking on the shared client calendar created a ClickUp task assigned to the delivery lead with the meeting link, attendee emails, and a short brief. The Teams alert gave the lead a heads-up with the task link. That removed the recurring manual step and reduced missed pre-call preparation.

For a similar pattern that sends ClickUp status changes into Slack, see our guide How to Automatically Notify Slack When a ClickUp Task Changes Status Using Make.com. If your team uses Google Calendar instead of Outlook, you can adapt the same mapping ideas from our Google Calendar to ClickUp guide: How to Automatically Create ClickUp Tasks From Google Calendar Events Using Make.com.

Common Variations

• Route by event keyword: only create tasks for events that include a project prefix such as "Project: X" in the subject
• Create a checklist template in ClickUp after creating the task, so every meeting has the same preparation steps
• Post a Teams adaptive card with action buttons (for example "Mark task high priority")

A final note on reliability

Keep the mapping between Outlook event id and ClickUp task id as the single source of truth for idempotency. If you implement that ledger and write it only after a successful task creation, the scenario becomes resilient to retries and edits.

If you want help implementing this across multiple calendars, or adding dynamic assignee routing and checklist templates, Olmec Dynamics builds and maintains these kinds of automations for real teams. See what we do at https://olmecdynamics.com