Figr is the AI product designer that understands your product.
Try for freeSee a demo
Guide

Creating User Stories: A Practical Guide for Product Teams

Creating User Stories: A Practical Guide for Product Teams
Published
November 15, 2026

The story on the screen reads "As a user, I want to manage my account so that I have control," and six people in a refinement meeting are deciding what "manage" means. The estimate is twenty minutes away. Nobody in the room can name the first test that would prove the story works.

Weak stories don't fail in refinement. They fail weeks later, in QA, when a missing error state turns into a bug that needs triage, or in the demo, when a stakeholder asks what happens if two people edit the same record and the answer is a shrug. The template wasn't the problem. The missing definition of done was.

This guide treats creating user stories as a drafting and review discipline rather than a writing exercise. You'll get a five-step draft method, the INVEST check with real warning signs, a way to split oversized work without losing the user outcome, and an acceptance-criteria matrix that surfaces the error, empty and permission states before a developer touches code. By the end, you'll be able to defend one story to a developer, a designer and a tester in the same conversation.

Write a Testable User Story in Five Steps

A testable user story names one person, one capability and one outcome: "As a returning shopper, I want to save my delivery address, so that checkout takes less time." Three parts, one sentence, and enough room for the team to argue about the best solution. The format exists to describe a need from the user's side and leave implementation open for product, design and engineering to settle together.

Compare it with "Build an address form with twelve fields." That's a solution wearing a requirement's clothes. It answers a design question before anyone asked whether shoppers want a form, an address book imported from their last order, or a two-field autocomplete that skips the step entirely. The user story format came out of Extreme Programming in the late 1990s as a lighter alternative to document-first requirements, and its value has always been the conversation it triggers, not the sentence it produces.

A team of professionals collaborating around a whiteboard while creating user stories in a workshop setting.

The five drafting steps

  • Name one user. "As a user" hides at least two populations with different needs. A returning shopper and a first-time buyer want different things from checkout, and one set of acceptance criteria can only match one of them. If picking the name is hard, go back to UX research methods and find out who uses the capability.
  • Pick one concrete verb. Manage, handle and support hide the work. Save, reorder, cancel, export and share each imply a different screen, a different permission and a different failure path, which is exactly the detail you want on the table early.
  • Write the outcome in the user's words. The "so that" clause is what the team tests against. "So that I can find a past order in under a minute" gives you something to measure; "so that I have control" gives you nothing.
  • Flag every "and." Two results joined by "and" means two stories. In a case study of eight Agile teams, 19.7% of 1,345 user stories across 19 sprints violated atomicity by describing more than one feature, and 12.6% carried extra information that broke the minimality criterion, according to the Quality User Story framework evaluation.
  • Add open questions and one acceptance criterion. A draft should arrive with its unknowns listed, not resolved. One concrete criterion forces the team to confirm the outcome is observable.

A story from draft to final

Say someone drops "Add search to order history" into the backlog. The first draft is "As a user, I want to search my orders so that I can find things," which fails on user, verb and outcome at once. The revised story: "As a returning customer, I want to search my past orders by product name, so that I can reorder the coffee I bought last month without scrolling through two years of receipts."

Two open questions sit underneath it. Does search include cancelled orders, and does it match line items or order numbers only? The first acceptance criterion answers the core path: given three past orders containing coffee, when the shopper searches "coffee," then all three appear with the matching line item visible.

Working rule: if a developer can't restate the story in their own words and name the first check they'd run, it isn't ready for estimation.

The cost of skipping that check shows up later than expected. A study of six Agile open-source software projects found that changes in user-story quality tracked later changes in bugs, with the effect appearing roughly 1 to 13 weeks afterward in short- to medium-duration projects and around 12 weeks in longer ones, with rework effects following after about 1 to 28 weeks, as reported in this Springer chapter on story quality and delivery problems. Weak stories don't announce themselves. They surface during implementation, testing or release, long after the author has moved on.

Check Each Story Against Six Quality Tests

Bill Wake's INVEST checklist is the standard filter: Independent, Negotiable, Valuable, Estimable, Small and Testable, as Mountain Goat Software's guide to good user stories sets them out. Read it as six questions rather than six grades.

PropertyQuestion to askWarning signUsual fix
IndependentCan the team schedule it without waiting on another story?Two stories must ship together before either worksReshape the split or move the dependency
NegotiableDoes it state the outcome rather than a fixed design?Story names a specific button color or API routeRemove implementation detail and keep the outcome
ValuableDoes a user or customer gain something?Story reads "Refactor the billing service" with no user namedRestate the value or label it as a technical task
EstimableCan the team size it with confidence?Developers ask what the story is supposed to doClarify the outcome or run a spike on the unknown
SmallCan it finish within one normal delivery horizon?Story spans three sprintsSlice it vertically
TestableCan the team define a pass or fail check?No observable result is namedWrite acceptance criteria that name observable behavior

When a story fails, the remedy is almost always one of four moves: clarify the user outcome, strip implementation detail, split the work, or investigate an unknown with a time-boxed spike.

Run the check out loud. Read each story, ask the six questions in order, and stop at the first failure, because later ones are usually symptoms of it. Take "Refactor billing service." It fails Valuable, since no user or customer appears anywhere in it, and it fails Testable, since no observable result exists. The fix isn't to add detail to the refactor. It's to restate the outcome: "As a finance admin, I want invoices to load within three seconds, so that month-end close finishes on time." Now the team can size it, test it and argue about the threshold.

INVEST is a prompt for a conversation, not a scorecard. Judge each property against the story's context and the team's delivery horizon.

Testable is the property teams fail most often, and the evidence backs that up. A study of more than 3,500 requirements found most INVEST properties exceeded 95% conformance, while testability stayed below 75%, according to the requirements quality study published through ACM. That gap is where test case creation starts, and it's why the acceptance criteria come before the estimate.

Before your next refinement session, run these six questions against five stories already in the backlog and mark the first test each one fails.

Split Large Work Without Losing the User Outcome

A story that joins two outcomes with "and," or that needs more than one sprint to finish, is ready to be split. Splitting badly is worse than not splitting. The common mistake is cutting along technical layers: database table, API, screen. Each slice ships on schedule, and no user can do anything new until the last one lands.

Jeff Patton's story mapping work gives you the alternative. Lay the essential activities of the user's end-to-end experience across a horizontal backbone, prioritize vertically beneath each activity, and build the walking skeleton first: the smallest system that supports the fewest necessary tasks across the full span of that experience, as Patton's story mapping paper describes it.

Split approachExample stories (illustrative)What a user can do after release
Horizontal by layerBuild the invite database table; build the invite API; build the invite screenNothing useful until all three ship
Vertical by workflowInvite one teammate by email; accept an invite from the email linkA teammate can join the team from start to finish
Vertical by permissionAdmin invites a teammate with the editor role; admin invites a teammate with the viewer roleAccess rules work for each role
Vertical by failure handlingInvite is rejected when the seat limit is reached; expired invite link shows a clear messageFailure states are handled before wider release

In short, a vertical split changes what a user can finish, not just how the work is organized. That's the whole argument for it.

Running the sequence

  • Map the journey. Lay the activities across the top of the board in the order the user meets them, from first invite to first accepted teammate.
  • Place the walking skeleton. Put the thinnest end-to-end slice first, even if it skips edge cases you already know about.
  • Add later slices. Add permissions, failure states and boundary conditions in subsequent slices, one user outcome at a time.
  • Rerun INVEST. Test each slice before estimation, particularly Independent and Valuable, which splits break most easily.

A horizontal split is acceptable in one case: a shared technical foundation or a spike that unblocks several stories downstream. Label it as enabling work, give it its own acceptance criteria and keep it off the user-facing release notes. The table above is an illustration of the pattern, not a benchmark from a study.

Take one oversized story from your backlog today and list what a user can do after each proposed slice. If two slices in a row produce nothing a user can finish, you've cut along layers, not outcomes. Mapping user stories instead of backlogs makes that visible before you commit a sprint to it.

Write Acceptance Criteria Your Team Can Test

A story can survive every step above and still fail at the final gate. The weak point is acceptance criteria. In a 2025 study of developer practice, 71.4% of developers considered acceptance criteria vague, and more than 90% said missing criteria create confusion during development, according to the study of acceptance criteria in practice.

A team discussing unclear software development acceptance criteria on a whiteboard in a professional office setting.

Given/When/Then is the working format because it forces a precondition, an action and an observable result into one line: "Given an incorrect password, when the user signs in, then an error appears and no session starts." That sentence is testable by a person, an automated check or a QA script without anyone interpreting intent.

Coverage areaQuestion it answersExample criterion (illustrative)
Happy pathDoes the main outcome happen?Given a saved address, when the shopper opens checkout, then the address is preselected
Error pathWhat happens when the action fails?Given an incorrect password, when the user signs in, then an error appears and no session starts
Empty stateWhat does a first-time user see?Given no orders, when the user opens order history, then a message explains where orders will appear
PermissionsWho can and cannot do this?Given a viewer role, when the user opens settings, then edit controls are hidden
BoundariesWhat are the limits?Given a password of seven characters, when the user registers, then the form asks for eight or more and no account is created
AccessibilityCan every step work with a keyboard and a screen reader?Given keyboard-only navigation, when the user reaches the save button, then focus is visible and the action completes
AnalyticsWhat must be measured?When an invite is sent, then an event records the invitation with the team identifier

The contrarian point is that more technical detail usually makes criteria worse. "The page loads within 2 seconds on a mid-range phone" is testable by anyone with a stopwatch and a device. "The page uses lazy loading" names a technique, so the team can satisfy the criterion while the user still waits.

A criterion that names a database table or a framework is a design decision wearing a test's clothing.

Criteria belong to one story, and they never replace its outcome. They also differ from the Definition of Done, which covers the activities required before any increment counts as complete, such as code review, unit tests and documentation. Keep the two lists separate or the story will turn into a checklist for the whole team.

For a wider set of worked criteria you can copy and adapt, see these testable acceptance criteria examples.

Write criteria for one live story this week and make sure the error path and the empty state are both on the list before it reaches estimation. Skipping the empty state is the single most common omission, and it's the one users hit first.

Run a Story Review Before Sprint Planning

Forty-five minutes with product, design, engineering and QA in the same call catches more than a week of written comments, because each function sees a different gap. Design spots the missing empty state, QA spots the undefined error, engineering spots the dependency on a service that isn't ready.

Keep two lists distinct. Acceptance criteria describe the conditions a specific story must satisfy for the Product Owner to accept it, while the Definition of Done is the team's agreed list of activities required before an increment counts as complete. Agile Alliance's guidance on the Definition of Done notes that the whole Scrum Team should agree on acceptance criteria by the end of the Sprint, and the Product Owner decides whether they've been met.

Then confirm two things per story: that the error and empty-state criteria exist, and that the story passes the INVEST check before anyone estimates it.

Track three numbers across iterations rather than arguing about story quality in the abstract: clarification questions per story, rework rate, and acceptance-test defects that reach QA. The case for treating this as engineering work is measurable. An intervention using the Grimm method cut defects per story by 38.3% in one e-commerce organization and 47.5% in one real-estate organization, with aggregated defects down 43.14% after treatment, according to the paper on reducing defects in agile requirements.

If you want a drafting head start, Figr's free User Story Generator needs no sign-up and returns stories in the "As a [role], I want [goal], so that [benefit]" format with 2 to 4 acceptance criteria each, editable inline and copyable as Markdown. Treat the output as a first draft that still needs the review above.

Pick three stories from the next sprint, run the review this week, and log every clarification question that comes up. The pattern in those questions tells you exactly which part of your drafting habit to fix. For the sequencing, follow this agile sprint planning guide so refinement happens early enough to matter.

Questions Teams Ask About User Stories

Does every story need the "so that" clause?

Yes when the value isn't obvious, because the outcome anchors scope negotiation when someone asks to add a field. Internal technical work can use a plain value statement or a labeled enabling task instead. If you can't articulate any outcome, the item is probably a task.

How many acceptance criteria should one story have?

Usually two to four: the happy path, an error or empty state, and a permission check where roles exist. Many more suggests the story spans multiple outcomes and needs splitting. Fewer than two usually means nobody has thought about what happens when the action fails.

Can the user be an AI system, an internal operator or a workflow?

Yes, but name the role precisely and keep the outcome human-centered. Research on LLM-generated stories found models often produced solution-oriented stories from non-user-centric roles, and that stories in AI systems depend on each other, such as dataset construction, training and evaluation, per this 2025 study of LLM-generated user stories. Those dependencies break the assumption that every story ships alone.

What is the difference between a story and a task?

A story states a user outcome the Product Owner can accept or reject, while a task is a unit of work the team uses to deliver it. "Create payment-token table" is a task. "As a customer, I want to save a payment method so that checkout is faster next time" is a story.

How often should the team re-check stories?

Recheck during refinement and again at sprint planning, because drafts drift as design decisions land. A story that passed INVEST two weeks ago may now describe an outcome the design has already replaced. The second check takes minutes and catches the drift before it becomes rework.


Creating user stories gets much easier when the drafting and the checking happen in the same tool. Figr's User Story Generator turns a feature description into stories with two to four acceptance criteria each, ready to edit inline and carry into refinement, and Figr can then map the flows, error states and edge cases those criteria imply before any screen gets designed. Start with one story you're unsure about, generate a first draft at Figr, and see whether the review conversation gets shorter.