Your HubSpot Shows Closed Deals. Your Operations Team Still Doesn't Know What Was Sold.

The deal closes on Friday. By Tuesday, operations is asking the salesperson what was sold.

The salesperson is in another meeting. Operations sends a Slack message. No answer. They open the HubSpot record — it shows the deal as Closed Won, the amount, the close date, and a PDF of the signed proposal attached as a note.

That's it. That's the entire handoff.

So operations does what they always do: they schedule a kickoff call with the salesperson to walk through what was actually promised, what the client expects, who the contacts are, and what the timeline looks like. The call gets scheduled for the following Monday because the salesperson is traveling. The project loses a week before it starts.

This is not a HubSpot problem. HubSpot is doing exactly what it was configured to do. The problem is that whoever set it up treated your business like it sells products, when you actually sell projects.

Generic HubSpot setups assume the deal ends when it closes. Yours doesn't.

If you sell SaaS subscriptions, t-shirts, or any product where the thing you sell already exists, the standard HubSpot model works fine. A deal moves through a pipeline, closes, and the customer record holds whatever happens next — renewals, support tickets, upsells.

But you don't sell something that already exists. You sell a promise that has to be built after the contract is signed. The work of delivering what you sold is bigger, longer, and more expensive than the work of selling it. And the standard HubSpot model has almost no language for that second half.

So your implementer did what implementers do. They set up Contacts, Companies, and Deals. They built a sales pipeline with stages ending in Closed Won. They maybe added a few custom properties. They connected your email. They turned it on. And technically, it works — sales has a CRM, the dashboard shows pipeline value, reports get exported.

What doesn't work is everything that happens after the deal closes. Because in the generic setup, nothing happens after the deal closes. The deal just sits there.

The fragmentation you feel every day is the result of a missing model — not missing tools.

You already have tools. You have HubSpot for sales. You have Asana or Monday or ClickUp for project management. You have QuickBooks or NetSuite for finance. You have Slack for communication. Each one works. The problem is that nothing connects them in a way that reflects how your business actually operates.

Here's what that looks like in practice:

A salesperson closes a $180K engagement. The deal record in HubSpot shows the amount and the company. To start the project, operations creates a new project in Asana — with a different name, different fields, and no link back to the original deal. Finance creates an invoice in QuickBooks with yet another reference number. The client communication moves to a shared Slack channel that no one outside the project team can see.

Three weeks later, the salesperson wants to know how the project is going before a check-in call with the client. There's no answer in HubSpot. The deal still says Closed Won — it has nothing to do with what's happening in delivery. So the salesperson messages the project manager on Slack. The project manager is heads-down on something else and replies four hours later. The check-in call already happened.

This isn't a tooling problem. It's a model problem. None of your systems were ever told that a closed deal is the beginning of the project, not the end of the relationship.

The same generic setup also hides what each project actually costs you.

Here's the test: open any deal that closed last quarter. Can you see, without leaving HubSpot, what that project actually cost to deliver? The contractor invoices, the software licenses bought for it, the hours logged, the unbilled expenses?

If your answer is "I'd have to ask finance" or "that lives in QuickBooks" — you don't have margin visibility. You have revenue visibility and you have cost data in a separate system, and once a quarter someone exports both into a spreadsheet and tries to reconcile them.

By the time you know which projects made money and which ones bled, you've already sold three more like the ones that bled. Because nothing in your sales process is connected to the cost reality of delivery. The salesperson sees the revenue. They don't see what it cost to produce that revenue. So they keep selling the same shape of work.

This is a structural blind spot. Not a discipline problem.

What it looks like when the model is built right.

In a setup designed for professional services, the deal doesn't end at Closed Won. The pipeline keeps going — into stages like In Progress, At Risk, In Maintenance, Completed. The deal record stays alive because the relationship stays alive.

The project itself becomes its own object in HubSpot — not a note, not a tag, not a link to Asana. A first-class object with its own properties: status, health, dates, deliverables, assigned team, milestones. One company can have three deals, and each deal can produce its own project. They don't collapse into one mess.

The internal work each team does is tracked as tickets. Pre-sales has tickets: information gathering, blueprint design, proposal creation. Delivery has tickets: kickoff, weekly checkpoints, QA, handoff. Each team has its own pipeline with its own velocity. You can finally see, in numbers, how much work a deal actually required to close and to deliver.

Costs become an object too — invoices, contractor payments, software charges — associated to the project. A rollup property on the deal sums them automatically. The margin on every project is visible in real time, inside HubSpot, without anyone touching a spreadsheet.

And the salesperson, before that client check-in, opens the deal and sees: project status green, two open issues, 60% of fees collected, next milestone Thursday. In ten seconds. Without messaging anyone.

What changes when you stop and what to do about it.

The change isn't buying new software. You already have HubSpot. The change is rebuilding the architecture inside it so it reflects how a professional services business actually runs — deals that don't die at close, projects as objects with their own lifecycle, tickets as the unit of internal work, costs visible against revenue at the deal level, and the existing tools you have (your PM tool, your accounting system) integrated by ID so the data stays in sync without anyone copying it.

The order matters. You map first — what the model should look like for your specific business, given how you sell and how you deliver. Then you audit against your current operation to make sure it's compatible. Then you implement. When the implementation starts, nothing is improvised. You already know what you're getting because you already approved the blueprint.

This is the model behind SAP ASAP's implementation for companies that sell projects. The page shows the full architecture — the objects, the pipelines, the integrations, the post-sale flow — before you ever talk to anyone. If it matches how your business should operate, you'll see it immediately. If it doesn't, you'll know that too, and you'll save the call.