Module 6: CRM with HubSpot

Deals and Pipelines

Capsule description

A contact is a person. But the CRM doesn't exist to store people — it exists to close sales. And an in-progress sale, in HubSpot, is called a deal.

This capsule introduces the two concepts that turn the CRM from a directory into a sales machine: the deal (the sales opportunity — who, how much, in what state) and the pipeline (the "funnel" — the sequence of stages a deal advances through until it closes). If contacts were "the who", deals are "the what" and pipelines are "where it's going".

There's a key concept worth anticipating: a deal lives in a stage of a pipeline, and "advancing a sale" in HubSpot literally means moving the deal from one stage to the next. Automating sales is, to a large extent, automating that movement — creating the deal in the first stage when an opportunity arrives, and moving it as it advances.

What you'll learn

By the end of this capsule you'll be able to:

✅ Understand what a deal is and what makes it up
✅ Understand pipelines and stages (deal stages)
✅ Create deals from a workflow, in the right stage
✅ Move a deal from one stage to another (advance the sale)
✅ Search and update existing deals
✅ Work with the IDs of pipeline and stage

What a deal is

A deal represents a concrete sales opportunity. It's not the person, it's not the company — it's the sale itself. Its typical properties:

Property	What it is
`dealname`	The deal's name — e.g. "License sale - Acme"
`amount`	The amount / value of the sale
`dealstage`	The stage it's in (key — see below)
`pipeline`	Which pipeline it belongs to
`closedate`	The estimated (or actual) close date

A deal on its own is incomplete: a sale has a buyer (contact) and, often, a company. Connecting the deal with those other objects is the topic of capsule 05 (associations). For now, focus on the deal as an entity.

Pipelines and stages: the sales funnel

What a pipeline is

A pipeline is the sequence of stages a sale passes through, from when it appears until it closes. HubSpot brings a default pipeline, and more can be created (a business might have a pipeline for "new sales" and another for "renewals", for example).

What stages (deal stages) are

Stages are the steps inside the pipeline. A typical sales pipeline might have:

Appointment scheduled → Meeting held → Proposal sent → Negotiation → Closed won / Closed lost

Each deal is, at all times, in a stage. "Advancing the sale" = moving the deal to the next stage.

The mental model: a pipeline is like a sales kanban board. Each deal is a card. The columns are the stages. Selling is moving cards from left to right until "Closed won". Automating sales with n8n is moving those cards with a workflow instead of by hand.

The technical detail: pipelines and stages have IDs

Like everything in these systems (Module 5, Module 6), pipelines and stages are identified with internal IDs, not with their visible names. The stage you see as "Proposal sent" HubSpot handles with an ID.

This is what confuses most when automating deals: to create a deal "in the Proposal sent stage", you need that stage's ID, not the text "Proposal sent". The n8n node often helps you with selectors that show the names and resolve the IDs behind the scenes — but when something doesn't add up, it's almost always because a name and an ID don't match. Capsule 07 (troubleshooting) returns to this.

Create a deal

Resource: Deal
Operation: Create
Key properties:
- dealname → a descriptive name
- amount → the amount
- pipeline → the pipeline (by its ID, or via the node's selector)
- dealstage → the initial stage (by its ID, or via selector)

Rule: a new deal is almost always created in the first stage of the pipeline. A just-appeared opportunity isn't "in negotiation" — it's in "appointment scheduled" or your pipeline's initial equivalent. Creating the deal directly in an advanced stage is skipping the process.

Just like with contacts, the created deal returns a Deal ID — store it if you're going to move or update it later.

Move a deal: advance the sale

This is the operation that automates sales. Moving a deal's stage is an Update that changes the dealstage property:

Operation: Update
Deal ID: {{ $json.id }} — the deal to move
dealstage: the ID of the new stage

Examples of real automation:

A proposal is signed (a webhook arrives) → move the deal to "Negotiation"
Payment is received (an event from a payment system) → move the deal to "Closed won"
30 days pass with no response → move the deal to "Closed lost"

Update is surgical (you know this from Sheets): moving the deal's stage changes dealstage and nothing else. The amount, the name, the associations — everything else stays. You only change where the card is on the board.

Search and update deals

Search: searches deals by properties (by stage, by amount, by close date...). Useful for "give me all the deals in negotiation", "the ones closing this month".
Get: fetches a deal by its ID.
Update: modifies any property — the amount changed, the close date moved, or (most common) advance the stage.

The "look up before acting" pattern applies: if your workflow receives "the customer Acme signed" but doesn't have the Deal ID at hand, first search the deal (by name, or better, by its association with the contact/company — capsule 05), get its ID, and then move it.

Common traps

Trap 1: Using the stage's name instead of its ID

What happens: You set dealstage = "Proposal sent" and HubSpot doesn't recognize it — it expects that stage's internal ID.

How to avoid it: Use the node's selector (which resolves the ID for you) or get the stage's ID. Name ≠ ID — the #1 error with deals.

Trap 2: Creating deals in an advanced stage

What happens: Your workflow creates every deal directly in "Negotiation" because "it's faster that way". You skip the process, and the funnel reports lie.

How to avoid it: A new deal is created in the first stage. Advancing it is a separate step, when something justifies it.

Trap 3: Confusing pipeline with stage

What happens: You mix up the pipeline's ID with a stage's, or assume a stage of one pipeline exists in another.

How to avoid it: The pipeline is the whole funnel; the stage is a step within. Stages belong to a specific pipeline — the "Negotiation" stage of pipeline A is not the same as pipeline B's.

Trap 4: Moving a deal without knowing what stage it's in

What happens: Your workflow "advances" a deal to "Negotiation" but the deal was already in "Closed won" — you moved it backward.

How to avoid it: If the logic matters, read the deal's current stage before moving it, and decide with an IF. Don't move blindly.

Trap 5: Creating a deal with no buyer

What happens: You create "loose" deals, without associating them to any contact or company. You have sales without knowing whose they are.

How to avoid it: A deal should almost always be associated to a contact (and often a company). That's capsule 05 — but keep it in mind from now: a deal with no buyer is an incomplete deal.

Exercise: create and move a deal

Goal: practice a deal's life cycle through the pipeline.

Setup

In HubSpot, look at your default pipeline and its stages. Note down the stage names (the n8n node will help you with the IDs).

Your task

Create a deal: Manual Trigger → Set (dealname, amount) → HubSpot (Deal, Create) in the first stage of the pipeline. Look at the output and locate the Deal ID.
Verify in HubSpot that the deal shows up in the first stage of the board.
Move the deal: chain a HubSpot (Deal, Update) that uses the Deal ID to change dealstage to the second stage.
Verify that the deal moved on the board — the "card" advanced a column.
Search deals: separate workflow — HubSpot (Deal, Search) that brings the deals of a certain stage.

See hints

In #1 and #3, use the node's stage selector if available — it resolves the ID for you. If not, you need the stage's ID.
In #3, the Deal ID comes from the Create: {{ $json.id }}
The lesson: create = first stage; move = Update of dealstage. That's "automating sales" in its most basic form.

Summary and next step

A deal is the concrete sales opportunity — neither the person nor the company, the sale itself
A pipeline is the sequence of stages a sale advances through; each deal lives in a stage
Mental model: the pipeline is a sales kanban board — automating sales is moving cards with a workflow
Pipelines and stages are identified with internal IDs, not with their visible names — the #1 error with deals
A new deal is created in the first stage; "advancing the sale" = an Update of dealstage
"Look up before acting" applies: if you don't have the Deal ID, search for it before moving
5 traps: stage name instead of ID, creating in an advanced stage, confusing pipeline with stage, moving blindly, deal with no buyer

Before moving on you should be able to:

Create a deal in the first stage of a pipeline
Move a deal to another stage with an Update
Explain the difference between pipeline and stage

What comes next (capsule 05):

You have contacts (capsule 03) and deals (capsule 04) — but for now they live loose. Capsule 05 connects them: HubSpot's associations — how a deal links to its contact and its company. It's the piece that makes the CRM a truly relational system.

Additional resources

n8n HubSpot node Docs - Deal operations.
HubSpot: deal pipelines and stages - How pipelines are configured.
HubSpot: deal properties - A deal's predefined properties.

Created: May 14, 2026 Version: 1.0

← PreviousContacts Next →Companies and Associations