How to find where users drop out of a Mixpanel funnel

You find where users drop off by building a Funnels report in Mixpanel from the events that make up the journey you care about, such as signup, onboarding, or upgrade. Each step is an event your product already sends, like "Sign Up Completed" or "Project Created." Mixpanel counts the users who did the first step, then how many of them went on to do each later step within a time limit called the conversion window, which is 7 days unless you change it. The step where the share falls hardest is where users drop out.

Mixpanel gives you a lot to work with on its own. You choose whether users must complete the steps in the order you listed or in any order, and whether to count unique users, total conversions, or sessions. You can break the funnel down by a property such as country, device, or UTM source to see whether one group converts worse than the rest. You can hold a property constant, so a user only counts as converting if, for example, they stayed on the same plan the whole way through. And you can exclude users who did something in between, such as contacting support.

When you click on a step, Mixpanel lets you act on the people who dropped off there. You can view them as a list, save them as a cohort, watch their session replays if replay is turned on in your project, or open the drop-off in a Flows report to see where those users went instead. You can also switch the funnel to show how a step's conversion has changed over time, or how long people take to get from one step to the next.

What the report doesn't do is tell you which drop to believe or which one to fix. A step can look broken because its event was renamed in a release, or because the anonymous visitor who started the journey and the account they created are being counted as two different people. The biggest drop may sit on a step that few people reach, while a smaller one loses your best prospects. And once you've found the right step, the report can't change the screen people leave from.

That's the real work in this job. A good result names one step, the group of users it loses, the most likely reason, and a change worth making, with numbers you can measure the change against.

Kite does that work for you. It reads your Mixpanel project, finds the drop-off that matters most, works out why people leave, and builds the fix.

Start by telling Kite which journey worries you. The request can be as plain as this:

"A lot of people start a trial and never create a project. Use Mixpanel to find where they drop out and tell me what to change."

Kite is an AI marketer. It researches your business, builds a growth strategy, and ships the work that brings you new customers. By the time you ask, it already knows your product, your plans, and what a good customer looks like from that research. That lets it propose the journey to chart, the events that mark each step, the date range, and the groups to compare, without a long brief from you. It posts that plan in the conversation, and you confirm it or adjust it.

You'll need to connect your Mixpanel account by signing in to Mixpanel from Kite. Kite then works with the projects your account can see. If your organization keeps more than one project, such as one for your marketing site and one for your product, Kite asks which one holds the journey you asked about.

Reading your Mixpanel data is routine analysis, so Kite runs it and reports back without checking in. It asks for your approval before anything reaches your users, such as a changed page or a launched experiment.

Kite starts with what your team has already built, because the definitions your team trusts are a better starting point than a guess. It reads the business context your team saved in Mixpanel, the short notes that explain what a term like "Activated" means at your company. It searches your project for saved funnels, reports, dashboards, and metrics, and when someone has already built a funnel for this journey, Kite reads its results and starts from there.

Then Kite reads the project's events and properties, so every step of the funnel uses an event that really exists. It reads your event names and descriptions, which events your team marked as verified or hidden, and the event and user properties attached to them, including the custom ones. It also reads the values a property actually takes, so a breakdown by plan uses "Pro" and "Team" rather than names that don't appear in your data.

Kite checks each step's tracking before it trusts the funnel, because a broken event looks exactly like a drop-off. It pulls the daily count of users who did each step's event over the period it plans to study. If "Project Created" fell to almost nothing on the day of a release while signups held steady, the problem is tracking, not users, and Kite tells you that first.

It also reads the data quality issues Mixpanel has flagged for those events, such as a property that suddenly started arriving as the wrong type. And it looks for near-duplicate event names, like "Sign Up Completed" and "signup_completed," because a step built on the older name will undercount everyone who arrived after the change.

The step where an anonymous visitor becomes a signed-up user gets an extra check. Mixpanel only treats the visitor and the new account as one person when your product links them at signup or login. When that link is missing, everyone who signs up seems to vanish at that step, so Kite reports a problem like this as its own finding, separate from the real drop-offs.

Kite builds the funnel from the journey's major milestones first, then charts the steps inside whichever stretch loses the most people. A self-serve product's trial journey might look like this:

• Viewed the pricing page
• Started signup
• Completed signup
• Created a first project
• Invited a teammate

Kite sets the conversion window to fit the journey, because the right window changes what the funnel says. Someone usually finishes signing up within minutes of starting, but might take a few days to invite a teammate. A window that's too short counts slow users as lost, and Mixpanel's 7-day default can hide a step that people never come back to.

It also decides how strictly the steps must happen in order, and what to count. Most journeys need users to complete the steps in the order listed, so Kite uses any order only when users can reasonably do the steps either way round. It counts unique users unless the journey repeats, such as a checkout someone can complete several times. When a property should stay the same from start to finish, such as the plan a user is trialing, Kite holds it constant so a user who switched plans midway doesn't blur the result.

The step with the lowest conversion rate isn't always the one to fix first, so Kite weighs a few things before it picks:

• How many users reach the step, because a small leak on a busy step can cost more people than a big leak on a quiet one
• How close the step is to revenue, because losing people after they've created an account usually costs more than losing pricing-page visitors
• Whether the drop is spread evenly or concentrated in one group

That last check usually finds the answer. Kite breaks the weak step down by one property at a time, such as device, browser, country, plan, and the UTM source and campaign of the user's first visit. When one group converts far worse than the rest, the problem is narrower than it first looked. A signup step that loses most of its mobile visitors from one paid campaign points to something very different from a step that loses everyone equally.

Kite also reads how the step's conversion rate has moved over time, and how long people take to get through it. A step that has always been weak calls for a different fix from one that fell on a specific date, and a step that converts well but slowly may simply need a reminder rather than a redesign.

Once Kite knows which step loses people, it looks at what those people did instead. It runs a Flows report from the last step they completed, which shows the most common things users did next, including the share who did nothing more at all. That turns "40% of trial users never create a project" into something more specific, such as "most of them opened the integrations page and stopped there."

When session replay is turned on in your project, Kite also reads the replays recorded for a sample of users who dropped out, along with the events that happened during each one. Replays often show what an event list can't, such as a button someone clicked repeatedly or a form field they kept returning to.

Kite compares those patterns with what it knows about your product and your customers. People who repeat the same action usually hit something that doesn't work. People who visit pricing, help, or settings and then leave usually had a question the step didn't answer. People who stop entirely usually met a step that asked for more effort than they were ready to give. Kite names the explanation the evidence supports best, and it says plainly when the evidence is thin.

Kite turns the strongest explanation into a specific change and builds it, and where that change lands depends on the step:

• A page on your website. When users drop out on a pricing, landing, or signup page, Kite rewrites the copy, shortens the form, moves the call to action, or adds the answer people were looking for. It makes the change on a site Kite hosts, through a connected CMS such as Webflow, or in your imported GitHub repository, where it merges into your main branch or opens a pull request when that branch is protected.
• A screen inside your product. When users drop out during onboarding or at an upgrade prompt, Kite writes the new in-app copy and describes the change it recommends to the screen, ready for your team to build.
• A Mixpanel experiment. When the change lives in your product, Kite can set it up as a draft experiment in Mixpanel. It first checks whether your team has already tested something similar, writes the hypothesis, picks the step's conversion as the primary metric, and runs Mixpanel's pre-launch checks, including whether your traffic can reach the sample size the test needs.

Kite posts the change in the conversation with the evidence behind it and the conversion rate it expects to move. Approve it, and Kite publishes the page or launches the experiment.

Kite measures the result with the same funnel it used to find the problem, so the before and after are directly comparable. It saves the funnel to a Mixpanel dashboard with a short note on what changed and when, so anyone on your team who opens the board later can see when the change shipped and what it was meant to move.

After a fair stretch of time, Kite reruns the funnel with the same steps, conversion window, order, and breakdown, and compares the step's conversion rate on each side of the change. When the change ran as an experiment, Kite reads the lift and significance for each version instead, and checks that the traffic split stayed as configured. If the group the step was losing now converts like everyone else, Kite moves on to the next weakest step. If it doesn't, Kite goes back to the flows and replays with a sharper question.

When Kite finishes, you have a clear answer about where your journey leaks, a change already built to fix it, and a place in Mixpanel to keep watching it.