Sales funnel optimisation: a RevOps approach to finding where B2B deals actually stall

Sales funnel optimisation in B2B usually means picking a tactic: a new qualification framework, a shorter form, a tighter follow-up cadence. That works when the funnel itself is sound. In most B2B SaaS companies it isn't, and the tactic just adds a layer of polish on top of a process nobody agreed on. 

So what is sales funnel optimisation actually trying to achieve? At its core, it's about building a solid, scalable process that reps can actually follow, one that minimises bottlenecks and delivers a fluid sales journey. 

Done well, it improves both conversions and the buyer's experience along the way. A faster sales cycle, better conversion rates at each stage, and a way to measure the outcomes so the process keeps adjusting as your team and your market evolve. 

All of that eventually translates into closing more deals, which is the only reason any of this is worth doing: more revenue, delivered more predictably.

Why the usual funnel advice misses the point

Most sales funnel content repeats the same tips: add BANT or MEDDIC, track more CRM fields, speed up follow-ups, build a better forecasting dashboard. 

None of it is wrong, exactly. It's just built on an assumption that doesn't hold: that the funnel structure itself is fine, and the problem is discipline or tooling. 

In practice, the funnel is often the thing that's broken. A new framework bolted onto a broken structure just gives you a more detailed report on the same mess.

The actual problem: nobody agrees what a stage means

Here's the pattern I keep running into with B2B SaaS revenue teams. A deal moves through the pipeline, but nobody really agrees on when it should move, or what needs to happen for it to get there. One rep treats "Demo" as done the moment the call ends. Another keeps it open for three weeks waiting on a follow-up that never gets scheduled. 

From the outside, this looks like a leaky funnel. From the inside, it's simpler than that: nobody ever wrote down what each stage actually means. 

That's the gap Revenue Operations (RevOps) exists to close. Someone has to own the stage definitions, the exit criteria, and the handoffs, because sales teams are rarely given the bandwidth to step back and build that clarity themselves. A leaky funnel is usually the clearest sign that this ownership is missing, or scoped too narrowly to matter. Fixing it comes down to two things, in order: build a solid foundation, then find where it's still leaking.

Step 1: Give every stage clear exit criteria

Most stage names describe where a deal is, not what a rep needs to do to move it forward. "Discovery." "Demo." Labels, not instructions. The name itself can stay exactly as it is. What needs to change is what's attached to it. 

Not just "Discovery," but: to exit this stage, the rep has confirmed budget authority and a target timeline with the buyer. Not just "Demo," but: to exit this stage, the rep has presented the demo and sent a follow-up email within 24 hours. Not just "Proposal," but: to move on, there's a signed mutual action plan with a target close date. 

That level of specificity does more for pipeline hygiene than any dashboard. It removes the guesswork around what "in progress" actually means, both for the rep and for whoever reviews the pipeline afterwards.

‍

{start-table}

Stage

• Discovery
• Demo
• Proposal
• Negotiation
• Closed Won

Stage weight

• 20 %
• 40 %
• 60 %
• 80 %
• 100 %

Example (£100K deal)

• £20,000
• £40,000
• £60,000
• £80,000
• £100,000

Exit Criteria

• Budget authority and a target timeline confirmed with the buyer
• Demo presented and follow-up email sent within 24 hours
• Signed mutual action plan with a target close date
• Redlines resolved and verbal commitment from the economic buyer
• Contract signed

{end-table}

‍

A weighted pipeline number is only as trustworthy as the exit criteria behind it. A deal sitting in "Proposal" without a signed mutual action plan isn't actually 60% likely to close, whatever the stage weighting says.

Treat the sales pipeline like a product, not a policy

I think about this closer to product management than sales management. The rep is the customer. The process is the product. If a stage exists only to produce a report for leadership, reps will find a way around it, and the data will lie to you. If it makes the rep's day easier, they'll use it without being told to. 

That's the real test before you ship any new stage or field: does this create value for the person using it, or just a metric for the person watching it?

Score movement on intent, not activity

A lot of teams still lean on activity to move a deal forward. None of it tells you whether the buyer is actually close to a decision.

• Weak signal: a call logged, an email opened, a form filled out
• Strong signal: a prospect booking a demo with three colleagues, someone asking about implementation timelines before you've raised it, a champion forwarding your proposal internally without being asked

The strong signals are messier to track than a logged call, but they're what actually predicts a closed deal. Put them in your stage criteria, not just in a rep's gut feeling. This is the foundation, and it holds as long as it's rolled out clearly, not necessarily gradually. 

Redesign whichever stages need it, put the new criteria in writing, and walk the team through it so there's one standard to work against instead of five reps each guessing at what "in progress" means. 

Skip this and nothing that follows will hold, because you won't be able to tell a real bottleneck from noise caused by reps interpreting the same stage differently.

Step 2: Diagnose the specific bottleneck

Once stages are clearly defined, "the conversion funnel is leaking" stops being a vague complaint and becomes a specific question: which transition is the bottleneck, and why do deals get stuck there?

‍

Read the CRM for patterns

This part is pattern recognition before it's a fix. Across hundreds of deals, look for where stage duration spikes, where deals loop backward, and where the same rep phrasing shows up right before a deal stalls. 

This is exactly what AI is good at surfacing, but only once the foundation from Step 1 is in place. Consistent stage definitions, reliable timestamps, structured notes instead of free text nobody reads. Point AI at messy, undefined stages and it will still find patterns, just the wrong ones, delivered with total confidence, which tends to be worse than finding nothing at all. 

We've built Claude skills at YOYABA for exactly this: taking a messy CRM history and surfacing where deals actually stall, which transitions are the noisiest, and where the definitions people use don't match what's happening in the data. What used to take a RevOps team weeks now takes an afternoon, and it gets more useful the cleaner the underlying stage data is.

Check the properties already sitting in your CRM

A couple of fields most teams already have and barely use:

• Closed-lost reason codes, if reps are picking a real reason and not the default option in the dropdown
• A competitor field, logged the moment a competitor is first mentioned on a call, not just at the point a deal is lost

Once that second field is populated consistently, you can ask a sharper question than "where do deals stall." You can ask "where do deals stall specifically when a certain competitor is in the room," which often points to a positioning gap at one exact stage rather than a general process problem.

Listen to the calls, not just the data

Closed-lost reasons and competitor fields tell you what happened at the end. A call transcript tells you what happened in the moment, which is closer to why. 

Pull a sample of AE call recordings from the exact stage the data flags as a bottleneck, not at random. That turns a vague hypothesis into something checkable: is the objection reps mention anecdotally actually showing up on the calls, at the frequency they think, right before deals stall in the data? 

This is also where AI earns its place a second time. Reviewing calls by hand doesn't scale past a small team, but scanning transcripts for a recurring phrase across hundreds of calls is exactly the kind of pattern-matching AI is suited to, as long as the stage data is clean enough to know which calls belong to which stage.

Then go talk to the reps

The data tells you where a deal stalled, not always why. That's where you actually go talk to your reps. They know things the CRM never captures: the objection that keeps coming up off-script, the internal buyer who goes quiet at a certain point, the step that feels redundant every time. 

Skip that conversation and act only on the data, and you're just replacing a gut feeling with a dashboard's version of one. Ten minutes with three reps about a single stage usually surfaces more than another week spent slicing the same CRM export a different way.

None of these sources tells the full story alone. A spike in stage duration could mean anything. The same spike, cross-referenced against a closed-lost reason citing the same competitor, and confirmed by a handful of transcripts where reps struggle with a specific objection at that exact stage, stops being a guess and becomes a finding you can act on.

That combination, process understanding, clean CRM data and stage definitions, AI to find the pattern, and honest input from reps, is why RevOps is best placed to do this work. Not sales leadership, which is close to the day-to-day but rarely has room to step back and instrument it. Not marketing, which owns a different stretch of the funnel entirely. And not a tool bought off the shelf with nobody owning the foundation underneath it.

Step 3: Fix the handoffs

Handoffs are some of the most fragile points in a revenue process. Every time ownership moves from one team to another, there's a chance for context to get lost, expectations to change, or a deal to sit in limbo.

The obvious example is marketing to sales. If marketing and sales aren't working from the same definition of a qualified lead, the funnel inherits that mismatch from day one. Deals enter the wrong stage, get worked with the wrong urgency, and early sales stages take the blame for something that started upstream.

But the same thing happens later in the funnel. Sales hands a new customer over to post-sales. If the context from the sales process isn't transferred properly, the customer ends up repeating information, the post-sales team starts from scratch, and the experience takes a hit.

The fix isn't another handoff checklist for the sake of having one. It's making the transition explicit: when does ownership change, what needs to be true before it changes, what information needs to move with it, and who owns the next action?

That's where RevOps can have a real impact. It can define the rules across teams, make the required information visible in the CRM, and measure what happens after the handoff rather than assuming the process works because the deal moved stages.

The same diagnostic approach from Step 2 applies here. Look for where deals or customers slow down after a change in ownership, where information is repeatedly missing, or where one team consistently sends work back to the previous team. Those patterns tell you where the handoff itself needs attention.

{{cta}}

The funnel doesn't stop at closed won

A sales funnel naturally ends at closed won. The revenue process doesn't. Once a customer signs, the process widens again: onboarding, adoption, retention, expansion, and advocacy all become part of the picture. That's the logic behind the bowtie model.

For sales funnel optimisation, the bowtie is useful less as a new framework to implement and more as a reminder: don't optimise the sales process in isolation. A funnel can look healthy through closed won while the handoff into post-sales creates churn, delays onboarding, or leaves expansion opportunities on the table.

The same principles still apply on the other side of the deal: define what a successful transition looks like, make ownership clear, measure where customers slow down, and fix the bottleneck you find. The goal isn't to turn this article into a full customer lifecycle framework. It's to make clear that closed won is a handoff, not the end of the revenue process.

Keep measuring and improving the process

Redesigning the funnel isn't a one-time project. You can roll out the changes across the process at once if that's what makes sense for the team. What matters is what happens after the rollout.

Build enough visibility into the funnel to see where deals are slowing down, where handoffs are breaking, and where reps are working around the process. Then use that information to keep refining it.

A new process will surface problems that weren't visible before. Some bottlenecks will disappear. Others will move somewhere else. New ones will appear as the team grows, the product changes, or the way customers buy evolves.

That's why conversion funnel optimisation should be treated as an ongoing RevOps process: define the process, make it visible, measure what happens, find the next bottleneck, and improve it.