How to Deduplicate and Merge Feature Requests With AI (2026)

An 8-step method to deduplicate and merge feature requests, keep every requester, and rank by distinct accounts and revenue instead of votes.

Your feature request board has 900 entries. 'SSO', 'SAML login' and 'Okta support' are three separate cards. Each has a modest vote count, and none reaches the top ten. The counts tell you little because demand for one need is split across cards that differ only in wording. This guide from the BuildBetter team covers four things: an 8-step method to deduplicate and merge feature requests using only a spreadsheet, a worked example that reduces 900 requests to 210, rules for telling a duplicate from a variant, and a clear threshold for when AI tooling is worth adding.

What Does It Mean to Deduplicate and Merge Feature Requests?

Deduplicating feature requests means finding requests that describe the same underlying customer need, however they are worded. Merging means combining them into one canonical request that keeps every requester, account, quote and source. These two steps produce a list you can prioritize honestly.

Feature request board cleanup involves three separate operations:

  • Deduplication finds matches. It answers the question 'are these the same need?'
  • Merging combines true duplicates into one record, the canonical feature request, without losing who asked or why.
  • Linking connects requests that are related but meaningfully different in scope, user or effort. Each linked request keeps its own record.

Most teams do the first step and lose data in the second. They spot that three cards are the same, click merge, and the requester list, comments or vote history disappear or get double-counted. The third operation is often skipped entirely, so different needs get flattened into one vague card.

The goal is one list where each row is a distinct customer need, counted by distinct accounts and revenue rather than raw votes. That list supports roadmap decisions. The fragmented board does not.

AI fits into one step. Semantic matching groups requests by meaning instead of keywords, so it speeds up grouping. The method underneath stays the same, and you can run it by hand.

Why Feature Request Deduplication Is Hard

Duplicate feature requests are a structural problem, not a sign of a sloppy team. Research on bug trackers in large open-source projects such as Firefox and Eclipse found that duplicate reports make up a large, persistent share of submissions (Anvik, Hiew & Murphy, 2005; Jalbert & Weimer, 2008). Feature requests duplicate for the same reasons, plus a few of their own:

  • Customers describe solutions, not problems. 'Okta support' and 'SAML login' are two proposed solutions to one job: 'let our IT team control who signs in.' Keyword search cannot see that. Fuzzy string matching catches 'SSO login' versus 'SSO log-in', but it will never match 'Okta' to 'SAML'.
  • The same need arrives through different channels with different vocabularies. It comes in through the public board, support tickets, sales call notes, CS notes, account-team Slack threads and survey verbatims. Sales says 'enterprise auth.' Support says 'login issue.' Customers say 'Okta.'
  • Near-duplicates hide real differences. 'Export to CSV' and 'scheduled CSV export to S3' share words, but they solve different jobs and need different engineering effort. Merging them hides the harder request inside the easier one.
  • Merging is destructive in most board tools. Requester lists, comments and vote history can be lost or double-counted. Teams learn to avoid merging, and the board keeps growing.
  • Nobody owns the rule. Without a written intake rule, every PM, CSM and AE logs requests their own way. Duplicates return within weeks of a cleanup.

Formally, this is a case of record linkage, also called entity resolution: finding records that refer to the same real-world thing. Statisticians have studied it since the Fellegi–Sunter model in 1969. In this case the 'entity' is a customer need instead of a person or address, which makes the matching harder.

Why Do Duplicate Feature Requests Distort Prioritization?

Duplicates split demand for one need across several entries, so each entry looks smaller than the real need. A popular request phrased one consistent way can outrank a more important need described seven different ways. If you prioritize on fragmented counts, you are ranking by vocabulary, not demand.

Three mechanisms cause the distortion:

Mechanism 1: Split counts

Seven variants with 5 to 22 votes each never reach the top 10, even though together they form the second-largest need on the board. Each card looks like a niche ask, and none of them gets discussed.

Mechanism 2: Double counting

If one account votes on three variants and you add the votes together, that account counts three times. Merging without deduplicating accounts overstates demand, and the error is hard to spot later.

Mechanism 3: Channel bias

Board votes over-represent self-serve users, who have the time and incentive to click upvote. Requests raised in sales calls and support tickets often never reach the board, so high-revenue needs get undercounted.

The consequences are predictable. Roadmap debates stall over whose count is right. Requesters hear 'not enough demand' for things many customers asked for. Building on a bad signal is expensive. In Microsoft's experimentation program, only about a third of tested ideas improved the metric they targeted (Kohavi et al., 2009). If even well-reasoned ideas fail that often, the demand data feeding the roadmap has to be accurate.

The Method: How to Deduplicate and Merge Feature Requests in 8 Steps

This method works with a spreadsheet and no budget, and a team can start it today. It does not require any specific tool. Each step adds a column or a tab, so you can always trace a decision back to its source.

Step 1: Export everything into one sheet

Pull every request from the board, ticket tags, CRM notes, call notes and Slack. Use one row per request per requester, with these columns:

  • Request text (original, untouched)
  • Requester and account
  • Account ARR or plan
  • Source channel
  • Date
  • Link to original
  • Current votes

Step 2: Normalize the wording

Add a 'normalized' column. In it:

  • Lowercase the text.
  • Strip filler such as 'it would be great if.'
  • Expand acronyms (SSO = single sign-on).
  • Replace product nouns with your own internal names.

Keep the original text in its own column and never overwrite it. Normalized text is for matching. Original quotes are the evidence engineering and design will ask for.

Step 3: Write the job, not the solution

Add a 'job statement' column in the form 'When [situation], I need to [outcome].' This is the jobs-to-be-done framing, and it is the step that makes vendor-name duplicates collapse. Teresa Torres makes the same distinction in Continuous Discovery Habits between opportunities (needs) and solutions. For example, 'Okta support', 'SAML login' and 'force SSO for all users' all become: 'IT needs to control who can sign in from one identity provider.'

Step 4: Group by job

Sort by job statement and assign a cluster ID. Use the duplicate test in the section below to decide what belongs together. You can also paste batches of 50–100 normalized rows into any general-purpose AI assistant and ask it to propose job groupings. A human confirms every merge.

Step 5: Create the canonical request

Give each canonical request:

  • One title written as the job
  • A short problem statement
  • Links to every merged row

Never delete the originals. Mark each one 'merged into #ID.'

Step 6: Keep meaningful near-duplicates as linked variants

Some requests share the job but differ in scope, effort or user. SCIM provisioning versus SSO sign-in is a common example. These get their own record, linked to the parent. Linking keeps the distinction without fragmenting demand.

Step 7: Recount by distinct accounts and revenue, not votes

Within each cluster:

  1. Remove duplicate accounts.
  2. Sum ARR.
  3. Count open opportunities.

This is the number you rank on. For the scoring model itself, see our guide on how to prioritize feature requests by revenue.

Step 8: Set the intake rule and close the loop

Write the intake rule down:

  • Before anyone logs a request, they search canonical titles and job statements first.
  • If a match exists, they add themselves as a requester instead of creating a new card.
  • One named owner runs weekly triage.

When the canonical request ships, notify every requester on the merged list. Our guide on closing the loop with customers when you ship a feature covers the messaging.

Use this template for every canonical record:

FieldWhat goes in it
Canonical IDStable ID, e.g. FR-0142
Job-statement title'IT controls sign-in through our identity provider'
Problem statement2–3 sentences on the situation and outcome
Merged request IDsEvery original row or card marked 'merged into'
Linked variantsRelated records with different scope or effort
Distinct accountsDeduplicated account count
Total ARRSum of ARR across distinct accounts
Open opportunitiesDeals where the need was raised
SourcesBoard, tickets, calls, CS notes, Slack, surveys
Representative quotes3–5 verbatim quotes with source links
StatusOpen, planned, in progress, shipped, declined
OwnerOne named PM
Decline reasonRequired if status is declined

Worked Example: 900 Feature Requests Collapsed to 210

This is an illustrative scenario for a hypothetical B2B SaaS company, not a customer case study. The numbers are realistic but invented, to show how each decision changes the ranking.

The team starts with 900 board entries, then exports requests from ticket tags and sales call notes into the same sheet. After normalizing and writing job statements, the 900 reduce like this:

  • About 120 were exact or near-verbatim duplicates.
  • About 480 were merged by shared job.
  • About 90 were reclassified as bugs, support questions or out of scope.
  • 210 canonical requests remain, and 34 of them carry linked variants.

The SSO cluster, decision by decision

Seven variants were scattered across the board:

  • 'SSO' (22 votes)
  • 'SAML login' (18)
  • 'Okta support' (15)
  • 'Azure AD sign-in' (12)
  • 'Google Workspace SSO' (9)
  • 'Enforce SSO for all users' (7)
  • 'SCIM provisioning' (5)

The highest single variant ranked #14.

Decision 1: Merge the six sign-in variants. They become one canonical request: 'IT controls sign-in through our identity provider.' One release would let the team tell all six sets of requesters it's done.

Decision 2: Keep SCIM provisioning as a linked variant. Automated user lifecycle (creating and removing accounts when people join or leave) is a different job with different effort. It stays linked so the team sees the full identity picture, but it is scoped separately.

Decision 3: Do not sum the 83 votes. After removing accounts that voted on more than one variant, the cluster represents 51 distinct accounts. The call notes add 6 open opportunities that raised SSO in sales conversations and never touched the board.

Result: Ranked by distinct accounts and ARR, the SSO cluster moves from #14 to #2.

Rank (before → after)Canonical requestRaw votesDistinct accountsARR bandSources
#3 → #1Bulk edit records across a filtered view4841$1M–$2MBoard, tickets, CS notes
#14 → #2IT controls sign-in through our identity provider83 across 6 variants (audit only)51$2M+Board, sales calls, tickets
#2 → #4Managers get a scheduled summary report5238$500K–$1MBoard, surveys
#1 → #9Dark mode6458Under $250KBoard
Not ranked → linked variantSCIM provisioning (linked to SSO)55$500K–$1MBoard, sales calls

Counter-example: dark mode. It stays high on raw votes (64) and distinct accounts, but it falls when ranked by revenue because most voters are on the free tier. This is a judgment call, not an automatic demotion. If free-to-paid conversion is a strategic goal this year, dark mode may still earn its slot. The recount gives the team the information. It does not make the decision for them.

How Do You Tell a Duplicate From a Different Request?

Two requests are duplicates if they describe the same job for the same user, and one shipped solution would satisfy both requesters. If they need different solutions, serve different users or differ substantially in effort, they are different requests. Link them instead of merging.

QuestionDuplicate (merge)Variant (link)Different (keep separate)
Same job?YesYes, or closely relatedNo
Same user?YesOften different (admin vs. end user)Not necessarily
Same solution satisfies both?YesNoNo
Similar effort?YesNoIrrelevant
Example pair'Okta support' + 'SAML login''SSO sign-in' + 'SCIM provisioning''Export to CSV for reporting' + 'Export all data for migration'

Run the 'would one release close both?' test. Picture shipping X. Would you notify both requesters that their request is done? If yes, they are duplicates. If one of them would reply 'that's not what I meant,' they are not.

Watch for two traps:

  • False friends share keywords but have different jobs. 'Export' for weekly reporting and 'export' for leaving the product are different needs with different stakeholders. Semantic matching can also score these as highly similar, which is why a person reviews merges.
  • Hidden twins use different words for the same job. 'Okta' and 'SAML' share no characters, but they describe the same need.

When unsure, link rather than merge. Linking is reversible and keeps the distinction. Unmerging a bad merge means rebuilding requester lists by hand.

Should You Merge Votes When You Merge Requests?

Merge the voters, not the vote totals. Combine requester lists, remove duplicate people and accounts, and report distinct accounts as the demand figure. Adding raw votes from each variant double-counts customers who voted more than once.

Four rules keep feature request vote counts honest:

  • Keep per-variant counts for audit only. Store the original votes on each merged item inside the canonical record so anyone can check the math. Don't rank on them.
  • Weight by account, not by user. Ten users from one account are one account's demand. Note the breadth in context, since ten users can signal deep adoption, but count the account once.
  • Add the demand that never got a vote. Requests from tickets, sales calls and CS notes count as requesters even though nobody clicked upvote. They are often the highest-revenue signal you have.
  • Report three numbers together: distinct accounts, total ARR and open opportunities. Any one of them alone can mislead.

How Do You Keep the Requester List After Merging?

Never delete merged requests. Mark each one 'merged into #ID' and copy every requester, account, quote and source link into the canonical record. The canonical request should contain everyone who asked, so you can notify all of them when it ships.

The practical setup:

  • Use a 'requesters' tab with one row per requester per canonical request: name, email, account, source, date and original quote.
  • Keep the original wording as quotes. Engineering and design will want the customer's actual words, and the specific phrasing often reveals the job better than your summary does.
  • Check your board tool before merging. Some tools transfer voters and comments when you merge. Others drop them. If you aren't sure, export first.
  • Record the merge date and who merged. Mistaken merges happen. A merge log makes them easy to undo.

Common Mistakes When Merging Feature Requests

Most failed cleanups fail in predictable ways, and several of the causes are process problems no software fixes.

  • Grouping by proposed solution instead of job. The SSO need stays split across vendor names.
  • Over-merging. Meaningful variants get collapsed into one vague mega-request such as 'better integrations' that nobody can scope or ship. AI clustering makes this worse if nobody reviews the groups.
  • Summing votes after a merge. Demand is overstated, and trust in the list erodes once someone notices.
  • Deleting merged items. Requesters are lost, so you cannot close the loop.
  • Counting only the public board. Sales calls and tickets, where high-revenue requests surface, get ignored.
  • Doing a one-time cleanup with no intake rule. Duplicates return within a quarter.
  • Treating a merged count as a decision. No dedupe method or tool decides what to build. Strategy, effort and fit still need a human call.
  • Closing the loop only on shipped requests. Declined requests need a recorded reason and a reply too.

Be direct about the last group. Having no triage owner, never writing decline reasons, and letting one loud executive override account-level counts are organizational choices. A better tool will not correct them.

When Do You Need AI Tooling to Deduplicate Feature Requests?

Manual merging works for a few hundred requests a year from one or two channels. Once sales calls, tickets and CS notes add requests daily, the spreadsheet falls behind. At that point you need semantic matching across channels to keep up.

Signs you have crossed the threshold:

  • Weekly triage cannot finish.
  • Sales, support and CS log the same need in the same week, in three places.
  • Requests live in call recordings nobody re-reads.
  • Answering 'which accounts asked for this?' takes a day of digging.

What AI changes: it groups by meaning rather than keywords, matches requests across channels and attaches account data automatically. Embedding-based matching makes this cheap. The Sentence-BERT paper (Reimers & Gurevych, 2019) cut the time to find the most similar pair among 10,000 sentences from about 65 hours to about 5 seconds.

What AI does not change: someone still reviews merges, owns the intake rule and makes the priority call. Before you automate, calibrate. Hand-label a sample of request pairs as duplicate, variant or different, then check what the tool gets wrong.

1. BuildBetter Signals — Best for Cross-Channel Feature Request Deduplication

BuildBetter Signals captures and consolidates feature requests from sales calls, support tickets and CS notes, then detects duplicates using semantic matching, cross-channel correlation and use-case similarity. It automates the parts of the method that stop scaling in a spreadsheet.

Here is how it maps to the 8 steps:

  • Steps 1–2 (capture and backfill): 35+ signal types are detected across calls, tickets, Slack, CRM and surveys without manual tagging. These include feature request, bug, complaint and objection. CSV import of up to 100MB or 100,000 records per file lets you load your existing board export.
  • Steps 3–4 (group by job): Clusters group similar signals by meaning, update as new feedback arrives, and flag rising and declining themes. A 4-level taxonomy (Domain, Product, Feature, Tag) organizes the result.
  • Step 7 (recount by revenue): Signals inherit Salesforce and HubSpot properties. You can filter clusters by account, opportunity, deal stage or any custom CRM field.
  • Step 8 (act and close the loop): Stakeholder tracking records who wants what. Requesters are notified when features ship. One-click Jira and Linear issues carry the original quote, customer info and source link. One example workflow: 'Feature mentioned 5+ times → auto-create feature request with all evidence.'
'Citations in reports are critical for us. They build trust and prove accuracy.' — Juan Canal, Head of Product, Rappi

That point applies directly to merged requests. Every canonical record should still point back to the call, ticket or thread it came from.

A caveat: Clusters need at least 3 similar signals to form and work best with 100+ signals. A team with a small, single-channel backlog will get as much from the spreadsheet method.

2. DIY: Spreadsheet Plus a General-Purpose AI Assistant

The DIY option is the 8-step sheet plus a general-purpose AI assistant or a simple embeddings script to propose groupings, with a human approving every merge. It costs nothing and is a good way to calibrate your duplicate rules. The trade-offs are no cross-channel capture, no CRM sync and manual upkeep every week.

OptionCross-channel captureSemantic groupingRevenue recountCloses the loopBest fit
BuildBetter SignalsCalls, tickets, Slack, CRM, surveysYes, continuously updatedYes, via Salesforce/HubSpot propertiesYes, requester notificationDaily requests from multiple channels
DIY spreadsheet + AI assistantManual exportBatch, on requestManual lookupManualA few hundred requests a year, one or two channels

FAQ: Deduplicating and Merging Feature Requests

Can AI deduplicate feature requests automatically?

AI can reliably propose duplicates by matching requests on meaning rather than keywords, including across channels like calls, tickets and boards. A person should still approve merges, because AI can over-merge requests that share a topic but differ in scope, user or effort.

What is the difference between a duplicate and a cluster?

A duplicate is a request for the same job that one release would satisfy. A cluster is a broader group of related requests that may contain several distinct canonical requests and linked variants. For example, an 'identity and access' cluster might hold both SSO sign-in and SCIM provisioning.

Do you lose data when you merge feature requests?

Only if you delete the originals or your tool fails to transfer voters and comments. Mark merged items 'merged into #ID', copy every requester, quote and source link into the canonical record, and export before merging in any board tool.

Should you add up votes when you merge requests?

No. Merge the voter lists, remove duplicate people and accounts, and report distinct accounts (plus ARR and open opportunities) as the demand figure. Keep per-variant vote counts for audit only.

How should you title a canonical feature request?

Title it as the customer job, not a vendor or solution. For example, use 'IT controls sign-in through our identity provider' rather than 'Okta support', so future variants are recognized as duplicates during intake.

How often should you deduplicate feature requests?

Run a weekly triage pass that checks new requests against canonical titles, plus a full review each quarter. A one-time cleanup without an intake rule reverts within months.

How many feature requests before manual deduplication stops working?

Manual merging holds up for a few hundred requests a year from one or two channels. When requests arrive daily from sales calls, tickets and CS notes, semantic matching becomes necessary.

Sources and Further Reading

Turn 900 Fragmented Requests Into One List You Can Trust

The method above will get your board under control with a spreadsheet. When requests arrive daily from calls, tickets, Slack and CS notes, BuildBetter does the capture, semantic grouping and revenue recount automatically. Every merged request keeps the original quote and source, and every requester hears back when you ship.

Make churn optional. Book a demo to see BuildBetter Signals on your own feedback.