Why Are We Trying to Deflect Helping Our Customers? What we should be doing instead to measure the success of our self-service offerings.
There’s a question I keep coming back to lately:
Why is the success of self-service measured by how many customers don’t ask us for help?
For years, the industry standard has been case deflection.
If a customer doesn’t open a support case, we assume self-service worked.
On paper, it sounds efficient.
In practice, it’s incomplete and in many ways, disconnected from how customers actually behave.
Industry Context (and Where This Breaks Down)
Across the industry, success is often defined by:
- Case deflection
- Cost avoidance
- Reduced ticket volume
Organizations influenced by groups like Gartner and TSIA have started to expand this thinking; but deflection still remains a primary signal.
This challenge becomes even more pronounced in complex B2B, high-technology environments; where customers aren’t looking for simple answers, but are navigating interconnected systems, configurations, and dependencies.
In these environments, support models are often aligned to practices like Consortium for Service Innovation’s Knowledge-Centered Service (KCS) and Intelligent Swarming; where knowledge sharing, collaboration, and continuous learning are foundational.
Self-service isn’t a single interaction in this world. It’s part of a broader ecosystem of knowledge, community, documentation, AI tools, and assisted support working together.
The Problem With Deflection
Case deflection assumes something very specific:
That a customer started the process of asking for help… and then chose not to.
But that’s not how most customers operate.
The reality is that only a fraction of users ever get close to submitting a case.
Before that point, they are:
- Searching documentation
- Reading knowledge base articles
- Browsing community threads
- Googling solutions
- Asking AI tools for help
- Trying, failing, retrying, and adapting
By the time a customer even considers opening a case, they’ve already invested significant effort trying to solve the problem themselves.
So when we measure success by “deflection,” we’re not actually measuring the experience.
We’re measuring the absence of an action at the very end of a long, mostly invisible journey.
The Visibility Gap
This creates a fundamental problem:
We have high visibility into assisted support …and very limited visibility into self-service behavior.
Most reporting models are built around:
- Case creation
- Case resolution
- Agent activity
But the majority of the customer experience happens before any of that exists in our systems.
That’s where customers:
- Build understanding
- Get stuck
- Find partial answers
- Piece together solutions
- Or quietly give up
And in most cases, we don’t measure any of it.
Not Thinking Like a Customer
At its core, this is a perspective problem.
We’ve built reporting models based on how support organizations operate
instead of how customers actually solve problems.
Customers don’t think in terms of:
- Should I open a case?
- Am I deflecting support?
They think:
- Can I fix this?
- Why isn’t this working?
- Where do I go next?
- What can I do on my own to solve the problem?
Self-service isn’t a channel to them like it is to us. It’s a journey of trying to solve something, often under pressure, often without context.
Get Kellie Sullivan’s stories in your inbox
Join Medium for free to get updates from this writer.
In KCS-aligned environments, we already recognize that knowledge is created and improved across every interaction.
But our measurement models haven’t fully caught up to reflect how customers actually consume and use that knowledge independently.
When we measure only the moment they don’t open a case, we ignore everything that led up to that decision.
So Where Does That Leave Us?
If deflection doesn’t truly measure success… what does?
The answer isn’t to throw it away entirely. It’s to recognize that deflection is a lagging indicator, not a complete picture.
To understand self-service, we need to shift from:
Measuring outcomes only
➡️ to
Measuring behavior and signals throughout the journey
Rethinking Self-Service Measurement
Instead of asking:
Did the customer open a case?
We should be asking:
- Did they engage with the content?
- Did they explore multiple paths?
- Did they interact in meaningful ways?
- Did their behavior suggest they found what they needed?
Because in a self-service world, success often looks like:
- A customer reading deeply, then leaving
- A user refining a search and finding the right answer
- Someone solving a problem without ever telling us they did
That success is real. It’s just not captured in traditional models.
The Challenge (and Opportunity)
Here’s the reality:
We have very little direct insight into what customers are doing before they engage with support. But that doesn’t mean we can’t measure it.
It means we need to get better at identifying signals of success instead of relying on a single outcome. This is where behavioral data becomes powerful.
Things like:
Time spent
Scroll depth
Interaction patterns
Navigation paths
Exit behavior
Individually, none of these are perfect indicators. But together, they begin to tell a story: Evidence of resolution
What’s changed more recently is that we no longer have to evaluate these signals entirely in isolation.
With Google Analytics 4, engagement is now measured using a composite model built around events and session behavior.
GA4 automatically captures signals such as:
- Page views
- Scroll depth (at approximately 90%)
- User engagement time
- Clicks and interactions
- Navigation across multiple pages
It also introduces the concept of an engaged session, defined as a visit that:
- Lasts longer than 10 seconds,
- Includes two or more page views, or
- Triggers a conversion event
Importantly, conversion events in GA4 are not predefined. They are events that organizations choose to mark as meaningful outcomes, such as a form submission, download, or key interaction.
This gives us a more flexible, and more realistic, way to model our user behavior.
Instead of analyzing time on page or clicks independently, we can begin to understand engagement as a set of combined signals.
But even this model has limitations.
Privacy regulations, particularly under General Data Protection Regulation, can restrict tracking and reduce visibility into user behavior. In some cases, data is partially modeled or unavailable entirely.
And that’s the reality of self-service measurement today:
We’re working with the best available signals, and learning how to interpret them more intelligently.
A Shift in Thinking
The future of self-service measurement isn’t about deflecting support.
It’s about understanding:
Did the customer successfully solve their problem, whether we saw it happen or not?
That requires a different mindset:
- From binary → to probabilistic
- From outcomes → to signals
- From internal processes → to customer behavior
What Comes Next
This is the question I’ve been working through:
How do we measure the success of a self-service experience when most of it happens outside of our direct visibility?
In my next post, I’ll share the framework we’ve been building to answer that, including how we’re using behavioral signals to define self-service success in a more meaningful way, and how we’re starting to measure the overall health of the system itself.
