Skip to content

Backlog refinement

Refinement turns a rough idea into a piece of work someone can pick up and finish without a second conversation. This page is about how much detail belongs in a ticket — and who owns the rest.

Refine just-in-time, in small batches, with the people who’ll do the work. Keep the top two or three items in the backlog ready at any moment — no more. For each item, write:

  • Why — one or two sentences on the outcome. Always present.
  • What — the acceptance criteria that make “done” unambiguous, and the edge cases worth naming.
  • How — left to the implementer, unless a specific constraint (a compliance rule, a downstream contract, a mentoring intent) narrows it.

If the ticket dictates the how, name the reason or delete it.

The real variable in refinement isn’t team size — it’s distance. How far is the implementer from the conversation that produced the ticket? A three-person team with a shared standup can work from one-line tickets because the context lives in everyone’s head. A larger team, where work is picked up weeks after refinement by someone who wasn’t in the room, needs the what written down — not because the implementer is less capable, but because that room no longer exists.

Refining continuously — just before work is pulled — keeps context fresh. It also means less refinement: items that never get picked up never earn a session. Sprint-based refinement front-loads the same work into a ceremony; it works if you have a reason to hold the batch, and creates waste if you don’t. Flow-based cadences (Kanban-style) produce fresher context at implementation time, which is why we default to them.

The why is the anchor when the implementer hits a fork the refinement didn’t foresee. Without it, they guess or come back to ask — both worse than two sentences up front.

Refinement is expensive — six people in an hour is a working day. Most of that cost is wasted if the PO shows up with an idea instead of a ticket. Like any meeting, it wants a named owner, a stated outcome, and an agenda — see meeting hygiene for the shape. Before the session, the PO owns:

  • The why, drafted. Two sentences on the outcome. No one else in the room can substitute for this.
  • A first-draft what. Acceptance criteria the PO believes make it “done”. The team will sharpen them; the PO brings a shape, not a blank page.
  • The obvious questions answered. Who’s the user, what’s the current behaviour, is a stakeholder waiting. If the first ten minutes are the PO looking things up, the ticket wasn’t ready.
  • A rough sense of priority. So the room knows whether to invest 5 minutes or 15.

Estimates and the final what stay with the team. The how stays with the implementer.

  • Vague why, over-specified how. The most common failure. Reverses which decisions are made by whom.
  • Refining the whole backlog. Detail decays. Items refined months out are re-refined when picked up — the first pass was waste.
  • “What” that’s a design doc in disguise. Acceptance criteria are outcomes, not implementations. If you’re naming files or classes, you’re writing the how.
  • No named edge cases. “Handle errors sensibly” isn’t a criterion. Name the two or three cases that matter; the rest is the implementer’s judgement.
  • One person refines, everyone else executes. Refinement without the people who’ll do the work produces tickets that miss the constraints they’d have flagged.
  • Standing “pre-refinement” meetings. A symptom that tickets aren’t arriving ready. The fix is PO prep, not a second meeting. The one exception: a scoped consultation with a rep from a system you’ll touch — name it that, not pre-refinement.

Cap group refinement at 15 minutes per ticket. Past that, one of three things is true, and none is fixed by more discussion:

  • The ticket is actually two tickets — split it.
  • You’re missing information only someone outside the room can provide — park it with a named blocker (who to ask, what to spike).
  • You’re drifting into designing the how — stop, and let the implementer own it.

The output of refinement is a shared understanding, not a word count. A ticket that takes three minutes because the why and the “done” condition are obvious is finished. A ticket that takes twenty because the room argued about acceptance criteria isn’t better — it’s more expensive.

A useful session is 30–45 minutes covering two to four tickets. If you’re spending an hour on one, the session has quietly become a design meeting — different attendees, different agenda. Schedule that separately.

  1. Pick the next few items — the ones likely to be pulled in the coming week or two, not the whole backlog.
  2. State the why in one or two sentences. Outcome, not activity.
  3. Write acceptance criteria as observable outcomes. Include the edge cases that would otherwise come back as questions.
  4. Stop before the how. Note constraints if they exist; leave the solution space open.
  5. Read it back to the person likely to pick it up. If they can restate the why and the “done” condition, it’s ready.
  6. Timebox the session and each ticket. 30–45 minutes total, 15 minutes per ticket. If you hit the cap, split, park, or hand off — don’t push through.