When a stakeholder says "Competitor X has it," the correct response is to spec the underlying job that feature does for the customer, not the feature's UI. Trace the request back to the need it reveals, weigh that need against your own strategy using a framework like Kano or DHM, then write a requirement scoped to the job — not a clone of their screen.
Quick answer: "Competitor X has it" describes a feature, not a need. Extract the customer job or pain behind the request, test it against your differentiation strategy, and spec the requirement in your own product's language — never the rival's implementation.
Sales just lost a deal because the competitor has bulk export. Support is fielding tickets asking why you don't have the dashboard everyone else has. A stakeholder forwards a screenshot with "why don't we have this?" in the subject line. Every one of these moments arrives disguised as a requirement, and every one of them is actually a signal — evidence that a real need exists somewhere underneath the feature request. The job of a PM writing the spec is to find that need before a single line of the PRD gets written.
This matters more than it sounds like it should, because the failure mode is invisible until it compounds. Ship enough competitor-shaped features without examining the need underneath each one, and you end up with a product that matches everyone else's checklist and stands for nothing. This piece is a working method for the moment a "me too" request lands on your desk: how to interrogate it, how to decide whether to build it, and how to spec it so the decision doesn't quietly get overwritten six months later.
Why "Competitor X Has It" Is a Symptom, Not a Requirement
A competitor feature request is symptom-level evidence, not a specification — it tells you that some customer, in some context, needed something, and one vendor's specific implementation is the only shape you've seen it take. Treating the screenshot as the spec skips the one step that actually matters: figuring out what the feature was hired to do.
"Competitor X has bulk export" is not a requirement — it's a clue. The requirement lives one layer down: is the underlying need "I need to get this data into my BI tool," "I need to prove compliance to an auditor," or "I need to hand a clean file to a client"? Each of those produces a genuinely different spec, and only one of them might actually call for a bulk-export button that looks anything like the competitor's.
Three patterns almost always precede this kind of request, and each deserves a different response:
- A sales objection — a prospect said no because of a specific gap. The real question is what outcome the prospect needed, not whether you can check the same box.
- A support escalation — customers are working around a missing capability. The workaround itself is often a better requirements document than the ticket.
- A stakeholder's personal observation — someone saw the competitor's feature and assumed it must be important. This is the weakest signal of the three and the one most likely to be pure feature-matching anxiety.
Treat all three the same way at first: as a lead to investigate, not a line item to schedule. The investigation is what the next two sections cover.
The Parity Trap: How Copying Competitors Quietly Erodes Your Product
Matching a competitor's feature list feels safe because it's defensible in a meeting, but it optimizes for the wrong thing: shipped output instead of customer outcomes. Do this repeatedly and you get a bloated, undifferentiated product where every feature has a plausible reason to exist and almost none of them are why anyone actually chooses you.
Product coach Marty Cagan, in his work with the Silicon Valley Product Group, calls the organizational pattern behind this the feature factory — a team measured on velocity and output parity rather than on whether any given feature moved a customer or business outcome. A roadmap driven by "what did the competitor ship this quarter" is a feature factory's natural output, because it never has to justify a feature against your own strategy — only against someone else's release notes.
The cost shows up later, and it's rarely visible at ship time. Research popularized by the Standish Group, and repeated in various forms across the agile literature since, has long pointed to a startling pattern: a large share of features shipped by software teams go rarely or never used by customers. Feature-matching inflates that number specifically, because parity features are added to close a perceived gap, not because a validated need pulled them out of the backlog.
A feature nobody asked for in your own product's context is technical debt with a UI, whether or not a competitor has one exactly like it.
There's a useful counter-model here from Gibson Biddle, Netflix's former VP of Product, who developed the DHM framework (Delight customers, in ways that are Hard to copy, in ways that enhance your Margin) while running product strategy there.
Run a competitor-inspired request through DHM before you spec it: does matching this feature delight your specific customers, is it hard for competitors to copy back, and does it help your business model — or does it just erase a talking point in a sales deck? Most pure parity features fail at least two of the three.
None of this means ignore competitors. It means competitor awareness is an input to strategy, not a substitute for it — and the distinction shows up entirely in what you do between hearing the request and writing the spec.
A Framework for Turning a Competitor Signal Into a Real Requirement
The fix is a short, repeatable extraction process: name the observed feature, ask what job it's hired to do, validate that job with real customer evidence, then write the requirement in job language instead of feature language. Skipping straight from "they have it" to a ticket is what causes parity bloat in the first place.
This is a direct application of Jobs to Be Done thinking — the idea, most closely associated with Clayton Christensen, that customers don't buy features or even products, they "hire" them to make progress against a specific job in a specific context. Christensen's own go-to example, a fast-food chain's milkshakes hired disproportionately by commuters for a boring, one-handed breakfast, is the model for what you're doing here: looking past the product on the shelf to the job that got it purchased.
Our complete guide to Jobs to Be Done walks through the interviewing method in more depth if this is new to your team.
Work the extraction in five steps:
- Name the feature exactly as observed. No interpretation yet — just what the competitor shipped, screenshot included, so the team is arguing about the same artifact.
- Ask what job the feature is hired to do. State it as "when [situation], I want to [action], so I can [expected outcome]" — the standard JTBD job-statement shape.
- Validate the job with your own customers, not the competitor's marketing page. A handful of interviews or support-ticket patterns usually surfaces whether the job is real for your base and where in their workflow it shows up.
- Map the job onto your customer's actual journey to find where the friction really lives — sometimes the competitor's feature solves step three of a five-step journey, and your product's problem is actually at step one. Our guide to mapping the customer journey is a useful companion exercise here.
- Write the requirement in job language, explicitly decoupled from the competitor's UI. "Users need to reconcile exported data against their existing BI dashboards without manual reformatting" is a spec. "Add bulk export like Competitor X" is not.
Notice what step 3 protects against: a request that sounds universal ("everyone wants this") often turns out to be one loud stakeholder's inference about what customers want. Real validation — even lightweight — is the difference between spec'ing a need and spec'ing an anxiety.
Parity or Differentiation? A Decision Framework
Once the underlying job is validated, the decision isn't "build it" or "don't" — it's where the job sits on a satisfaction curve. The Kano model, developed by quality researcher Noriaki Kano, is the sharpest tool for that call, because it separates features customers merely expect from features that actually delight them.
| Kano category | What it means | Typical response to a competitor feature in this bucket |
|---|---|---|
| Must-be | Absence causes dissatisfaction; presence isn't noticed as a plus | Match it at parity — this is the cost of entry, not a differentiation opportunity |
| Performance | Satisfaction scales linearly with how well it's done | Compete on execution quality, not mere presence — do it measurably better |
| Delighter | Unexpected; absence isn't missed, but presence creates disproportionate loyalty | Don't clone the competitor's version — find your own delighter tied to your strategy |
| Indifferent | Customers don't care either way | Don't build it regardless of who else has it |
| Reverse | Some segment actively dislikes it | Building it because a competitor did could actively cost you customers |
Run the validated job through this table before it goes anywhere near a sprint. A "must-be" gap (say, SSO for an enterprise buyer) genuinely does need parity — no PM should spend a strategy debate defending the absence of table stakes. A "delighter" a competitor already claimed is the opposite case: cloning it now makes you the follower, not the innovator, even if your version ships.
Layer the DHM lens from the previous section on top for anything that isn't a clear must-be: does closing this gap in our way delight our specific customers, resist easy copying, and support the business model? That combination — Kano for where the need sits, DHM for how to respond to it — turns "they have it" into an actual product decision instead of a reflex.
When Parity Is the Right Call
Parity is the correct answer more often than differentiation purists like to admit. If the gap is blocking deals in your core segment, if it's a regulatory or security baseline (data residency, audit logs, SSO), or if it's genuinely a must-be need you validated independently — build it, and build it well. The mistake isn't matching competitors; it's matching them without doing the validation first.
Writing the Spec: From Extracted Need to PRD Requirement
A requirement extracted this way reads differently on the page: it states the customer situation, the job, and the acceptance criteria, with the competitor mentioned only as context in a comment thread, never as the justification in the requirement itself. "Because Competitor X has it" should never appear as a rationale line in a shipped PRD.
In practice, structure the requirement with three parts:
- The trigger context — when and for whom the job shows up (from your JTBD statement).
- The acceptance criteria — what "done" looks like in terms a QA engineer or an eng lead can verify, independent of any other product's implementation.
- The explicit boundary — what this requirement deliberately does not do, especially if the competitor's version does more. This line is what prevents silent scope creep back toward "just build what they built."
If the competitor feature you're responding to is itself AI-powered — a copilot, an auto-summarize, a recommendation panel — resist the urge to spec the model behavior directly. Spec the underlying data and evaluation criteria first; our template for spec'ing AI features covers the extra fields (failure modes, confidence thresholds, human-review paths) a normal feature spec doesn't need.
Almost every "me too" AI feature turns out to hinge on data you may not actually have. Check the requirement against our guide to writing data requirements into a PRD before you commit to a build date.
For the underlying mechanics of turning any validated need into a requirement engineering can actually estimate — not just competitor-driven ones — our PRD writing masterclass for the AI era is the fuller reference.
| Approach | What ships | Differentiation impact | Long-term cost |
|---|---|---|---|
| Copy the competitor's feature as observed | The same surface behavior, roughly | None — you're now a follower on this axis | Ongoing maintenance for a feature you didn't validate |
| Extract the job, then spec your own version | A requirement scoped to your customers' actual context | Neutral to positive — you can out-execute or angle differently | Lower — the feature earns its keep because it's tied to a validated need |
| Ignore the signal entirely | Nothing | Risky if the underlying job turns out to be real and widespread | Deferred cost — you may lose deals or churn customers over a real gap |
The middle row is the target. It costs one extra round of validation up front and, over the life of the feature, tends to cost far less than either extreme.
Keep the Decision From Drifting: Why This Belongs in a Living PRD
A parity decision made carefully in week one doesn't stay made — specs drift as competitors ship again and stakeholders forget the original reasoning. "We decided not to do this" quietly becomes "why haven't we done this" a few quarters later. The fix isn't a stronger decision; it's a document that preserves the decision's history, not just its current state.
This is the practical argument for treating a PRD as a living document rather than a file that gets written once and archived. Our piece on why a living PRD stays always current covers the general case; the competitor-parity scenario is one of the sharpest examples of why it matters, because the reasoning behind a "not now" decision is exactly the kind of context that gets lost first.
Prodinja's Spec Studio is built around this problem directly. It's a living PRD — organized into sections with inline comments — where a proposed change to a requirement (say, someone re-raising the competitor-matching request) shows up as a PR-style diff you can approve or reject, with the original reasoning still attached to the section rather than buried in an old Slack thread.
Readiness gates and an engineering hand-off export are designed to carry that same context forward into build, so "we looked at this and chose not to match it — here's why" survives past the meeting where it was decided.
That traceability is the actual defense against the parity trap. Not a stronger opinion in the moment, but a record that makes the moment findable again.
Key Takeaways
- A competitor feature request is a symptom, not a spec — treat it as a lead to investigate, never a ticket to schedule directly.
- Feature-matching without validation drives feature-factory behavior — output measured against competitors instead of outcomes measured against your own customers.
Jobs to Be Doneextraction turns "they have it" into a validated job statement you can actually design against.- The
Kanomodel tells you whether a job is table stakes (match it), a performance lever (out-execute it), or a delighter (don't clone it — differentiate instead). DHM— delight, hard to copy, margin-enhancing — is a fast filter for whether matching a competitor's move actually serves your strategy.- Write requirements in job language with explicit boundaries, and keep "because a competitor has it" out of the rationale entirely.
- Parity decisions decay over time unless the reasoning behind them is preserved somewhere a future stakeholder will actually find it — which is the core case for a living PRD.
Frequently Asked Questions
How do I say no to a stakeholder who insists we need a competitor's feature?
Bring the extraction, not an opinion: show the job statement you derived from the request, the evidence (or lack of it) from your own customers, and where it lands on Kano. Most pushback softens once the conversation is about validated customer need instead of a screenshot comparison.
Is matching competitors ever the right strategy?
Yes — for must-be requirements like security baselines, compliance certifications, or integrations your buyers simply won't purchase without. The distinction isn't "never match," it's "never match without first validating that the underlying job is real and significant for your own customers."
How is a "me too" feature different from table stakes?
Table stakes are must-be requirements validated as genuinely necessary for your market — their absence actively costs you deals. A "me too" feature is added purely because a competitor shipped it, without that validation step, which is exactly the pattern this piece is arguing against.
Should I mention the competitor by name in the PRD?
Keep the competitor reference in a comment thread or discovery notes, not in the requirement's rationale. The shipped requirement should stand on its own — stated as a customer job and acceptance criteria — so it still makes sense to someone reading it a year later with no memory of which competitor prompted it.
What's the fastest way to validate whether a competitor-inspired request is a real need?
Pull existing support tickets and sales-loss notes for the pattern before scheduling new interviews — the evidence often already exists in-house. If it doesn't, five to eight targeted customer conversations using a Jobs to Be Done script is usually enough to confirm or kill the request.