---
name: closed-won-to-delivery
description: Build a closed-won handover: a won deal creates delivery work with the line items attached, and work status reports back to the CRM record. Use when the user wants to automate the sales-to-delivery handover, stop somebody retyping deal terms into a project tool, or keep the CRM current after the close.
---

# Closed won to delivery

> Generated from https://www.reversecontact.com/integrations-hub/workflows/closed-won-handover
> Every tier requirement and limit below was read from the vendor's own documentation on 2026-09-18.
> Vendors change these without notice. Re-check anything load-bearing before you rely on it.

**Tools in this workflow:** HubSpot, ClickUp, Slack.
**Build effort:** Hours.

## What you are building

A deal reaches closed won. Delivery work is created with the line items, the owner and the close date attached, the team is told once, and a status change in delivery updates the deal. Nobody retypes anything.

## Ask this before writing anything

Does the handover logic depend on custom fields on either side? If it is standard objects, use the native integration in both directions and stop there. If custom fields are load-bearing, the native path thins out and Make is the usual answer. Find this out first, because discovering it halfway through means rebuilding.

## Prerequisites

| What | Where to get it | Notes |
|---|---|---|
| HubSpot Professional | An existing subscription | For the automated direction. Starter's 50 simple workflows may cover a straightforward rule |
| A ClickUp workspace | Free Forever works; automation limits vary by plan | Check the automation run limit against how many deals you close |
| A list template for delivery | Built once in ClickUp | The tasks that should exist for every new customer |

## The tools, and how to call them

### HubSpot

- **Base:** `https://api.hubapi.com`
- **Auth:** `Authorization: Bearer <private-app-token>` for a private app, or OAuth for a marketplace app. Full CRM API access is on every tier including Free.

| Call | Request | What it does |
|---|---|---|
| `PATCH /crm/v3/objects/contacts/{contactId}` | `{ "properties": { "rc_title": "VP Sales" } }` | Update a contact. Send only the properties you own. |
| `POST /crm/v3/objects/contacts/search` | `{ "filterGroups": [...], "properties": [...] }` | Find records by property. Use this to pull the slice that is missing a field. |
| `POST /crm/v3/objects/contacts/batch/update` | `{ "inputs": [ { "id": "...", "properties": {...} } ] }` | Batch of up to 100. Prefer this over per-record PATCH at volume: it is one request against the rate limit. |

**Rules that will cost you time if you skip them:**

- **Rate limits.** A private app gets 190 requests per 10 seconds on Professional and Enterprise, 100 on Free and Starter. Daily caps are 250,000 / 625,000 / 1,000,000 calls **per account, shared across every app**. A public OAuth marketplace app is capped at 110 per 10 seconds per installing account.
- **Calling an external API from a workflow needs Data Hub Professional or Enterprise.** Both the webhook action and the custom code action live in that hub, not in Sales Hub. Check this before designing an in-HubSpot build.
- **Custom code actions get 20 seconds and 128 MB.** Combined length of all workflow secrets is capped at 1,000 characters. Secrets are read with `process.env.NAME`.
- **Workflows:** up to 50 simple on Starter, up to 300 fully customisable on Professional.
- **Never write to a property a human maintains.** Use prefixed properties (`rc_*`) and promote with a separate workflow only where the human field is empty.

**HubSpot custom code action (Node 20):**

```javascript
// Input field: email   Output fields: rc_status, rc_title, rc_company, rc_headcount
// Secret: RC_API_KEY
const axios = require('axios');

exports.main = async (event, callback) => {
  const email = event.inputFields['email'];
  const res = await axios.post(
    'https://api.reversecontact.com/v2/enrich/persons',
    { email },
    { headers: { Authorization: `Bearer ${process.env.RC_API_KEY}` } }
  );

  const person = res.data?.data?.person;
  const company = res.data?.data?.company;

  // null means "not found", not "try harder". Write nothing and flag it.
  if (!person) return callback({ outputFields: { rc_status: 'no_match' } });

  callback({ outputFields: {
    rc_status:    'matched',
    rc_title:     person.currentPosition?.title || '',
    rc_company:   company?.name || '',
    rc_headcount: company?.employeeCount || 0
  }});
};
```

Docs: https://developers.hubspot.com/docs/api/overview

### ClickUp

- **Base:** `https://api.clickup.com/api/v2`
- **Auth:** `Authorization: pk_...` (personal token) or OAuth.

| Call | Request | What it does |
|---|---|---|
| `POST /list/{list_id}/task` | `{ "name": "...", "description": "...", "custom_fields": [...] }` | Create a task. Use this only if the native HubSpot action does not cover your fields. |
| `ACTION ClickUp action inside a HubSpot workflow` | - | The native path, and the one to prefer. Both vendors built into the other, so both directions are first-class. |

**Rules that will cost you time if you skip them:**

- The native integration covers common objects well and **thins out at custom fields**. Workflows that depend on custom fields usually move to Make.
- One rule per direction. HubSpot owns "a deal changed, create or update work"; ClickUp owns "work changed, update the deal". Writing to the same field from both sides is a loop.

Docs: https://developer.clickup.com/

### Slack

- **Base:** `https://slack.com/api`
- **Auth:** `Authorization: Bearer xoxb-...` (bot token). Scope `chat:write`, plus `chat:write.public` to post to a channel the bot has not joined.

| Call | Request | What it does |
|---|---|---|
| `POST /api/chat.postMessage` | `{ "channel": "C0123", "text": "...", "blocks": [...] }` | The only call most of these workflows need. Use this when you need to choose the channel at runtime. |

**Rules that will cost you time if you skip them:**

- **HubSpot's Slack workflow action cannot route to the channel associated with the record.** It sends to a channel chosen at design time. If you need per-record routing, look the association up yourself and call `chat.postMessage` directly.
- Creating a Slack channel from a HubSpot workflow requires HubSpot Professional or Enterprise.
- Route only events a named human must act on within minutes. A channel that fires forty times a day gets muted, and a muted channel is indistinguishable from a working one in the admin screen.

Docs: https://api.slack.com/methods/chat.postMessage

## Build it

### 1. Decide ownership per direction, and write it down

HubSpot owns "a deal changed, create or update work". ClickUp owns "work changed, update the deal". One rule each. The moment both sides write to the same field on the same event you have built a loop between two automation engines, and those are unpleasant to unpick.

### 2. HubSpot workflow: deal stage becomes closed won

Add the ClickUp action. Create from a template so the delivery tasks are consistent, and pass the deal context rather than summarising it.

### 3. Send the line items, not just the deal name

This is the difference between a handover and a notification. If the delivery team has to open the CRM to find out what the customer bought, the automation has not done its job.

### 4. One Slack message, to the channel that owns onboarding

Naming the account and linking both records. Not a message per task, which is how this becomes noise inside a fortnight.

### 5. Build the return direction

A ClickUp automation updating the HubSpot record when delivery status moves. Teams forget this half, and it is what stops the CRM going stale the moment the deal closes.

## Gotchas

- This workflow has no data layer in it, and that is correct. Everything it moves was entered by your own team during the deal. Not every gap in a sales stack is an enrichment problem, and adding one here would add cost without adding anything.
- Half the logic lives in HubSpot workflows and half in ClickUp automations. That is the price of both directions being native. Document which side owns which rule.
- Check ClickUp automation run limits against your deal volume before relying on this at scale.

## What breaks, from the vendors' own docs

- **Custom fields are the ceiling.** The native integration covers common objects well. Workflows that depend on custom fields are where teams move to Make, which has fuller custom-field support on the ClickUp side. Check your specific fields before you design around the native path.
- **The automated half needs Professional.** Manual linking works lower down, but "when a deal closes, do this" is a workflow, and fully customisable workflows start at HubSpot Professional. On Starter you get up to 50 simple workflows and should check yours fits inside one.
- **Two automation engines, two places to debug.** Half the logic lives in HubSpot workflows and half in ClickUp automations. That is the price of both directions being native. Write down which side owns which rule before you build the second one.
- **Writing to the same field from both sides is a loop.** One rule per direction. HubSpot owns "a deal changed, create or update work"; ClickUp owns "work changed, update the deal". The moment both write to the same field on the same event you have built a loop, and loops between two automation engines are unpleasant to unpick.

## How to verify it works

- Move a test deal to closed won and confirm the list is created with the line items present, not just the deal name.
- Change the delivery status and confirm the HubSpot record updates.
- Change something on both sides in quick succession and confirm you have not built a loop.
- Confirm exactly one Slack message fired, not one per task.

## What this costs to run

| Component | Billing | What drives it |
|---|---|---|
| HubSpot | Professional, for the automation | The trigger is a workflow. Starter's 50 simple workflows may cover it; fully customisable logic is Professional. |
| ClickUp | Per member | A Free Forever plan exists. Automations and their run limits vary by plan, so check yours against the volume of deals you close. |
| Slack | Free plan works | One channel and one message per closed deal does not need a paid workspace. |
| Middle layer | None | Both halves are native. Make only enters the picture if custom fields are load-bearing. |

This is the cheapest workflow on the site, because there is no metered line in it at all. What it costs is an afternoon of deciding which side owns which rule, which is the part that determines whether it survives.

## Sources

- HubSpot: https://developers.hubspot.com/docs/api/overview
- ClickUp: https://developer.clickup.com/
- Slack: https://api.slack.com/methods/chat.postMessage
- This workflow, with the reasoning behind each step: https://www.reversecontact.com/integrations-hub/workflows/closed-won-handover

---

*Published by Reverse Contact, which appears in this directory as a data provider.
No other vendor pays for placement. Where a vendor publishes no public figure, this file says so
rather than estimating. Reverse Contact costs are stated in credits, which it publishes; no dollar
rate per lookup appears here, because none is published and dividing a pack price is not their number.*
