Scaffold · Guides

How to prioritise feature requests from sales, customers and the CEO

Do not score them on one scale. Agree the product strategy with leadership first, then split development capacity into three buckets: roadmap work ranked strictly by the strategy, technical debt chosen by your most senior engineer, and tactical requests that compete only with each other. When an idea has to wait, the answer is "not right away", not no.

By Cyril Le Roux · Updated 19 November 2026 · 10 min read

Disclosure: Produxity builds Scaffold, which appears below as a worked example. The guide stands without it.

Monday morning, three messages. Sales needs an integration to close a deal before the quarter ends. A large customer has escalated a complaint about a screen that has not changed since launch. The CEO has seen a feature on a competitor's website and wants to know when you will have one. Each request is reasonable. Each one, on its own terms, is urgent. Together they would fill the next three months.

So you open the spreadsheet, score them for reach, impact, confidence and effort, and discover that sales, support and the CEO each weigh those inputs differently. The scoring meeting becomes the argument it was meant to prevent, and the request with the most senior sponsor wins anyway.

Two ways prioritisation fails

Product managers under this kind of pressure tend to swing between two failure modes. The first is prioritising by decibel: whoever shouts loudest, or sits highest, gets their feature. The second is analysis paralysis: more scoring, more data, more meetings, and still no decision anyone will defend. Neither moves the product in a coherent direction.

Both come from the same gap. Requests are hard to push back on when there is no clear direction to push back with. Stakeholders who have not agreed a strategy ask for what makes sense for them now: sales for what closes accounts before the period ends, customer service for the fixes that cut its costs, marketing for something worth a campaign. The product suffers death by a thousand cuts, and the product manager becomes a feature factory worker. In time a line manager steps in to set the direction, with less knowledge of the domain than you have.

A scoring framework does not close that gap. RICE, which Sean McBride described for Intercom, is a sound way to rank items that serve the same goal. It cannot tell you what the goal is. Without one, it launders loudness into numbers.

You can only say no so many times before it becomes career limiting. The strategy has to do the saying for you.

Seven steps, in order

  1. 01Agree the strategy before you rank anythingUnderstand leadership's strategy, even if it is light, then sell your product strategy to them. Without an agreed destination, every request is judged on who asked and how loudly.
  2. 02Split development capacity into three bucketsOne for roadmap work, one for technical debt, one for tactical requests from sales, marketing and customer service. Agree the split with the CEO and CTO before the requests arrive.
  3. 03Rank the roadmap bucket by the strategy aloneEverything in the largest bucket is prioritised strictly by how well it serves the strategy. Who asked for it does not count.
  4. 04Hand the technical-debt bucket to your most senior engineerBrief them on the strategy, then let them choose what to reinforce, so the parts of the product that will carry the next stage are ready for it.
  5. 05Let tactical requests compete only with each otherA request from sales competes with other tactical requests, not with the roadmap. That stops you comparing things whose value and time horizons cannot be compared.
  6. 06Set the mix by the product's stageBefore launch, technical debt should be small and tactical work close to zero. After launch, set roadmap capacity aside for tactical requests.
  7. 07Say "not right away", and show what goes firstPresent the strategy before the roadmap, every time. Then the answer to a request is rarely "no". It is "not right away": these other items get us there faster.

1. Agree the strategy before you rank anything

The first job comes before any ranking: understand the strategy your leadership is following, and accept that it may be light. Then sell your product strategy to them as the product's answer to theirs. Where the company strategy is thin, you may find yours absorbed into it. Either way, once senior stakeholders have understood and accepted it, you have something to judge every request against that is not your own opinion. If you have no product strategy yet, start there: our guide on how to build a product strategy sets out the steps.

2. Split development capacity into three buckets

An agreed strategy will not remove every distraction on its own, which is why it helps to think in buckets. Take your development capacity and split it three ways, agreeing the shares with the CEO and CTO before the requests arrive, not while they are being argued over.

BucketShare of capacityWho prioritises, and howWhat it holds
Roadmap executionThe largest shareThe product manager, strictly by how well each item serves the strategyThe work that moves the product towards its vision
Technical debtAgreed with the CEO or CTO; in Cyril’s experience rarely below 15%, up to 40% for a very distressed productThe most senior engineer, once briefed on the strategyReinforcing the parts of the product that will be load bearing in the next stage
Tactical requestsWhat remains; close to zero before launchThe product manager, comparing each request only with the others in this bucketAsks from sales, marketing and customer service that cannot wait for the roadmap

The buckets solve the problem the spreadsheet could not: comparing things whose value and time horizons are different in kind. A deal this quarter, a sturdier platform next year and a step towards the vision are no longer fighting over one number.

3. Rank the roadmap bucket by the strategy alone

The largest bucket is roadmap execution, and everything in it is prioritised strictly by how well it serves the strategy. Not by who asked, not by how long it has waited, and not by how easy it is. A request from the CEO that serves the strategy well goes near the top; one that does not, waits, and the reason is one the CEO has already agreed to. Scoring models can help here, because inside this bucket everything is aiming at the same goal.

4. Hand the technical-debt bucket to your most senior engineer

At each development cycle, or at regular intervals, a fixed share of effort goes to technical debt. The product manager probably should not prioritise that work at all. Brief the most senior engineer on where the strategy is taking the product, and let them choose, so they reinforce the parts that will be load bearing in the next stage. How big the share should be depends on the state of the stack. In Cyril's experience it should not fall below 15%, and a very distressed product may need up to 40%.

5. Let tactical requests compete only with each other

The third bucket takes the tactical demands from sales, marketing and customer service. Here, who asked does matter: a fix for a large customer about to leave may reasonably beat a nice-to-have for a prospect. What changes is the competition. A request from sales no longer competes with the roadmap; it competes with other tactical requests, and when the bucket is full, sales can help choose which of its own asks goes first.

6. Set the mix by the product's stage

The shares are not fixed for life; they follow the product's lifecycle. Before launch, you would hope technical debt is minimal, and tactical work is close to zero because there are no live customers asking for anything. After launch, everything changes, and you need to set part of the roadmap aside for tactical requests before they take it by force. Review the split when the product changes stage, not when a stakeholder is unhappy with it.

7. Say "not right away", and show what goes first

Present the vision and strategy before the roadmap, every time, so the discussion that follows is about solving the same problem. If the roadmap is challenged because the strategy is, stop and settle the strategy; there is no point arguing about items. With the strategy accepted, pushing back on an idea stops being "this is a bad idea". It becomes "these other ideas will get us to our destination quicker". You are not saying no. You are saying not right away, because something already planned will have a stronger impact.

Why this matters more now

This was always hard. Now that engineers build with AI, the pace has gone up sharply: requests arrive faster, and more of them can be built before anyone asks whether they should be. "Let us launch and see" sounds cheap when code is cheap, but features nobody uses still need maintaining, still clutter the product and still pull it in several directions at once. Faster building makes the filter more valuable, not less.

AI can also give you time back. Keep asking of each task: is this a job for me, or something an AI could take care of? Grouping a few hundred requests by the problem behind them is a good example. Defending the ranking to your CEO is not.

A worked example: from strategy to a prioritised roadmap in Scaffold

Scaffold walks product managers through the research and analysis a strong product decision needs, on their own product, and each activity declares what it builds on. For prioritisation, three of them matter most:

Two limits, said plainly. Scaffold owns the judgement, never the backlog: requests, tickets and sprints stay in whichever tools your team already uses, and the buckets are yours to agree with your CEO and CTO. And it does not make the call for you. You are the one who has to explain the ranking, so you have to believe it.

When this is not your call

In a very early startup whose CEO runs the strategy hands-on, the product manager's job is to execute that strategy faithfully, not to set up a competing one. The buckets still help, because they make the trade-offs visible to the CEO. But the strategy that ranks the roadmap bucket is the CEO's.

In short

  1. Prioritising by decibel and analysis paralysis share a cause: no agreed strategy.
  2. Understand leadership's strategy, then sell yours to them.
  3. Split capacity into roadmap, technical debt and tactical buckets, agreed in advance.
  4. Rank the roadmap by the strategy alone; let the senior engineer rank the debt; let tactical requests compete with each other.
  5. Shift the mix as the product moves from pre-launch to live customers.
  6. Present the strategy before every roadmap, and say "not right away" instead of no.

Look at the last three requests you turned down. Could you have said which bucket each belonged in, and what it would have displaced? If not, agree the buckets before the next one arrives.

Questions product managers ask

Should requests from sales, customers and the CEO all be scored on the same scale?

No. A request that closes a deal this quarter, a fix that cuts support costs and a bet on next year cannot be compared on one number, because their value and their time horizons differ. Split capacity into buckets first, then compare each request only with others in its bucket. One scale just turns the loudest voice into a score.

Is RICE, or another scoring framework, enough to prioritise feature requests?

Not on its own. RICE, from Sean McBride at Intercom, scores reach, impact, confidence and effort, and it is a fair way to rank items that serve the same goal. It cannot tell you what the goal is. Without an agreed strategy, everyone weighs the inputs differently and the score reflects whoever argued hardest. Use it inside a bucket, after the strategy.

How should I handle a feature request from the CEO?

Treat it as a strategic input, not a ticket. Ask which part of the company's strategy it serves and what it would show if it worked. If it fits the agreed strategy, it competes in the roadmap bucket like anything else. If it does not, either the strategy needs revisiting, which is a conversation worth having in its own right, or the request waits.

What do I do when sales says a feature will close a deal?

Put it in the tactical bucket and compare it with the other tactical requests, not with the roadmap. Ask whether it is needed to win the deal or would only speed it up, and whether other customers would use it. If the tactical bucket is full, the trade is between sales requests, and sales can help choose.

Should a request count for more because of who asked for it?

Not in the roadmap bucket. There, an item ranks by how well it serves the strategy, whoever raised it. Who asked matters in the tactical bucket, where a request from a large customer at risk may reasonably beat a smaller one. Mixing the two is how seniority ends up setting the roadmap without anyone deciding that it should.

Should I build a feature that only one customer asked for?

Rarely as asked. One request is a weak signal on its own; look for the problem behind it and whether other customers share that problem. If it serves the strategy, the general version belongs in the roadmap bucket. If it is a one-off for an important account, it competes in the tactical bucket, and it should cost that bucket its full price.

Should product managers prioritise feature requests at all, or problems?

Problems. A feature request is a customer or colleague proposing a solution to a problem they have. Collect the requests, then group them by the problem behind them; five different buttons often turn out to be one workflow that hurts. The strategy then tells you which problems are yours to solve first, and the solution is the team’s to design.

How do I prioritise when sales, support and the founder all weigh things differently?

Stop trying to settle it item by item. The disagreement is not about the items; it is about where the product is going, and no spreadsheet resolves that. Agree the strategy with the founder first, then the buckets. After that, sales and support argue within their own bucket, and the roadmap is ranked against something everyone has already accepted.

How should a small team prioritise new features, bugs and customer feedback together?

Do not put them in one queue. Give each kind of work a share of capacity: roadmap features ranked by the strategy, technical work and serious bugs chosen by your most senior engineer, and customer asks competing with each other. Then the big features you care about are not lost under the day-to-day, and the day-to-day still gets done.

How much development capacity should go to technical debt?

In Cyril's experience, rarely less than 15%, and up to 40% for a very distressed product. Agree the figure with the CEO or CTO rather than fighting for it item by item, and let the most senior engineer prioritise within it once they know the strategy. The right share depends on the state of the stack, not on how busy the roadmap is.

Who should decide what technical debt to fix, product or engineering?

Engineering, inside a share of capacity agreed in advance. The product manager briefs the most senior engineer on the strategy and then stays out of the detail, so they can reinforce the parts of the product that the next stage will lean on. That also ends the stand-off where "we do not have capacity" closes the conversation.

How do I make room to improve existing features instead of always building new ones?

Make improvement a share of capacity rather than a request that must beat every new feature. Customer complaints about existing features belong in the tactical bucket or, if they block the strategy, in the roadmap bucket. Either way they stop competing with the next shiny thing, and you can point to the share when someone asks why it is not all new.

How do I tell a stakeholder that their request will not be built?

Usually you do not have to say never. With the strategy agreed, the honest answer is "not right away": these other items get us to the destination faster. Show where the request sits and what would have to change for it to move up. People take that far better than a flat no, because it is about the destination, not about them.

What do I do when stakeholders change the priorities every week?

Treat it as a sign that nobody has agreed the strategy, because a roadmap with an agreed strategy behind it does not swing weekly. Present the vision and strategy before the next roadmap discussion and settle that first. Then fix the review cadence, so changes are batched and argued against the strategy rather than arriving every Monday.

How often should feature requests be reviewed?

Triage new requests regularly, so nothing sits unread, but change the roadmap on a fixed cadence, such as a monthly or quarterly roadmap review. Between reviews, urgent asks go to the tactical bucket, which exists for exactly that. Re-ranking the roadmap every time someone escalates is how a team ends up starting everything and finishing little.

What should we do with a backlog of hundreds of old requests?

Judge it against the strategy, not by age. Group the requests by the problem behind them, keep the problems the strategy says matter, and archive the rest with a note that they were reviewed. If a request still matters, someone will raise it again. A backlog nobody reads is not a record of demand; it is a list of promises nobody made.

Should the sales team show the roadmap to prospects, with dates?

Show the direction rather than dates. Grouping work into now, next and later keeps the roadmap honest while it changes, and tying each group to the strategy gives sales a story to tell. Dates promised to prospects become commitments, and they turn the tactical bucket into the roadmap through the back door.

How do I push back on stakeholders if I am not the loudest person in the room?

Let the strategy do the pushing. Saying no on your own authority only works so many times before it becomes career limiting, for anyone. Saying "this serves the strategy we agreed less than these other items" does not depend on volume. Prioritising by decibel is a failure of the process, and the cure is a process, not a louder product manager.

Does AI-assisted coding change how feature requests should be prioritised?

It raises the stakes. When building is faster, requests arrive faster and more of them get built, so a product without a filter pulls in more directions at once. "Let us launch and see" is fine as a tactic inside the tactical bucket. It is not a reason to let every idea skip the strategy, and features nobody adopts still cost upkeep.

How should the split change before and after launch?

Before launch, technical debt should be small and tactical work close to zero, because there are no live customers asking for anything. Almost everything goes to the roadmap. After launch everything changes: customers, sales and support start asking, and you need to set part of the roadmap aside for tactical requests before they take it by force.

Where does AI help with prioritisation, and where does it not?

It helps with the reading: grouping hundreds of requests by the problem behind them, summarising feedback, and checking a request against what competitors offer. It does not know your strategy unless you have written it down, and it cannot defend a ranking to your CEO. Check its sources, and never present a priority you could not explain yourself.

How does Scaffold help with prioritising feature requests?

It works upstream of the backlog. Strategic Options lays out three to five strategic directions, compares them on the same evidence and records the one you choose, including what it rules out. Roadmap then builds on 9 earlier activities to generate a prioritised roadmap. Scaffold owns the judgement, never the backlog: requests and tickets stay in your team's own tools.

About the author

Cyril Le Roux teaches Product Focus's flagship product management course and co-authored its AI course. He has been a senior product leader at BT, Photobox, Zoopla and TransferGo, founded Produxity, which builds Scaffold, and is a co-founder of Frntir.ai.

Sources and further reading, read 6 October 2026