Where agency work gets lost between sales and delivery

Agency work gets lost between sales and delivery because the CRM, project tool and billing app each store a separate copy of the client. When a deal is won, someone manually creates a project, re-types the scope and hopes production reads the sales notes. Every field not copied is context that dies at the handoff — and agencies run this handoff on every new engagement.

This post maps exactly where information disappears, why process fixes alone do not work, and what an architectural fix looks like.

The handoff nobody designed

Most agencies have a sales process and a delivery process. What they lack is a designed connection between the two.

The typical flow:

Sales closes deal in CRM
        ↓
  [manual handoff — no system support]
        ↓
PM creates project in project tool
        ↓
Account manager sets up billing
        ↓
Designer asks "what did the client actually want?"

The gap in the middle is not a missing feature. It is a missing shared data model. The CRM thinks the job is done. The project tool thinks the job starts from scratch. Nobody owns the seam.

Five places context dies

1. Scope details in deal notes

Sales captures nuance in free-text deal notes: “client wants bold, not corporate,” “budget is tight but they will pay for rush,” “CEO signs off, marketing manager runs day-to-day.” None of this is structured data. When the PM creates the project, they copy the deal title and value — not the three paragraphs of context that actually matter.

What production sees: “Website redesign — £24,000.”
What production needs: everything in the notes field nobody read.

2. Budget breakdown

The deal value is £24,000. But sales agreed: £16,000 for design, £5,000 for development, £3,000 for copy. That breakdown lives in a spreadsheet attached to the deal — or in the sales rep’s head. Billing sets up a single £24,000 invoice. Production spends £18,000 on design and wonders why the budget is “tight.”

3. Stakeholder map

Sales met three people: the CEO (decision-maker), the marketing manager (day-to-day), and the IT lead (technical gatekeeper). The CRM has one contact linked to the deal. The project gets assigned to “Acme Corp” with no indication of who approves what. The designer sends mockups to the marketing manager; the CEO rejects them because nobody told the designer the CEO signs off.

4. Timeline constraints

“We need this live before the conference on the 15th” was discussed on the sales call. It is in the deal notes — maybe. The project gets a default six-week timeline. Week four, the account manager discovers the conference deadline and escalates.

5. Client history

This is the client’s third project with the agency. The first two had scope creep, a late payment, and a champion who left the company. None of that is visible in the project tool, because the project tool only knows about this project. Production treats it like a first engagement.

Why process fixes are not enough

Agencies that recognise the handoff problem usually respond with process:

• Handoff templates — a form the sales rep fills in before closing
• Kickoff meetings — a meeting where sales briefs production
• Mandatory fields — required CRM fields that must be complete before “won” status

These help. They also fail predictably:

Process fix	Why it degrades
Handoff template	Skipped when sales is busy closing the next deal
Kickoff meeting	Knowledge stays in someone’s memory, not the system
Mandatory fields	People fill minimum viable data to unblock the stage
Slack handoff message	Unsearchable, unlinked, lost in the scroll

Process depends on discipline. Discipline erodes under pressure — and agencies are always under pressure. The fix that survives busy season is not a better form. It is removing the copy-paste step entirely.

The architectural fix: one client record

The handoff breaks because three tools have three client records. The fix is one record that everything references:

Company: Acme Corp
├── Contacts (CEO, Marketing Mgr, IT Lead)
├── Deal: Website redesign — £24,000 [Won]
│   ├── Scope notes
│   ├── Budget breakdown
│   └── Timeline: live before 15th
├── Project: Acme Website Q3
│   ├── Tasks
│   ├── Assignees
│   └── References the deal above
├── Invoice: £8,000 milestone 1
│   └── References the project above
└── Documents: contract, brief, brand assets

When production opens the project, they see the deal it came from — scope, contacts, budget, timeline — without anyone copying anything. When billing creates an invoice, it references the same company. When the account manager checks client history, all three previous projects are right there.

This is not a feature wish list. It is what happens when CRM, projects and billing share one database.

What changes in practice

Sales closes a deal

The deal record already has the company, contacts, value, scope notes and timeline. Nothing needs to be “sent” anywhere.

PM starts delivery

They create a project linked to the same company and deal. The scope, budget breakdown and stakeholder contacts are already attached. The first task is real work, not archaeology.

Billing invoices a milestone

The invoice references the company and project. Rates agreed during sales are in the deal record. No one checks three systems for the number.

Designer joins the project

They open the project and see: the brief (documents), the stakeholders (contacts), the constraints (deal notes), and the previous engagements (project history). No kickoff meeting required for basic context — though kickoffs still help for nuance.

Account manager checks in

They open the company record and see: pipeline deals, active projects, outstanding invoices, and upcoming calendar events. One view, not four tabs.

The cost of the broken handoff

Context loss is invisible on any single invoice, which is why it persists. But it accumulates:

• Rework — deliverables that miss unstated requirements
• Scope creep — production discovers “extras” that sales already promised
• Slow starts — first week spent reconstructing what sales already knew
• Client friction — “I already told your sales team this”
• Margin erosion — unbilled time spent on handoff archaeology

Multiply by the number of engagements per year, and the broken handoff is one of the largest hidden costs in a fragmented agency stack — larger than any single subscription line item.

How sSystm handles the handoff

In sSystm, the handoff is not a process — it is a property of the data model:

• CRM holds contacts, companies and deals
• Projects reference the same companies and can link to deals
• Billing invoices reference the same companies and projects
• Documents attach to companies and projects
• Calendar events link to companies and projects

There is no export step. No copy-paste. No “check the CRM for details.” The client record is the hub; every module is a spoke.

Your AI connected over MCP can read the full context — deal notes, project status, invoice history — in one query. That is only possible because the data is in one place, not because the AI is especially clever.

The one-minute test

Pick your last three won deals. For each one, answer:

1. Can you see the active project without leaving the CRM?
2. Can you see the deal scope from the project view?
3. Can you see all invoices for that client in one place?
4. Can a new team member find the signed contract in under 60 seconds?

If any answer is no, your handoff is a manual process — and manual processes lose context every time.

---

Related: Agency CRM vs generic CRM · Why agencies need CRM, projects and billing in one tool · The real cost of disconnected agency tools