You closed a deal three weeks ago. Today the client emails the salesperson asking why the scope feels different from the proposal. The salesperson opens HubSpot, sees "Closed Won," and has no idea what's happened since. They Slack the PM. The PM is in a meeting. By the time the answer arrives, the client has escalated.
This is what happens when you implement HubSpot for companies that sell projects the same way you'd implement it for a SaaS company. The CRM ends as a deal graveyard. Everything that matters — execution, margin, incidents, fees outstanding — lives somewhere else.
This article is the complete model. Not a list of tips. The actual object architecture, pipeline design, handover mechanism, and financial layer we use when we implement HubSpot for companies that sell projects — consultancies, agencies, ERP shops, architecture firms, recruiting firms, any business where the deliverable doesn't exist until someone builds it.
Most HubSpot implementations assume a linear funnel: lead becomes contact, contact becomes deal, deal closes, customer renews. That model works for product companies where the thing being sold already exists and the post-sale motion is mostly retention.
Project-based companies don't work that way. The product is invented during the sales cycle. presale — scoping, designing, building the proposal — is real work that requires the delivery team's input. After close, the deal is just beginning. Execution can take six months. Margin depends on how the project runs, not on what was sold.
A standard implementation collapses all of that into a single deal record with a single owner. The deal closes, the pipeline ends, and the CRM goes blind exactly when the most expensive part of the business begins.
The usual response is to bolt on project management software — Asana, Monday, ClickUp, Jira — and call it integration. Sales lives in HubSpot. Delivery lives somewhere else. A Zap or a native sync pushes deal data across when something closes.
This fails in three predictable ways. First, the salesperson loses visibility the moment the deal hands off. They can see the project name in another tool, maybe, but they can't see incidents, fees collected, or whether the client is happy. Second, finance has no real-time margin view — costs live in QuickBooks or NetSuite, revenue lives in HubSpot, and reconciliation happens in a spreadsheet at month-end. Third, when leadership asks "how much did this deal actually make us," nobody can answer without a half-day of digging.
The bolt-on approach treats sales and delivery as separate universes that occasionally talk. For project-based companies, they're the same universe. The CRM has to reflect that.
When we implement HubSpot for companies that sell projects, everything hangs off six objects working together. Each one has a specific job. None of them duplicates another.
Contacts hold the person-level intelligence: their stage in the buyer journey (which can differ from the deal stage), their goals, their pains, their relationship with the salesperson. The test is simple — anyone on the team should be able to pick up a conversation with any contact after reviewing the record, without a verbal briefing.
Companies hold the permanent layer: fit with your value proposition, MRR, churn risk, competitors in the account, sales signals. Projects, invoices, and deals all hang off the company. This is where account-level intelligence accumulates over years.
A deal represents one specific commercial conversation. A consulting firm might have three live deals with the same client at once — one with marketing about a website rebuild, one with sales ops about pipeline tooling, one with the CEO about an AI roadmap. Even if all three eventually become one engagement, they should be separate deals because they're separate conversations on the client side.
The deal pipeline includes Presale stages (information gathering, blueprint design, proposal creation, presentation) and post-sale stages (in progress, maintenance, closed won). The deal doesn't disappear from the pipeline when it closes. The salesperson can still open it six months later and see exactly what's happening.
This is the move most implementations miss. Tickets aren't just for customer support. They're the unit of work for every internal team — including presale.
A deal in the proposal stage might generate three tickets: discovery call, technical scoping, proposal draft. Each ticket has an owner, a SLA, a deliverable. When all the tickets close, the deal advances. The salesperson sees the work happening without nagging anyone. The delivery team sees their pipeline without opening seven different deals.
Some deals close with three tickets. Others require twelve. That data is now visible and comparable. You can finally answer "which deals cost us the most to win" — a question most services firms can't touch today.
After close, the project object holds everything related to delivery: costs, progress, documents, incidents, team members, pauses, change orders. One deal can produce multiple projects (in the example above, the website, the pipeline tooling, and the AI roadmap are three projects from the same account).
The project is what the salesperson opens when they want to know "how's this account going." Not Slack. Not a meeting. The record.
Most implementations leave finance out of HubSpot entirely. That's the single biggest reason CRMs feel disconnected from the business.
The invoice object — custom or repurposed from HubSpot's native one — records every dollar in and every dollar out tied to a deal. Subcontractor payments. Software costs. Travel. Client invoices. At minimum it captures vendor name and amount; at maximum it captures full invoice numbers and line items.
A rollup property on the deal sums all associated invoices, giving you real-time margin without leaving HubSpot. If you run NetSuite, Sage Intacct, QuickBooks, or any ERP with an API, you connect by dealaq ID. One consistent identifier in both systems is enough to associate automatically.
The deal pipeline is the spine. For a services firm, it usually looks like this:
The salesperson keeps ownership of the deal through every stage. They don't "hand it off" emotionally — they hand off the execution work but retain the relationship. That's a critical cultural shift the pipeline enforces.
The moment a deal moves to the handover stage, automation fires. A briefing meeting is scheduled. The PM and the salesperson both receive a checklist of what needs to transfer: signed scope, ticket deliverables from presale, contract terms, billing schedule, client expectations not captured in writing.
Everything that lived in presale tickets is already in the deal record. The briefing isn't "let me explain what we sold." It's a 30-minute alignment on edge cases and unwritten expectations. The PM walks out with everything they need. The salesperson walks out knowing the project will be executed against what was actually sold — not a reinterpretation.
This single mechanism eliminates the most expensive moment in any project-based business: the gap between sale and delivery where information evaporates.
Once the model is in place, a set of capabilities becomes available that most services firms simply don't have today.
Even teams that understand the model in principle make predictable mistakes during execution. A few worth flagging:
Don't collapse multiple opportunities into one deal. If a client has three active conversations, that's three deals. Merging them destroys visibility into which motion is actually working.
Don't skip the invoice object because finance "already has a tool." If margin lives outside HubSpot, the CRM will always feel like a sales toy instead of an operating system. The connection back to the ERP solves the duplication concern.
Don't let presale live in email and Slack. If the work to build a proposal isn't in tickets, you lose the ability to measure it, automate handover, and improve win rates over time.
You don't roll all of this out in one weekend. The order matters.
Map the deal pipeline first, including Presale and post-sale stages. Then add tickets for the presale team — that alone changes how proposals get built. Next, layer in projects and the handover automation. Finally, bring in the invoice object and ERP integration for the financial view.
Trying to do all four at once is how implementations stall. Doing them in sequence, with the team using each layer before the next one drops, is how they stick.
When you implement HubSpot for companies that sell projects this way, the CRM stops being a sales reporting tool and starts being the operating system for the business. Sales sees delivery. Delivery sees sales context. Finance sees real-time margin. Leadership sees which deal types are actually profitable, which clients are at risk, and where the capacity bottleneck really is. The arguments between teams about "who said what" disappear because the record holds the truth.
The firms that get this right over the next 24 months will have a structural advantage over competitors still running on spreadsheets and Slack threads. Not because they have better salespeople or better PMs — because their information moves faster than the competition's does. If you want to see exactly what this model looks like when it's already built and running, this is the implementation we deploy for companies that sell projects.