Agile & Project Management
Product Owner and Backlog Management: Value, Stories and Ordering
Intermediate8 min readUpdated
A product backlog is not a to-do list; it is an ordered argument about what is worth building next. This guide covers the product owner accountability, writing items that survive contact with a team, continuous refinement, four ordering techniques compared, splitting large items, and roadmaps that stay honest as things change.
What you will learn
- Explain value maximisation as an accountability and what it requires from the organisation
- Write user stories and acceptance criteria that pass the INVEST test
- Run refinement as a continuous activity rather than a scheduled meeting
- Apply WSJF, MoSCoW, Kano and value-versus-effort to order a backlog and know their limits
- Split a large item into thin vertical slices that each deliver something
The hardest part of building software is not building it. It is deciding what to build, in what order, and what to leave out — and doing that repeatedly as the market, the users and the technical reality all move. That decision is what the product owner accountability exists to hold, and a product backlog is simply the current written form of the answer.
Most backlogs fail as answers. They accumulate every request anyone ever made, are ordered by whoever complained most recently, and contain items so vague that the team must guess. This guide is about making the backlog do useful work: what the accountability actually requires, how to write items worth building, how to keep the list refined, and how to order it defensibly. The Scrum framework guide covers the events that consume the backlog; here we look at what feeds them.
Value maximisation is an accountability, not a task list
The framework says the product owner is accountable for maximising the value of the product resulting from the team's work. Two words in that sentence carry the weight. Maximising implies choosing between options with a real cost of being wrong, which means a product owner must be able to say no, publicly and often. Accountable implies the organisation actually respects the decisions — if a director can reorder the backlog by walking into the team room, the accountability is nominal.
Three things make the accountability workable in practice. The first is a product vision: a short statement of who the product serves, what problem it solves for them, and why it is different. The second is a product goal: the next meaningful objective on the way there, concrete enough that you can tell when it is met, and stable for longer than a sprint. The third is evidence: usage data, support volume, revenue, interviews, experiments — anything that turns an ordering argument from a contest of opinions into a discussion of measurements.
A product owner without vision produces a backlog with no shape. A product owner without evidence produces one ordered by seniority.
Writing items that survive contact with a team
The user story format — as a <user>, I want <capability>, so that <benefit> — is a convention, not a rule from any framework. Its value is entirely in the third clause: it forces the author to state a reason, and a story whose "so that" is empty or circular usually should not be built. The format is a placeholder for a conversation, not a specification, which is why an item that has never been discussed with the team is not ready regardless of how well it is written.
The INVEST checklist is the usual quality test for an item.
| Letter | Property | What it rules out |
|---|---|---|
| Independent | Can be built without waiting for another item | Chains where item four is useless until items one to three ship |
| Negotiable | The details are open to discussion | A pre-written solution with no room for the team's input |
| Valuable | Delivers something a user or the business can perceive | "Create the database table" as a standalone item |
| Estimable | The team understands it well enough to size it | Items whose scope depends on unanswered research |
| Small | Fits comfortably inside one sprint | Epics disguised as stories |
| Testable | You can state how you would know it works | "Improve performance" with no number |
Acceptance criteria turn the last property into something concrete. They should describe observable behaviour, including the unhappy paths, and they belong to the item rather than to a separate test document. A scenario style — given a starting state, when something happens, then this is observable — reads naturally and maps directly onto automated tests, which is the bridge that BDD with Cucumber formalises. Keep them to a handful; twenty criteria on one item is a signal to split it.
Note the distinction from the definition of done. Acceptance criteria are specific to one item and answer "did we build the right thing"; the definition of done applies to every item and answers "did we build it properly". Confusing the two produces items that pass their criteria and still cannot be released.
Refinement as a continuous activity
Refinement is the ongoing work of adding detail, estimates and order to backlog items so that the top of the list is always ready to be selected. The framework describes it as an ongoing activity rather than an event, which matters: teams that treat it as a single ninety-minute meeting per sprint tend to arrive at planning with items nobody has thought about.
What refinement produces is a ready top of backlog. A workable definition of ready is that the item has been discussed with the developers, has acceptance criteria, has no unresolved external dependency, is small enough to finish in a sprint, and has an estimate the team is comfortable with. Two or three sprints' worth of such items is enough; refining further ahead is waste, because the ordering below that will change before you get there.
Useful habits: keep refinement to roughly five to ten per cent of the team's time; refine as a whole team so that testers and operations people spot problems early; timebox each item and park anything that runs long for a separate investigation; and split as you refine rather than at planning, when there is no time to think.
Ordering the backlog
Ordering is the product owner's most consequential act, and no single technique is correct for every situation.
Value versus effort. Plot each item on two axes and take the high-value, low-effort quadrant first. It is crude and it is usually enough, especially for a small backlog where everyone shares context.
WSJF — weighted shortest job first. A scoring model popularised by scaling frameworks. You estimate the cost of delay as the sum of three relative scores — user or business value, time criticality, and risk reduction or opportunity enablement — and divide by the job size. A worked comparison:
| Item | Value | Time criticality | Risk/opportunity | Cost of delay | Size | WSJF |
|---|---|---|---|---|---|---|
| Regulatory reporting change | 8 | 13 | 3 | 24 | 5 | 4.8 |
| Checkout redesign | 13 | 5 | 5 | 23 | 13 | 1.8 |
| Search relevance fix | 5 | 3 | 2 | 10 | 2 | 5.0 |
| Data warehouse rebuild | 8 | 2 | 13 | 23 | 20 | 1.2 |
The search fix wins despite being the least valuable item, because it is cheap and can be done now. This is the point of the technique: it favours short jobs with meaningful cost of delay, and it makes the trade-off explicit enough to argue with. Its weakness is false precision — the inputs are relative estimates, so treat the output as a ranking hint rather than a calculation.
MoSCoW. Must, should, could, won't-this-time. Useful for a fixed deadline where scope must flex, and for the discipline of the fourth category. Its failure mode is well known: everything becomes a must. A common rule is that musts may not exceed about sixty per cent of the available capacity.
Kano. Classifies features by how satisfaction responds to them — basic expectations whose absence causes anger but whose presence goes unnoticed, linear performance features, and delighters. It is a good corrective to backlogs full of delighters while a basic expectation such as password reset is broken.
Use one primarily and the others as challenges to the result. Ordering is also where dependency and risk enter: an item with a long lead-time dependency may need to start earlier than its value alone would justify, which connects directly to estimation and planning.
Splitting large items
Splitting is the skill that most improves flow, because small items finish, and finishing is what produces feedback. The rule is to slice vertically — each slice must go through every layer and deliver something observable — rather than horizontally by component, which produces four items and no working software until the last one lands.
Reliable splitting patterns:
- By workflow step. Take the happy path end to end first; add validation, edge cases and administration later.
- By business rule. One currency, one country, one customer type first; generalise afterwards.
- By interface. A working API before the polished screen, or a plain table before the interactive chart.
- By data variation. Handle the common record shape now, the rare legacy formats next.
- By operation. Create and read before update and delete, if that ordering matches real usage.
- Spike then build. When an item is unestimable, split off a timeboxed investigation with a defined question and a written answer as its output.
If a slice cannot be described as something a user could notice, it is probably a task rather than a story, and it belongs inside another item.
Stakeholders and roadmaps
A product owner spends a surprising share of the week outside the team. Map the stakeholders by influence and interest, agree how each group is kept informed, and route requests into the backlog rather than into the team's inbox. The sprint review is the main scheduled channel and works best when it feels like a working conversation about what to do next rather than a demonstration for approval.
Roadmaps are where honesty is most often lost. A roadmap of dated features becomes a set of promises that were never estimates, and every slip becomes a credibility problem. Two alternatives survive change better: a goal-based roadmap that names the outcome for each horizon rather than the features, and a now-next-later roadmap where only the "now" column carries dates. Both let you change the mechanism without breaking the commitment. Whichever you use, keep it visible in the same system as the backlog so it cannot silently diverge — see project management tools for the trade-offs there.
Key takeaways
- The accountability is maximising value, which requires the authority to say no and an organisation that respects the ordering.
- A product goal gives the backlog direction; without one, ordering arguments have nothing to be measured against.
- Items are placeholders for conversations — INVEST plus concrete acceptance criteria keeps them small, valuable and testable.
- Refinement is continuous, costs roughly five to ten per cent of the team's time, and should keep two or three sprints of ready work at the top and no more.
- WSJF, MoSCoW, Kano and value-versus-effort each expose a different trade-off; pick one as primary and use the others to challenge the result.
- Split vertically so that every slice delivers something observable, and put defects and technical work in the same ordered list as features.
Sources and further reading
Frequently asked questions
- How large should a product backlog be?
- Large enough that the team never runs out of ready work, small enough that the whole thing can be reviewed. A practical shape is a few sprints of refined items at the top, a few months of coarse items below, and anything older than that deleted. Backlogs of eight hundred items are common and almost always contain years of requests nobody will ever act on, which makes ordering harder rather than richer.
- Who writes the user stories, the product owner or the team?
- The product owner is accountable for the backlog's content and order, but writing is usually collaborative — the best acceptance criteria come out of a conversation between the person who understands the need and the people who will build it. A product owner who writes every item alone and hands them over produces specifications, and the team stops thinking about the problem.
- What is the proxy product owner anti-pattern?
- It is when the person attending the team's events cannot actually decide anything and must take every question back to a real decision-maker or a committee. Every decision then takes days, the team builds on guesses, and nobody is accountable when the guesses are wrong. The fix is authority, not attendance — either empower the person in the room or put the decision-maker in it.
- How do bugs and technical work fit into the backlog?
- Everything that consumes the team's capacity belongs in one ordered list, including defects, technical debt and infrastructure work, because otherwise the ordering decision is being made invisibly by whoever shouts loudest. The product owner needs enough technical literacy — or enough trust in the developers — to weigh a database migration against a customer feature rather than always deferring it.