Here is a number that should stop every product manager, founder, and engineering lead cold: 80 percent.
That is the share of features in the average software product that are rarely or never used, according to Pendo’s landmark 2019 Feature Adoption Report, which analyzed usage data across 615 software subscriptions. The Standish Group, one of the most respected research bodies in software project management, has independently reinforced this finding, reporting that 80 percent of features and functions in enterprise software have low to no value for end users.
Two separate research bodies. The same conclusion. And yet most product teams continue shipping features at the same pace, rewarding velocity over value, and measuring success by what gets launched rather than what actually gets used.
This post explores what the research actually says, why the problem is so persistent despite widespread awareness, what it costs in real dollars and real engineering hours, and what the teams getting it right do differently.
What the Research Actually Says
Before we go further, it is worth understanding the full scope of the evidence, not just the headline number.
The Pendo Feature Adoption Report
Pendo analyzed anonymized product usage data over a three-month period across 615 customer subscriptions to determine how features are actually used in the wild. The conclusion was striking: an average of just 12 percent of features generate 80 percent of average daily usage volume. Meanwhile, 80 percent of features are rarely or never used. These percentages vary only slightly by company size, which gives researchers confidence they represent patterns across the broader software industry.
The financial implications are significant. To extrapolate across all public software companies, Pendo used Gartner’s calculation of combined public cloud revenue, which was forecast at $175.8 billion in 2018. By applying average R&D expense ratios from 54 publicly-traded software companies, Pendo estimated that publicly-traded cloud software companies collectively invested up to $29.5 billion developing features that may rarely or never be used.
Put that in more tangible terms. Using an average US developer salary of around $100,000 as a baseline, a team of 10 developers costs roughly $1 million per year. If only 20 percent of that resource is working on features that actually get used, a company is effectively throwing $800,000 down the drain annually.
The Standish Group Research
The Standish Group has been researching software project outcomes since the early 1990s. Their data offers a complementary breakdown of how feature usage actually distributes across enterprise applications. Their findings show that on average only 7 percent of enterprise application features are “always” used, 13 percent are “often” used, and 16 percent are used “occasionally.” That leaves 64 percent of features in an average enterprise application as either “rarely” or “never” used. In a 2014 follow-up, the Standish Group went further, stating plainly that 80 percent of features and functions across software products have low to no value.
For packaged applications like Microsoft Office, the picture is even starker. Standish found that just five percent of features are used in products like Microsoft Office. Think about that the next time a stakeholder insists your product needs more capabilities.
What the Research Confirms, and What It Does Not
It is worth being precise about what these studies measure. The Pendo data tracks features that product teams believed were important enough to monitor, meaning the actual proportion of wasted development effort across all software is likely even higher when unmeasured features are included. The Standish data focuses on enterprise applications and may not perfectly translate to lean SaaS startups.
What both studies agree on is the direction and magnitude of the problem. The majority of features built into software products do not justify the resources spent building them. This is not a fringe result or a statistical artifact. It is a structural pattern in how software gets made.
Why This Happens: The Real Causes of Feature Overbuilding
The research findings prompt an obvious follow-up question. If product teams know this data, and most do, why do they keep building features that no one uses?
The answer involves a combination of organizational dynamics, psychological pressures, and structural incentives that all point in the same direction, toward shipping more rather than shipping smarter.
The Feature Factory Trap
John Cutler coined the term “feature factory” upon hearing a software development friend complain that he was “just sitting in the factory, cranking out features, and sending them down the line.” Despite all the bad-mouthing the feature factory concept has received since it was first described, ProductPlan’s 2023 State of Product Management Report found that 54 percent of roadmaps are still designed around outputs.
This is the core of the problem. When a roadmap is organized around what gets built rather than what outcomes get achieved, the natural pressure is to fill it with features. Features are visible. They can be demoed to investors. They give sales teams something new to pitch. They show up in release notes. Shipping a feature feels like progress even when it adds complexity without adding value.
Stakeholder and Customer Request Pressure
According to ProductPlan’s 2023 State of Product Management Report, reviewing customer feature requests is the number one source of actionable product ideas for 35 percent of product teams. But when teams do not dig deeper into those requests to identify the underlying problem, they risk jumping on the feature conveyor belt, introducing features with no overarching understanding of why except “our customers asked for it.”
Customer requests are not requirements. They are expressions of pain. A customer who asks for a specific feature is describing their experience of a problem, not necessarily the best solution to it. Teams that treat requests as specifications rather than as signals end up building solutions to symptoms rather than root causes. Many of those solutions never get adopted because they address the literal request without solving the actual problem.
Sales teams compound this by requesting features to close deals, even if those features do not benefit most users. Engineers are then rewarded for launching features rather than for improving adoption. The roadmap gets locked in, leaving no room for iteration or course correction.
The Psychology of Addition
Adding features feels like progress. It feels like growth. It gives the team something to do, the sales team something to pitch, and investors something to point to in their decks. The incentive structures of most software organizations actively reward addition over subtraction. A product manager who kills a feature rarely gets the same recognition as one who ships a new one, even if the deletion creates more user value than the launch did.
There is also a cognitive bias at work. When product teams imagine future users, they tend to imagine users who want everything the product can possibly offer. As one former Atlassian engineer described it: “You’re not building for your existing customers anymore. You’re building for the imagined customer that might come in the future. And that’s when you lose focus.”
The Measurement Gap
Another reason teams focus on outputs and risk becoming feature factories is that it is hard to measure outcomes. When asked if the return on product development investments meets their senior leadership’s expectations, nearly a third of product managers responding to ProductPlan’s survey said “I don’t know.” Based on the low adoption of tools for post-release evaluation, many teams are not measuring return on investment at all.
When you cannot measure whether a feature creates value, the path of least resistance is to measure whether it was delivered. That leads directly to roadmaps full of features that were shipped on time but never used.
What Feature Overbuilding Actually Costs
The dollar figure from the Pendo report is striking, but the true cost of building unused features goes well beyond direct development spend.
Technical Debt Multiplication
Every feature added to a product, whether it gets used or not, must be maintained, tested, updated, and accounted for in future architectural decisions. Every new feature released adds more waste and inefficiency on top of any existing technical debt burden. As the codebase grows more complex and interconnected, developers spend vastly more time understanding existing logic and untangling dependencies before they can add anything new. Simple changes take longer, and major new features can require near-total rearchitecture.
A product with 200 features that 20 percent of users engage with is not just wasteful in the original build. It is actively hostile to future development velocity because every sprint now has to navigate a codebase shaped by 160 features that nobody asked for.
User Experience Degradation
Every new feature is another decision your users have to make, another item in the navigation, another potential source of confusion. Research from the Nielsen Norman Group shows that feature bloat directly correlates with decreased user satisfaction. Design expert Jared Spool describes it as “experience rot,” the inevitable complexity creep and user experience decline that occurs when teams add features without ruthless prioritization.
Users do not experience software as a list of capabilities. They experience it as a cognitive environment they have to navigate. The more options, menus, and settings they encounter, the more effort each interaction requires. Features that nobody uses do not just waste engineering time. They actively harm the people using the product by increasing the cognitive load they face every session.
Opportunity Cost
Perhaps the most underappreciated cost of unused features is the work that never got done because engineering time was allocated to low-value features. Low-impact features do not just waste resources. They actively prevent you from building high-impact ones.
Every sprint filled with features that end up in the 80 percent unused category is a sprint not spent improving the 20 percent of features that drive 80 percent of user value. The compounding effect of this misallocation over two or three years of product development is a product that is dramatically weaker than it could have been, surrounded by complexity that makes it harder to improve.
The Industries and Companies Most Affected
Feature overbuilding is not uniform across all software categories. It tends to be most severe in specific organizational contexts.
Enterprise software products face the sharpest challenge. Enterprise applications consistently show the highest concentration of unused features, with the Standish data showing that only 36 percent of features across the average enterprise application are used with any regularity. Enterprise products often accumulate features over years because they are built to satisfy procurement requirements, compliance checklists, and the preferences of powerful buyers rather than the daily workflows of actual users.
B2B SaaS companies with active sales-led growth models are also particularly vulnerable. When a sales team can close a large deal by promising a feature, the pressure on product to deliver is enormous, even if that feature will only ever be used by the one customer who requested it.
According to ProductPlan’s 2023 State of Product Management Report, customer feature requests are the top source of actionable product ideas for 35 percent of respondents. Feedback from sales and support is the source for 26 percent, and competition inspires new features for 16 percent of respondents. When this is the pipeline, and it is for most B2B teams, the resulting roadmap reflects the loudest voices rather than the deepest needs.
What High-Performing Product Teams Do Differently
The most effective product teams are not necessarily smarter or better resourced than the ones building unused features. They operate with different frameworks, different incentive structures, and different definitions of progress.
They Solve Problems, Not Feature Requests
Great product teams know when to act, when to defer, and when to let go, because every “yes” has a cost. Customers are not counting how many new bells and whistles a product adds. They just want it to do what they need it to do.
The shift from building features to solving problems sounds semantic but it changes everything about how a roadmap gets built. When the question is “what problem does this solve and for how many users?” rather than “what should we build next quarter?”, the filtering that happens before development begins eliminates a large portion of the features that would otherwise end up in the 80 percent unused bucket.
They Validate Before They Build
To boost effectiveness, product teams need to refresh the processes that define which features they work on, identify and resolve friction points with their existing features, and verify assumptions before developing new ones.
The teams with the lowest rates of unused feature development use rapid experimentation, user interviews, prototype testing, and behavioral analytics to validate assumptions before committing engineering resources. They treat new feature ideas as hypotheses to be tested, not work orders to be executed.
They Measure Adoption, Not Just Shipment
Pendo’s research found that after their first year of using product analytics to improve their products, customers experienced a 50 percent increase in daily feature use. The percent of unused features declined by nearly 25 percent during that time.
The causal mechanism is straightforward: when teams can see exactly which features are being used and which are being ignored, they make different decisions. They invest in improving adoption of high-value features rather than layering new ones on top of unengaged existing ones. They sunset features that consistently show low usage instead of maintaining them indefinitely.
They Prioritize with Frameworks, Not Instinct
Structured prioritization frameworks transform what would otherwise be subjective debates into data-grounded decisions. Frameworks like MoSCoW and RICE help prevent feature bloat by introducing consistent criteria for evaluating which ideas are worth building. The key is to use transparent criteria to evaluate and rank features, and to involve stakeholders and users in the process.
The RICE framework, which scores features based on Reach, Impact, Confidence, and Effort, forces product teams to explicitly estimate both the value of a feature and the cost of building it before committing. Features that score well on impact but low on reach, meaning they serve a narrow slice of users, get deprioritized rather than built on the strength of one loud stakeholder’s request.
They Celebrate What They Do Not Build
The best product teams are disciplined about what they say no to. Building cultures where “we decided not to build that” is celebrated as much as “we shipped this new feature” is the real mark of product maturity.
Saying no to a feature request requires confidence and clarity. It requires a well-articulated product strategy that allows product managers to explain why a given request does not belong in the roadmap, not because it is a bad idea in isolation, but because it is not the right investment for this product at this stage. Teams that have that clarity say no more often, build less, and end up with products that are better used.
Practical Steps to Reduce Unused Feature Development
If your team recognizes itself in the research above, the solution is not to stop building. It is to build with more discipline and more feedback.
Start by auditing your existing feature set. Use behavioral analytics tools to map actual usage against your current feature inventory. Identify which features fall into the rarely or never used category, and ask honestly whether they should remain in the product, whether they need better onboarding to drive adoption, or whether they should be sunset entirely.
Before committing any feature to a sprint, require a documented problem statement that answers who experiences this problem, how frequently it occurs, and what the measurable outcome of solving it would be. Features that cannot clear this bar before development begins are unlikely to clear it after.
Build adoption review cycles into your release process. Every feature shipped should have a usage review at 30, 60, and 90 days post-launch. If adoption is not progressing toward expectations, treat that as a product signal requiring a response, either through improved onboarding, a feature redesign, or a decision to stop investing in that direction.
Connect your team to the right technology partners who share this outcome-focused philosophy. Whether you are looking for top software development companies who practice lean and agile methodologies, software testing companies who can help you validate user behavior before full development commits, or software outsourcing partners who can staff dedicated discovery and validation capabilities, the quality of your technology partnerships directly shapes your ability to build less and deliver more.
The Broader Pattern: Outputs Versus Outcomes
The unused feature problem is ultimately a symptom of a deeper organizational misalignment. When product teams are held accountable for what they ship rather than for the outcomes their users experience, the result is predictable. The roadmap fills with features. Most of them never get used. The product grows in complexity while shrinking in clarity.
The key distinction between empowered and feature-driven product teams comes down to how work is allocated. Are leaders giving teams solutions to build, or problems to solve? Empowered teams are given problems and the latitude to find the best solution, rooted in the belief that the team closest to the customer is best positioned to solve the problem.
The research from Pendo and the Standish Group does not reveal a failure of engineering talent or product intelligence. It reveals a failure of organizational structure and incentive design. The teams building features that nobody uses are not stupid. They are responding rationally to the pressures placed on them.
Changing that requires leadership that explicitly rewards outcome-focused thinking, product processes that create space for discovery before development, and a shared understanding that the goal of a product roadmap is not to describe everything that will be built, but to communicate the problems that will be solved.
Finding the Right Development Partner Changes What Gets Built
One underappreciated lever for reducing unused feature development is the quality of the software development partner you choose to work with. Development agencies that operate with lean principles, continuous discovery practices, and outcome-focused sprint planning actively resist the feature factory dynamic from the outside. They ask the questions that internal stakeholder pressure often suppresses: who is this for, what problem does it solve, and how will we know if it worked?
If you are evaluating software development partners to help your team build products that actually get used, Suggestron’s verified directory connects you with agencies across every major technology category. Explore top AI development companies for teams building intelligent, adaptive product experiences, browse mobile app development companies that understand lean product validation, or find software outsourcing partners with proven records of outcome-oriented delivery. Every listing on Suggestron includes verified client reviews so you can see how agencies actually perform, not just how they present themselves.
The 80 percent problem is not inevitable. It is the result of systems that reward the wrong things. With the right frameworks, the right metrics, and the right development partners, product teams can close the gap between what gets built and what actually creates value.