Feature Adoption: What It Is, How to Measure It, and Why Shipped Features Go Unused
Guide

Feature Adoption: What It Is, How to Measure It, and Why Shipped Features Go Unused

Felix Macx · · Updated · 12 min read

Feature adoption is the share of your users who find a specific feature, try it, and keep using it. It’s the per-feature version of product adoption, and it’s usually reported as a feature adoption rate — the users of a feature divided by your active users, times 100.

That definition hides the part that matters most. A feature can only be adopted by people who know it exists, and that’s the step most teams never measure. In October 2025 a B2B founder posted on r/SaaS about emailing every customer who’d cancelled the previous month to ask why. About 40% replied, by the founder’s count, and one of the four reasons they gave was this:

“They didn’t know we had a feature they wanted. This was the most painful one. Several users left because we were ‘missing’ a feature that we actually have, but it was buried in our UI.”

It’s one founder’s self-reported story rather than a study, but it’s worth sitting with — customers churned to get something they were already paying for. That isn’t a roadmap problem, and no amount of building fixes it. This guide covers what feature adoption is, how to measure it properly, why shipped features go unnoticed, and what actually raises the number.

Jump to: What feature adoption is · How to measure it · Why shipped features go unnoticed · How to increase it · Where ReleasePad fits

What is feature adoption?

The vendors who write about this mostly agree on the shape of it. Appcues defines feature adoption as “when someone learns about a feature in your product and starts to use the feature regularly.” Pendo’s glossary is drier — it “measures the usage for a software product’s specific features” — and adds the reason anyone cares: every feature a customer pays for and doesn’t use lowers the value they think they’re getting, which is what they weigh when the renewal comes up.

Two distinctions keep the term useful.

Feature adoption vs product adoption. Product adoption asks whether someone has become a regular user of the product at all. Feature adoption zooms in on one capability inside it. A customer can be a daily user of your product and still have never touched the feature you spent last quarter on — which is exactly why the overall usage chart can look healthy while individual features sit idle.

Feature adoption vs feature discovery. Discovery is awareness: the user saw the announcement, noticed the menu item, or read the changelog entry, and now knows the feature exists. Adoption is what comes after — they tried it, it worked, and they came back. Appcues puts discovery “upstream” of adoption, as the top of the funnel. It doesn’t move revenue on its own, but nothing below it can happen without it.

How much of what gets built ends up unused? The most-cited figure comes from Pendo’s 2019 Feature Adoption Report, which analyzed feature usage across 615 Pendo subscriptions and concluded that 80% of features in the average software product are “rarely or never used,” with about 12% of features generating 80% of daily usage volume. Treat it as directional — it’s seven years old, it’s drawn from one vendor’s customer base, and it counts only the features those customers chose to tag — but the direction is hard to argue with.

How to measure feature adoption

There are three layers here, and each one answers a different question: a single rate that tells you how a feature is doing, a funnel that tells you where it’s losing people, and a handful of supporting metrics that tell you how deep the usage goes.

The feature adoption rate formula

The headline metric is the same everywhere you look:

Feature adoption rate (%) = users who used the feature ÷ total active users × 100

Userpilot’s worked example is 200 of 500 monthly active users using a new analytics dashboard, for a monthly feature adoption rate of 40%. Appcues writes the same formula with “total number of product users” underneath.

The formula’s simple, and the two inputs are where teams quietly disagree with themselves:

  • What counts as “used”? Opening the screen isn’t using the feature. Pick the action that means the feature did its job — a report exported, an automation saved, a teammate invited — and count that.
  • Who’s in the denominator? A feature built for account admins will look terrible measured against every seat. Pendo’s advice is to look at adoption at both the user level and the account level, so that people whose role never needed the feature don’t drag the number down.
  • Over what period? Match it to how often the feature should be used. A monthly rate makes sense for invoicing, and it’s far too forgiving for something meant to be used daily.

As for what a good feature adoption rate looks like, Userpilot’s own benchmark report puts the average core feature adoption rate for SaaS products at 24.5%, and the same article immediately warns against leaning on it — a 15% rate can be healthy for an optional power feature and alarming for a core workflow. Appcues goes further and says there’s no universal benchmark at all. I’d side with both of them: the rate you defined as success when you scoped the feature is the only comparison that tells you anything.

The feature adoption funnel

A single rate can’t tell you why it’s low. The model most guides now use for that is the feature adoption funnel, a four-step framework from analytics consultant Justin Butlion, which Appcues and Userpilot both build on:

  1. Exposed — the user reached the place where the feature is presented. Butlion measures it as the percentage of users who viewed the page the feature lives on.
  2. Activated — the user turned the feature on or set it up. If the feature needs no setup, he says to skip this step entirely.
  3. Used — the user used it at least once.
  4. Used again — the user came back and used it more than once.

Each step is a yes/no per user, none of them is tied to a time window, and Butlion’s advice is to always run the funnel against a cohort — say, everyone who signed up in a given month — so you can compare one cohort with the next. (Later versions drift a little: Appcues and Userpilot describe “Used” as more meaningful or more regular engagement than a single use, so settle on your own definition and keep it fixed.)

Here’s how it reads with made-up numbers. Imagine a product with a cohort of 2,000 users and a bulk-export feature that shipped two months ago:

Stage Users From the previous step Of the whole cohort
Exposed 500 — 25%
Activated 300 60% 15%
Used 240 80% 12%
Used again 180 75% 9%

The headline adoption rate is 12%, and on its own that looks like a feature nobody wanted. The funnel says the opposite. Of the people who found bulk export, most set it up, most of those used it, and three in four came back for more. The feature is fine. Seventy-five percent of the cohort has simply never seen it.

That’s the pattern behind the Reddit founder’s churned customers, and it’s the reason the funnel earns its keep — each leak points at a different owner and a different fix:

Where it leaks What it usually means Whose problem it is
Few users exposed Nobody was told, or the feature is buried Announcements and navigation
Exposed, not activated The message didn’t land, setup is confusing, or the feature just isn’t appealing Messaging and first-run UX
Activated, not used Something’s broken or the workflow is too complicated Product and engineering
Used once, not again Users didn’t get value from it The feature itself

The second and fourth rows are close to Butlion’s own reading. His note on the first is blunter — low exposure, he writes, means product marketing needs to “up their game.”

Feature adoption metrics beyond the rate

Once the funnel tells you where to look, a few more feature adoption metrics fill in the picture. Pendo’s glossary groups them into four dimensions:

Metric The question it answers What a bad number suggests
Breadth of adoption How widely has the feature spread across your users, or across the segment it was built for? A discovery problem
Depth of adoption How often do the people who use it actually touch it? The feature isn’t relevant often enough, or it’s hard to use
Time to adopt How long between a user learning about the feature and first using it? Friction between hearing about it and trying it
Duration of adoption Do people keep using it for months, or drop it after the novelty fades? The value isn’t lasting

Breadth is the one to check first when a launch disappoints, and Userpilot’s guide explains why better than I could: low breadth “almost always points to a discovery failure rather than a value problem,” because “users who haven’t found the feature can’t tell you it doesn’t work for them.”

Why shipped features go unnoticed

Here’s the uncomfortable part. Most teams treat low adoption as a verdict on the feature, when the exposure step was never given a fair chance. In my experience the causes are boringly consistent:

  • It shipped quietly. The feature was merged, deployed, and mentioned in a team channel. Nobody outside the company was ever told, because “announce it” wasn’t anyone’s job.
  • It was announced somewhere users aren’t. A changelog page nobody visits unprompted, or an email that arrives while the reader is thinking about something else entirely. By the time they’re back in the product, the message is gone.
  • It was announced once. Whoever signed up the week after launch never saw the announcement, and neither did the customer who only needed the feature six months later.
  • It was written for the team that built it. “Improved performance of the data export module” describes the work. It doesn’t tell a user what they can now do that they couldn’t do yesterday.
  • It’s buried. The Reddit founder’s exact words. A feature three clicks deep in a settings page doesn’t exist for most of your users, whatever the release notes said.
  • It went to everyone. An announcement about team permissions sent to solo accounts teaches those users that your announcements aren’t for them, and they stop reading the next one.

You can usually spot the result without any analytics at all. Support gets asked for things that already exist, feature requests come in for capabilities you shipped last year, and — if you ask, the way that founder did — some cancellation reasons name a “missing” feature that’s sitting right there in the product. One commenter on the thread called it “a marketing and onboarding blindspot screaming to be patched,” and the founder’s own conclusion was that the team had been “stressing about competitors and pricing when our biggest problems were actually our onboarding and feature discovery.”

How to increase feature adoption

Start with the funnel, because the fix depends entirely on where the leak is. There’s no point polishing the onboarding of a feature that 75% of users have never seen, and no point announcing louder when users try the feature once and leave. With that said, exposure is the step that’s most often broken and the cheapest to repair, so that’s where most of this list sits.

1. Announce it inside the product. The best moment to tell someone about a feature is while they’re using your product, because that’s when they can try it in the same minute. An in-app announcement — a what’s-new widget, a banner, a tooltip next to the thing that changed — reaches people in the one place they’ve all chosen to be. Pendo’s 2019 report claims its customers raised the number of features used daily by 25% by deploying at least 25 in-app guides; Pendo sells in-app guides, so weigh that accordingly, but the logic holds up without the number. If you’re deciding how to add one, the build vs buy breakdown for in-app changelog widgets covers the trade-offs.

2. Keep a changelog as the permanent record. In-app messages are fleeting; a changelog entry isn’t. It’s the page support links to when someone asks “can it do X?”, the page a returning user skims to catch up, and the thing a prospect finds when they’re checking whether you’re still shipping. Treating those product updates as a channel in their own right is a separate topic, but for adoption the point is simple — every feature needs one durable, linkable place where it’s explained.

3. Email the releases that deserve it. Email is the only one of the three channels that reaches people who haven’t logged in lately, which makes it the right tool for bigger launches and for a periodic digest. It’s a poor tool for every small fix. The product update email playbook covers cadence and format, and the product announcement examples post has a tier system for deciding which channels a given release has earned.

4. Lead with what the user can now do. “New dashboard filters available” announces your work. “Find any report in two clicks with the new dashboard filters” announces theirs. The same goes for showing it — a short screen recording of the feature in use makes it concrete in a way that three paragraphs don’t. There’s a full guide to this in how to write release notes your users will actually read.

5. Tell the people it’s for. Userpilot’s guide calls this the step most teams skip: segment down to the users who haven’t adopted the feature before you announce it, because broadcasting to everyone “creates noise for people already using the feature and dilutes the message for the people who actually need it.” Even a rough cut helps — admins vs members, or accounts on the plan that includes the feature.

6. Say it more than once, in context. A launch announcement is one exposure for the users who happened to be around that week. The durable version is a prompt at the point of need: a hint beside the export button the first time someone selects fifty rows, a line in onboarding for new accounts, a mention when support answers a related question.

7. Ask the people who leave. The founder’s email was one sentence long — a request for the main reason they cancelled, with no attempt to win them back. It costs nothing, and it surfaces the feature discovery failures that no dashboard will, because a user who never found a feature leaves no usage data behind.

8. Measure again. Record the funnel before you change anything and again a few weeks after. If exposure climbs and “used again” holds steady, you’ve fixed the right thing. If exposure climbs and nothing below it moves, the announcement was never the problem, and it’s time to look at the feature.

Where ReleasePad fits

ReleasePad works on the exposure step and nothing below it, so it’s worth being specific about that. You write an update once — or have it drafted from what you shipped and approve it — and it publishes to an in-app widget with a per-user unread badge and to a public changelog page fed from the same source. On the Pro plan you also get per-post views and unique readers, and you can pass user metadata to the widget to see who read a given post. That tells you whether an announcement was seen.

It won’t tell you whether the feature was then used. For the activated, used, and used-again steps you need a product analytics tool tracking events in your own app, and I’d rather say that plainly than imply a changelog measures adoption. What it does is make sure the top of the funnel isn’t the reason a good feature sits at 12%. There’s a free plan with no time limit, and Pro is a flat $35 a month per product — the details are on the pricing page.

Every feature you ship has two jobs: working, and being found. Most teams put all of their effort into the first one, then read the adoption chart as if it were measuring that. Check the exposure number before you decide what a low rate means — you may already have the feature your next churned customer is about to leave for.

Further Reading

Frequently Asked Questions

What is feature adoption?

Feature adoption is the share of your users who find a specific feature, try it, and keep using it. It's measured per feature rather than for the product as a whole, which is what separates it from product adoption. A user who has only seen an announcement has discovered the feature; a user who comes back to it has adopted it.

How do you calculate feature adoption rate?

Divide the number of users who used the feature in a period by the number of active users in the same period, then multiply by 100. If 200 of your 500 monthly active users used a new dashboard, the monthly feature adoption rate is 40%. Decide up front what counts as 'used' and which users belong in the denominator, because a feature built for admins shouldn't be measured against every seat.

What is a good feature adoption rate?

There's no universal number. Userpilot's benchmark report puts the average core feature adoption rate for SaaS products at 24.5%, but a core workflow feature should sit far above that and an optional power-user feature can be healthy well below it. The useful comparison is your own rate against the target you set when you scoped the feature, and against the same feature last month.

What is the difference between feature adoption and feature discovery?

Feature discovery is awareness: the user knows the feature exists because they saw an announcement, a tooltip, or the menu item. Feature adoption is what happens after that, when they try it and build it into their routine. Discovery sits at the top of the adoption funnel, so a feature nobody discovers can't be adopted no matter how good it is.

What are the main feature adoption metrics?

Start with feature adoption rate, then add the four dimensions Pendo describes: breadth of adoption (how widely the feature has spread across your users), depth (how often they use it), time to adopt (how long between learning about it and first use), and duration (how long they keep using it). A four-stage funnel of exposed, activated, used, and used again shows which of those is the weak point.

How do you increase feature adoption?

Find the leaking funnel stage first, because each one has a different fix. If few users were ever exposed to the feature, announce it where they already are — inside the product, backed by a changelog entry and an email for the bigger releases. If users see it and don't try it, fix the message and the path to first use. If they try it once and never return, the problem is the feature's value rather than its visibility.

feature-adoption feature-discovery product-metrics product-communication churn saas

Ready to put this into practice?

Your changelog shouldn't be an afterthought.

ReleasePad makes it easy to publish great release notes — from a public changelog page to an in-app widget, GitHub integration, and analytics. Free to get started.

Get started — it's free
Try me now!