*sigh*… We’ll always have to fix bottlenecks.

You might’ve cracked your head to design and implement the perfect user journey that will lead most users to success.

Yet, most users won’t go through it, they’ll follow their own journey. And in the process, they’ll face bottlenecks—points in the journey where the user’s progress is slowed, interrupted, or simply blocked.

These bottlenecks are often not obvious and you won’t find them without exploring product analytics. For instance:

• A user who fails to use a core feature successfully due to a visual bug.
• UI that’s time-consuming, tedious, and prone to errors.
• An onboarding flow that, instead of making the feature easier to learn, makes it overwhelming and causes cognitive overload on users (making them likely to skip it).

So now, let’s explore the process to identify and process bottlenecks, and how we apply them at Userpilot:

How to identify and eliminate bottlenecks in the user journey

Harsh truth: The SaaS user journey is extremely complicated. It lasts months, and every user will have a different path regardless of how streamlined or personalized your product experience is.

You can’t just dive into the behavioral data and hope to find a bottleneck without first knowing what a bottleneck looks like.

Instead, you must be more strategic. Here’s how:

1. Map out the customer journeys that are valuable for you

Again, the SaaS user journey is too complicated. You can’t just map out every possible journey with your product.

But if you want to find important bottlenecks, you should map out the important touchpoints of the journey that have an actual business impact. This way, it will be possible for you to define what a bottleneck is before you start looking for it.

There are many ways to approach this, but my favorite is how Duolingo created a Markov model around their main business KPI (DAUs) to grow it. In the same way, you can start from your business KPI and then break it down into sensitive metrics and touchpoints you can map.

Plus, you don’t have to create a Markov model to find bottlenecks. You can just measure a set of sensitive metrics to identify bottlenecks and improve your main KPI (even if they’re not mutually exclusive like Duolingo’s model).

For example, if your main KPI is product adoption, some sensitive metrics can include:

• Feature adoption rate
• New user retention rate
• Activation rate
• Time-to-value
• Product stickiness
• Usage frequency

And once you measure these metrics, you can start mapping out the touchpoints that affect those metrics, and track them with some analytics tools. For instance, you can use funnel analysis to map the actions a user must take to achieve the activation milestone, and spot steps with high drop-offs.

Or for product stickiness, you can use path analysis to break down the journey of active users compared to less active users.

2. Check for ‘signals’ that can indicate existing bottlenecks

As I mentioned, a bottleneck is any experience in the product that prevents users from making any progress.

These friction points can manifest through different “signals” in the data depending on how you mapped out the user journey in the last step.

Some common examples include:

High drop-offs during funnel stages

If you’re analyzing a funnel like onboarding and find high drop-off rates in one step, there’s probably a bottleneck stopping the users from moving to the next stage.

Bear in mind: It can be something as simple as a button that doesn’t work, or a deep usability issue with one of your core features that requires deep investigation.

Unexplained customer churn

Sudden or persistent increases in churn can be a signal of unresolved user frustrations due to a significant bottleneck.

For more detail, you can further segment churned users to trace down where the spike is coming from. If it’s coming from new users or previously active users, then the potential bottlenecks could be very different.

Low adoption with core features

If the percentage of users who adopt core features is dropping, they’re probably failing to find the value of your product—causing a bottleneck in the adoption process.

The causes for this could be serious, such as a product-market fit problem. But it can also happen due to usability issues or even unreported bugs.

High volume of customer support tickets or complaints

Users naturally resort to customer support to address pressing problems. Think of:

• App-breaking bugs.
• Getting technical help to perform a task that can’t be done with the product (e.g., integrations).
• Data management issues.

Although they won’t help you find subtle bottlenecks related to usability, you can categorize your support tickets to identify recurring problems that are actively affecting the journey—and fix them.

Looking for an All-In-One Platform to Find and Fix Bottlenecks? Try Userpilot

Get a Demo

• 14 Day Trial
• No Credit Card Required

3. Investigate and come up with data-driven hypotheses

Once you’ve spotted a signal, the next step is to come up with multiple hypotheses and investigate them in detail.

As a starting point, you can start making up hypotheses based on:

• User experience: Is the UI of the core features unnecessarily bloated? Is it causing any confusion for new users?
• Product functionality: Is the feature failing to fulfill a desired task? Is there a missing setting in the product?
• Market behavior: Did a competitor release a big update that fulfills the JTBDs better? Did they implement an AI feature to fulfill these JTBDs?

But to come up with substantial hypotheses that have weight, you should also investigate using frameworks such as The 5 Whys, heuristic evaluations, or fault-tree analysis to spot the potential root cause of your bottlenecks.

For example, if you have to analyze a decline in activation rates:

1. Activation rate declined by 16%. Why?
2. Users drop off after the “import existing projects” step. Why?
3. They get stuck when they need to format their data. Why?
4. The onboarding instructions don’t clearly explain the required format. Why?
5. It assumes users are familiar with .CSV imports from other tools. It needs a clear in-app instruction.

4. Validate and prioritize bottlenecks based on their business impact

After digging into the data and observing how users interact with your product, you’ll start gathering evidence to support or discard your hypotheses.

But the final filter of your hypotheses must be: “Is this true?”

To confirm that a bottleneck is real, you can conduct some targeted research and use analytics tools that can test the validity of a hypothesis.

For example, we love session replays for analyzing product-related hypotheses.

One thing you can do is not only watch users who present a bottleneck signal but additionally, compare their sessions with users who successfully engage with a feature—allowing you to find the real source of the bottleneck.

Also, there’s more you can play with, think of:

• Customer interviews.
• Usability tests.
• Heatmaps.
• A/B testing.
• Retroactive analysis.

Once you get the evidence, you should measure the impact of the bottlenecks on your main KPI. The KPI must be specific, like “If we don’t fix the post-onboarding churn, DAUs will drop by 48% in the next four months.”

Finally, create a list of validated bottlenecks. Make sure they’re ranked based on their business impact to prioritize the most impactful ones.

5. Brainstorm and implement solutions for bottlenecks

With all your bottlenecks organized and prioritized, the next natural step is to define solutions for each of them.

For example:

• If there’s a high drop-off from a new feature because customers can’t use it correctly, implement an interactive walkthrough to make the whole process easier and clearer.
• When users don’t upgrade their plans because they don’t understand the value of premium features, offer them free, limited access to the pro features so they can experience them.
• If new users fail to activate key features because they skip the product tour, replace it with an onboarding checklist to make activation easier to achieve.

After the brainstorming, what’s left is to implement the solutions. Remember to start from the highest priority to the lowest, and make sure their deployment is aligned with your current roadmap.

6. Test your solutions to validate their effectiveness

Now, you can’t call the job done just by implementing random solutions. Except for bugs or punctual usability issues, you must also validate their effectiveness and make sure the issue is fixed.

To do this, trace back to the problem you were trying to solve earlier and tie it to your success metric. So if there was a bottleneck in feature adoption, has product adoption improved after implementing the solution? If so, how much was the improvement?

For instance, if the issue is product experience, I highly recommend running A/B testing or multivariate experiments. These will help you validate a solution based on the statistical significance of the data and flag the bottleneck as “solved.”

You can resort to in-app surveys or interviews to collect feedback and confirm that your solution was beneficial for users.

How do we conduct bottleneck analysis in Userpilot?

Although the entire process is pretty thorough and specific, it can look different from company to company, depending on how you apply it.

For instance, Lisa Ballantyne (Userpilot’s UX researcher) follows pretty much the same framework I just explained to fix bottlenecks in the user journey (with minor differences).

She would:

1. Make observations and perform heuristic evaluations to spot signals.
2. Come up with a hypothesis of a potential bottleneck
3. Perform deeper analysis to validate that the bottleneck exists.
4. Measure its impact and give it the right priority.
5. Implement a solution and make sure it works.

An example of this is how she addressed a UI issue with the custom dashboard feature. At first, she observed that adding existing reports to a dashboard could be unintuitive because the button placement was quite off. Then, she hypothesized that users might misclick the report they wanted to add, causing friction.

This led her to watch session replays of users who added existing reports and find out that users were indeed misclicking the “add” button. The priority for this wasn’t too high, so the solution came later on when there was a need to update the feature.

Finally, when the time came, the team updated the feature to allow adding multiple dashboards at once (solving the issue by allowing users to select the reports when hovering over their names).

‹

›

Here’s the most essential part to remove existing and potential bottlenecks

If you want to fix bottlenecks without getting lost in the data, you must indeed follow a solid framework.

However, the real backbone for your bottleneck analysis will be the tech stack you use to get the data you need.

For example, let’s say you’re a product analyst or PM who needs to find bottlenecks within your app. An all-in-one platform like Userpilot won’t only let you track your product performance but also create in-app experiences (e.g., walkthroughs or checklists) and A/B test them to validate your bottleneck solutions.

So if you’re looking for a platform that can allow you to find and fix bottlenecks in one place, consider booking a Userpilot demo to get started.

Looking for an All-In-One Platform to Find and Fix Bottlenecks? Try Userpilot

Get a Demo

• 14 Day Trial
• No Credit Card Required