From Quote to Cash: Why Most Proposals Disappear Into the Void

The Proposal That Nobody Followed Up

Leila runs a boutique digital marketing agency in Brisbane. Eight staff, solid reputation, clients who genuinely like working with her. On a Tuesday afternoon in March, she sent a proposal to a mid-sized retail brand she'd been courting for three months. Forty-two pages. Custom strategy, detailed deliverables, competitive pricing. She spent two days putting it together.

Then she went back to her other work.

Four weeks later, the client signed with someone else. When Leila followed up, she learned they'd actually wanted to proceed but hadn't heard back from her after sending a clarifying question. The email had gone to her spam folder. The proposal sat in her quoting tool. The client's question sat in her inbox. The gap between those two systems cost her a $68,000 contract.

This isn't a story about spam filters. It's a story about what happens when the stages of a sale live in different places.

The Stages Nobody Maps End to End

Most business owners think about proposals as a single event: you write it, you send it, you win or lose. But there are actually six distinct stages between first contact and final payment, and each one is a place where things fall through the cracks.

• Lead capture: Someone expresses interest. Where does that live?
• Proposal creation: You scope the work and price it. Which tool?
• Proposal tracking: Did they open it? Did they have questions? Who's following up?
• Acceptance and handover: They said yes. How does that become a project?
• Project execution: Work gets done. Are costs tracked against the quoted scope?
• Invoicing and payment: Does the invoice reflect what was actually agreed?

For most SMEs, each of those stages lives in a different tool. Leads in a spreadsheet or a basic CRM. Proposals in a quoting tool or a Word document. Acceptance via email. Project setup in Asana or Monday. Time tracking in Harvest or Toggl. Invoicing in Xero. Payment reconciliation back in Xero, manually checked against the project.

Six stages. Six systems. Six places for something to go wrong.

What Leakage Actually Looks Like

The word "leakage" gets used in sales contexts to mean revenue that slips away quietly, without drama. It's not a client who says no. It's a client who meant to say yes but got confused, or waited too long, or assumed you'd follow up and you didn't. It's a project that started at $15,000 and finished at $22,000 in actual costs because nobody was tracking scope creep against the original quote. It's an invoice that went out for the wrong amount because the person doing the billing wasn't the person who negotiated the deal.

A 2023 study by McKinsey found that B2B companies lose between 10% and 40% of potential revenue to process failures in the sales-to-delivery handover. That's not lost to competitors. That's lost to friction.

For a business turning over $800,000 a year, 10% leakage is $80,000. That's a salary. That's a year of software subscriptions. That's the difference between a business that grows and one that stays flat while the owner works sixty-hour weeks wondering why the numbers don't add up.

The Handover Problem

Here's the specific failure point that causes the most damage: the moment a proposal becomes a project.

In most businesses, this handover is manual. The client says yes. Someone creates a new project in the project management tool. Someone else sets up the client in the CRM (or updates their status). Someone else creates a job in the billing system. The original quote, with all its detail about scope and deliverables and pricing, sits in the quoting tool while the project lives somewhere else entirely.

Three months into the project, a team member asks: "Wait, were we supposed to include social media management in this?" Nobody knows. The quote is in a PDF in a folder. The project brief was written from memory. The client remembers one thing; the account manager remembers another.

This is where scope creep begins. Not from bad clients, but from bad handovers.

And when the project finishes and it's time to invoice, whoever raises the invoice is working from the original quote (if they can find it) or from their own recollection of what was agreed. Either way, they're not working from a live record of what actually happened during the project: the extra hours, the revised deliverables, the change requests that were verbally approved but never documented.

The Admin Spiral This Creates

If you've ever felt like you spend more time on administration than on actual work, this is a major reason why. Every disconnected system creates reconciliation work. You have to manually check that the CRM matches the project tool. You have to manually verify that the invoice matches the quote. You have to manually follow up on proposals because your quoting tool doesn't talk to your calendar.

This is what the administration death spiral looks like in practice. It starts with a reasonable setup: a few tools, each doing one thing well. Then the business grows. More proposals, more projects, more clients. The reconciliation work grows with it. Eventually you're spending half your week on administrative glue work, the manual effort of keeping disconnected systems in sync, instead of doing the work that actually earns revenue or building the relationships that bring in new clients.

The craft suffers. The business development stops. The admin fills the gap.

What Closing the Loop Actually Means

Closing the loop means that every stage of the proposal-to-payment journey is connected. Not integrated in the sense that two systems send data to each other occasionally, but connected in the sense that there is one record, and it follows the client from first contact to final payment.

Here's what that looks like in practice:

Lead comes in. It's captured in the same system where you'll eventually manage the project. The client record is created once.

Proposal is built. You're pulling from the client record. The scope, deliverables, and pricing are structured data, not a PDF. You can see the history of every proposal you've sent this client.

Proposal goes out. You can see when it was opened. You get notified if it's been sitting unread for three days. Follow-up tasks are created automatically.

Client accepts. The proposal becomes the project brief. The quoted scope becomes the project scope. The quoted price becomes the budget. No manual re-entry. No handover meeting where things get lost in translation.

Project runs. Time tracked against tasks feeds into actual cost calculations. If actual costs are approaching the quoted budget, you know before you go over. Change requests are documented in the same system, linked to the original quote.

Invoice is raised. It reflects the agreed scope plus any approved variations. The client can see exactly what they're paying for. Payment is reconciled automatically against the project record.

At every stage, the data is in one place. There's no reconciliation work because there's nothing to reconcile.

The Visibility Problem Nobody Talks About

Beyond the operational failures, there's a strategic problem with disconnected proposal systems: you can't see your pipeline clearly.

If your proposals live in a quoting tool and your projects live somewhere else, you can't answer questions like:

• What's the total value of proposals currently outstanding?
• What's my average time from proposal sent to acceptance?
• Which types of projects have the highest acceptance rate?
• Which clients have the most proposals sitting unaccepted?
• What percentage of my quoted revenue actually converts to invoiced revenue?

These aren't vanity metrics. They're the numbers that tell you whether your pricing is right, whether your follow-up process is working, and whether the projects you're winning are actually profitable.

Without them, you're running a business on instinct. Sometimes instinct is right. But instinct doesn't scale, and it doesn't tell you which part of your process is broken.

What This Looks Like for Different Business Types

The proposal-to-payment problem isn't unique to agencies or consultants. It shows up differently across industries, but the underlying failure is the same.

A trades business sends a quote via email, wins the job, creates a job card manually, tracks materials on a spreadsheet, and raises an invoice at the end. If the job ran long or materials cost more than expected, that margin erosion is invisible until the end of the month.

A consulting firm sends a detailed proposal, wins the engagement, sets up a project in one tool and tracks time in another, then reconciles hours against the retainer manually at billing time. Every billing cycle is a small administrative project.

A health clinic provides a treatment plan with associated costs, delivers services over weeks or months, and invoices periodically. If the treatment scope changes, tracking that against the original plan requires manual cross-referencing.

A creative studio quotes a brand identity project, wins it, delivers across multiple rounds of revision, and invoices at milestones. Scope creep is almost guaranteed without a live link between the quote and the project.

In every case, the fix is the same: a single system that holds the client record, the proposal, the project, and the invoice, without requiring manual data transfer between stages.

The Practical Steps to Audit Your Own Process

Before you change anything, it's worth mapping where your proposals actually live right now. Ask yourself:

• When a lead comes in, where is it recorded?
• When I send a proposal, can I see whether it's been opened?
• When a client accepts, what's the first thing I do manually?
• How does the person managing the project know what was quoted?
• How does the person raising the invoice know what was agreed?
• Can I see, right now, the total value of all outstanding proposals?

If the answer to any of those questions involves a different tool, a manual step, or "I'd have to check," you have a gap. Gaps cost money. They cost time. And they cost clients, quietly, in ways that don't show up on any report because the report doesn't exist.

A Note on Integration vs. Unification

The instinct when you spot these gaps is to add an integration. Connect the quoting tool to the CRM via Zapier. Connect the project tool to Xero. Build a workflow that copies data from one system to another when a proposal is accepted.

This works, until it doesn't. Integrations break. They sync on a delay. They handle simple cases but fail on edge cases. And critically, they don't give you a single view of the client: they give you two systems that occasionally share data.

The more durable fix is a system where the proposal, the project, and the invoice are all expressions of the same underlying record. Change the client's name once, and it updates everywhere, not because something synced, but because there was only ever one record.

This is the architectural difference between bolting tools together and building on a single foundation. It's also the difference between a business that runs smoothly as it scales and one that adds administrative complexity with every new client.

Closing the Loop

Leila rebuilt her proposal process six months after losing that $68,000 contract. She didn't add more tools. She removed the gaps between the ones she had by moving to a platform where her CRM, proposals, projects, and invoicing shared the same data. The next time a client sent a clarifying question, it appeared in the same place as the proposal. The follow-up was automatic. The handover to the project team happened without a meeting.

She won the next three proposals she sent. She doesn't know if that's because the proposals were better or because the follow-up was tighter. Probably both. But she does know that she can now see, at any moment, exactly where every proposal stands, what it's worth, and what needs to happen next.

That visibility alone changed how she runs her business.

If you're sending proposals regularly and you're not sure where they go after you hit send, it's worth taking a look at how Opus connects the full lifecycle from lead through to payment. The [free tier](https://opus.net.au) is a reasonable place to start.