Start free trial
Trending New Genres Authors
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Searching...
SoBrief
User Stories Applied

User Stories Applied

For Agile Software Development (Addison-Wesley Signature Series
Turn vague software requests into testable, valuable work your team can plan and deliver.
by Mike Cohn 2004 296 pages
3.89
2k+ ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Treat each user story as a conversation prompt, not a miniature contract.

A reminder, not a spec. Mike Cohn’s starting point is practical: teams he led built successful software by talking with users, showing working versions, and adjusting as they learned. He had felt guilty that they were not producing the long requirements documents common elsewhere. User stories gave him a way to plan without pretending that every detail could be settled in advance. A story describes a piece of software functionality that matters to a user or purchaser.

Three parts work together. The card holds a short reminder, conversation fills in details when the team needs them, and confirmation comes through tests that show whether the result meets expectations. The card is not the agreement. A job-search story, for instance, can name the goal without prematurely deciding every search field or screen design.

Analysis

What's valuable here is the distinction between recording an idea and creating shared understanding. A short card can bring a customer and a developer to the same discussion without implying that its wording is complete. That is especially useful when the product is changing as people see it. The tradeoff is real: conversations can be forgotten, and they are harder to share across remote or large teams. The method works best when tests, notes, or other records preserve decisions that need to survive beyond the people in the room.

Map distinct user roles before one imagined user defines the product.

Different users, different jobs. A user role groups people with similar goals and ways of interacting with the software. In Cohn’s job-search example, an occasional job watcher, a laid-off seeker, and a recruiter all use the same site, but they do not use it in the same way. Treating them as one generic user can hide important needs.

Build only useful detail. Teams can brainstorm roles, compare overlaps, combine duplicates, discard roles unimportant to success, and note differences such as expertise or frequency of use. A persona is a fictional, more vivid representation of a role, useful when the team needs to keep a critical user in mind. It should be based on knowledge of the intended audience, not invented as a substitute for it.

Analysis

Role modeling makes a product’s audience visible before design choices harden around the easiest user to imagine. It also helps teams notice that a purchaser and an everyday user may value different capabilities. Personas can sharpen discussion, but their vividness is a risk: a detailed fictional person may feel like evidence even when the underlying assumptions are weak. Their strongest use is as a prompt for questions and user research, not as proof of what an entire market wants.

Ask open questions, observe real work, and workshop workflows together.

Look beyond stated requests. Users may describe a solution rather than the problem they need solved. In one project, nurses requested a large text area for documenting calls. Watching them work revealed that the deeper need was for the software to record the searches and recommendations used during each call. Observation exposed a need their initial description had missed.

Use methods for different jobs. Interviews work best with open-ended, neutral questions that do not steer answers. Questionnaires can help prioritize known options across a large group, but they offer little opportunity to follow up on an unexpected answer. A story-writing workshop can combine brainstorming with a rough paper sketch of user workflows. The aim is to surface ideas, not settle screen design.

Analysis

The nurse example illustrates a basic limitation of self-report: people are often good at naming friction but less reliable at diagnosing its cause. Interviews, observation, and workshops provide different kinds of evidence, so combining them can reveal gaps that any one method misses. Observation has limits too. A person may act differently when watched, and a rare workflow may not appear during a short visit. The useful discipline is to treat every method as a partial view, then compare what users say with what they do.

Treat every proxy as biased, and keep a path to users.

A proxy brings a perspective. Real users are the best source of their own needs, but access is not always possible. Managers may favor supervisory features; salespeople may elevate whatever feature was missing from their last lost sale; domain experts may overlook the needs of beginners. In one case, a performance complaint grew as it passed from users through a manager to a vice president: the reported five-minute delay proved to be a one-minute query when the team checked its records.

Reduce the distortion. If direct access is restricted, a user task force can review ideas and prototypes while a proxy retains decision authority. When users are unavailable, combine different kinds of proxies and seek other evidence, such as competing products or early releases.

Analysis

The key issue is not whether a proxy is sincere, but whether their incentives and experience match the people who will use the system. That makes proxy selection a question of representation, not just expertise. A manager may understand the business and still misread everyday work. Multiple perspectives can reduce blind spots, but they do not cancel each other out automatically. Teams should make disagreements explicit and preserve opportunities for actual users to challenge assumptions as early as practical.

Make each story flexible, independent, valuable, estimable, manageable, and verifiable.

A useful quality check. The book presents INVEST as a mnemonic for judging stories. In practice, a story should be workable without unnecessary dependencies, open to discussion, tied to user or purchaser value, possible to estimate, small enough to plan, and clear enough to test. These qualities reinforce one another: a technically interesting task is hard for a customer to prioritize unless its benefit is visible.

Translate technical work into outcomes. Instead of asking the customer to prioritize a database connection pool, describe the user-visible need it serves, such as supporting a specified number of users without a noticeable delay. If a team cannot estimate a story because the technology is unfamiliar, it can run a time-limited investigation, called a spike, before estimating the feature itself.

Analysis

The checklist helps teams diagnose why a story is difficult to plan rather than treating every problem as a writing flaw. A story that depends on another may need a different split; a story with unclear value may need customer clarification. The framework also makes a useful distinction between technical means and outcomes the customer can weigh. Still, a measurable customer benefit does not make technical architecture irrelevant. Developers need room to explain hidden costs and risks without turning their preferred implementation into a customer requirement.

Split features into end-to-end slices that users can actually use.

Deliver a usable slice. When a resume-posting feature is too large, splitting it into a form in one iteration and database storage in another produces no useful result in either. A better split lets someone submit a basic resume first, then adds richer resume information in another story. Each slice crosses the necessary parts of the system and delivers something meaningful.

Match detail to timing. A large placeholder, or epic, can represent work that is not near-term. The team refines it when planning begins. Stories should be small enough to estimate and finish, but not so tiny that each card creates more planning overhead than the change itself. Avoid fixing interface details before they matter, while keeping stories focused on a complete user goal.

Analysis

End-to-end slices make progress legible to users and expose integration problems while the team is still working on the feature. They also give customers meaningful choices about what to fund first. The technique is not a rule that every technical component must be independently shippable; some systems have architectural work that produces little immediate user value. In those cases, the team should explain the dependency and its consequences clearly, rather than disguising infrastructure as a user story.

Define acceptance tests before coding, while assumptions are still cheap to correct.

Make done visible. Acceptance tests describe how the customer will know a story behaves as expected. For a credit-card purchase, examples might check supported card types, expired cards, missing security details, and purchases above a card’s limit. Writing these checks before coding can reveal assumptions that a short story card leaves unstated.

Share the testing work. The customer specifies the intended outcomes, often with help from a developer or tester. Developers remain responsible for lower-level unit tests, so customer tests need not enumerate every technical edge case. When practical, acceptance tests can be automated and rerun as later changes are made. Tests can also express constraints, such as requiring most searches to return within a stated time.

Analysis

Acceptance tests turn a potentially vague conversation into observable evidence without requiring a full specification for every feature. They help customers and developers discover mismatched expectations before a feature is treated as complete. The distinction between customer acceptance and developer unit testing matters: otherwise, users can be burdened with technical cases they cannot judge, or developers can end up defining success solely by their own interpretation. Automation supports repeatability, but human usability checks still matter when the requirement concerns whether people can complete a task.

Estimate as a team, then forecast from finished stories rather than effort spent.

Use a local scale. Story points express the relative size or effort of stories, as defined by each team. Developers estimate together, discuss why their numbers differ, and compare new estimates with previously sized stories. This is more useful than pretending a story can be predicted precisely in calendar hours. One team’s points cannot be compared with another team’s.

Learn from completed work. Velocity is the number of story points a team finishes in an iteration. It helps turn a rough estimate into a release forecast. Only stories that pass their acceptance tests count; partial work earns no points. That rule avoids treating unfinished functionality as delivered value. Early velocity is uncertain, so the team should adjust plans as several iterations provide a clearer pattern.

Analysis

Relative estimates are a way to coordinate decisions, not a universal measure of productivity. Their value comes from consistency within a team and from checking forecasts against completed work. Counting only finished stories can feel strict, but it makes the forecast correspond to usable results rather than time consumed. The caution is that velocity can become a target and then distort behavior: teams may split work to inflate counts or avoid difficult but valuable features. It should inform planning, not rank individuals or teams.

Let customer value drive priorities, with development cost and risk visible.

Trade value against cost. Customers rank stories, while developers provide estimates and explain technical risks. A feature can lose priority once its cost is known. Cohn describes a customer who initially wanted a particular keyboard behavior, then chose other work after learning that the requested option would take about a week longer. MoSCoW offers a simple release conversation: must have, should have, could have, or not this time.

Treat plans as forecasts. Teams allocate high-priority work to iterations based on expected velocity, then revise as estimates, progress, and priorities change. In Scrum, the same user-centered stories can populate the product backlog, with selected work moving into the sprint backlog. A case in the book reports 54 person-months for a story-based Scrum rewrite versus 540 for the earlier waterfall effort, but the projects were not identical experiments.

Analysis

This approach makes scope a shared decision instead of a private negotiation in which one side silently absorbs every deadline. Its most important feature is the visibility of cost before the release is locked. The reported tenfold difference in person-months is striking, but it cannot establish that stories alone caused the productivity gap: the rewrite changed the team size, technology, and target market. The case is best read as evidence that process and team scale can matter, not as a universal productivity guarantee.

Keep story cards light, but make quality constraints and interface risks explicit.

Stories are not everything. Performance, capacity, security, or portability requirements may work better as constraints than as ordinary feature stories. State them in measurable terms where possible, then test them. For example, a concurrency target can be checked with simulated users, while a performance target can specify how quickly a defined share of searches should return.

Protect the experience. Iteration can change an interface after users have learned it. For products where consistent navigation or accessibility is central, teams may need early role modeling, workflow grouping, paper prototypes, and user feedback before coding. Other formats may also be justified for interfaces, integrations, or traceability. Retaining completed stories can help with future maintenance, audits, or rewrites.

Analysis

The method is strongest when it is treated as a way to keep requirements responsive, not as a ban on documentation or upfront design. A stable interface can be part of the product’s value, especially for novice or infrequent users, so changing it casually may create real costs. Likewise, regulated or distributed work may need durable records beyond cards and conversation. The practical question is not whether to document, but which decisions need a lasting record and which details are better discovered close to implementation.

Analysis

The book’s central contribution is a change in what requirements are for. A requirement is not a perfect sentence that predicts a finished system. It is a way for people with different knowledge and authority to make the next useful decision together. User stories support that shift by keeping the initial record small, making value visible, and moving detail into conversation and tests when the team can learn from it.

That process is also a governance design. Customers decide which outcomes matter, developers make cost and uncertainty legible, and users provide evidence about whether the product fits their work. If one group controls all three roles, the method can reproduce the same failures it is meant to prevent. The proxy examples show why participation is not a ceremonial add-on: the person who approves a feature may not experience its consequences.

The book’s planning tools are deliberately modest. Story points and velocity do not reveal objective productivity; they help one team learn from its own completed work. Their usefulness depends on psychological safety. If estimates become promises used to punish developers, people have reason to conceal uncertainty, and the feedback loop breaks. Likewise, a backlog can make priorities visible while still excluding needs that no one has represented.

The strongest modern reading is therefore not that writing is bad and conversation is always better. Conversation carries nuance, but durable records support memory, coordination across distance, accountability, and accessibility. The useful practice is selective: record enough to preserve decisions and test outcomes, but resist documenting detail that the team has not yet learned how to judge. Stories are effective not because they eliminate uncertainty, but because they make uncertainty discussable and revisable.

Summary in 30 Seconds
A user story begins as a brief prompt for discussion, not a complete specification. Learn user roles and observe real work to uncover needs that proxies or stated requests can miss. Break features into usable slices, then define customer acceptance checks before coding. Teams estimate together and forecast from completed, accepted work, adjusting as they learn. Prioritize customer value alongside cost and risk, and state measurable quality constraints separately.
Contains spoilers

Last updated:

Report Issue

Review Summary

3.89 out of 5
Average of 2k+ ratings from Goodreads and Amazon.

User Stories Applied receives mixed reviews, averaging 3.89/5 stars. Readers appreciate its clear introduction to user stories in agile development, praising the practical examples and case study. Many find it well-written and easy to follow. However, some criticize its dated content (published 2004) and lack of depth on certain topics. The book is recommended for those new to agile methodologies but may be less valuable for experienced practitioners. Some readers note its excessive breadth and high price as drawbacks.

Your rating:
4.42
189 ratings
Want to read the full book?

Glossary

User story

User-valued functionality reminder

A short description of functionality valuable to a user or purchaser. It is used to plan work and prompt a conversation, rather than to specify every detail in advance. The team clarifies the story through discussion and uses acceptance tests to check whether the delivered behavior matches the customer’s expectations.

Card, Conversation, and Confirmation

Three parts of a story

A way to describe the three elements behind a user story. The card is a brief written reminder, conversation develops the details between customers and developers, and confirmation uses tests to establish whether the completed functionality meets expectations. The written card is only one part of the story process.

INVEST

Story quality checklist

A mnemonic for six qualities of a useful user story: independent, negotiable, valuable, estimatable, small, and testable. It gives a team a quick way to diagnose stories that are difficult to prioritize, estimate, schedule, or verify. The qualities are guidelines rather than an insistence that every story be perfect.

User role

Group with shared usage

A collection of attributes that characterizes a population of users and their intended interactions with a system. Roles help teams identify distinct goals, expertise, and usage patterns instead of designing for one generic user. A role should represent a person who interacts with the software, not an organization as a whole.

Persona

Imagined role representative

A fictional representation of a user role, given a name and enough relevant detail to help a team think concretely about that user’s goals and context. Personas can make stories more specific, but should reflect research about the intended audience. They are a design aid, not a replacement for actual users.

Epic

Large placeholder story

A story too broad to estimate or complete conveniently as one unit. Epics can mark substantial areas of desired functionality while the work is distant or still poorly understood. When the team is ready to plan or implement that area, it breaks the epic into smaller stories that can be discussed, estimated, and tested.

Spike

Time-limited learning task

A short, bounded investigation used when a team lacks enough technical knowledge to estimate or implement a story confidently. The team sets a maximum time for the investigation, learns enough to reduce uncertainty, and then estimates the functional work separately. A spike produces information rather than direct user functionality.

Story points

Team-relative size estimates

Units a team uses to estimate the relative size, effort, or complexity of stories. Their meaning is defined locally, so point values are not comparable across teams. The estimates support planning and, when combined with the team’s observed velocity, help produce rough forecasts.

Velocity

Completed points per iteration

The number of story points a team completes during an iteration. It is used to forecast how much work the same team may complete in a future iteration. Only fully completed stories count, because partial functionality has not yet met its acceptance criteria and does not represent delivered value.

MoSCoW

Release priority categories

A prioritization method that sorts desired work into must have, should have, could have, and will not have this time. It helps customers discuss what belongs in a release, particularly when time is constrained. The categories distinguish essential work from valuable work that can be deferred.

Constraint

Condition the system must meet

A requirement that limits or governs how the system is built or behaves, rather than describing a discrete feature a user performs. Examples include performance, capacity, portability, and technology restrictions. Constraints should be stated clearly and tested when practical, so they remain visible during implementation and planning.

FAQ

What's User Stories Applied about?

  • Focus on User Stories: User Stories Applied by Mike Cohn emphasizes the role of user stories in agile software development, providing a framework for writing effective stories that capture user needs.
  • Requirements Process: The book outlines a process that saves time and reduces rework, teaching how to gather, prioritize, and utilize user stories throughout the development lifecycle.
  • Practical Guidance: It offers practical advice on writing, organizing, and using user stories for planning, management, and testing, making it a comprehensive guide for agile methodologies.

Why should I read User Stories Applied?

  • Enhance Agile Practices: The book enhances understanding of agile practices, particularly in writing and utilizing user stories effectively, making it valuable for developers, testers, analysts, and managers.
  • Improve Communication: It helps improve communication between technical teams and stakeholders, leading to software that better meets user needs.
  • Practical Tools and Techniques: Cohn provides tools and techniques that can be immediately applied to projects, useful for both beginners and experienced practitioners in agile development.

What are the key takeaways of User Stories Applied?

  • User-Centric Development: Emphasizes writing user stories from the user's perspective to ensure software meets actual user needs.
  • INVEST Criteria: Introduces the INVEST criteria for good user stories: Independent, Negotiable, Valuable, Estimatable, Small, and Testable.
  • Continuous Collaboration: Highlights the importance of ongoing collaboration between developers and users to refine requirements and adapt to changing needs.

What is a user story according to User Stories Applied?

  • Definition: A user story is a simple, clear, and brief description of functionality valuable to real users, capturing what the user wants to achieve.
  • Three Aspects: Consists of a written description, conversations to flesh out details, and tests to confirm completion, ensuring clarity and accountability.
  • Example: An example might be, "As a job seeker, I want to search for jobs by location so that I can find opportunities near me."

How do I write effective user stories as per User Stories Applied?

  • Follow the INVEST Criteria: Ensure stories are Independent, Negotiable, Valuable, Estimatable, Small, and Testable for manageability and user value focus.
  • Use User Roles: Include specific user roles to clarify who the story is for, enhancing effectiveness.
  • Keep It Simple: Avoid unnecessary details or technical jargon, focusing on user needs for further discussion and refinement.

What techniques does User Stories Applied suggest for gathering user stories?

  • User Interviews: Conduct interviews to gather insights about user needs and expectations, uncovering valuable information.
  • Story-Writing Workshops: Organize workshops for stakeholders to collaboratively write user stories, encouraging participation and idea generation.
  • Observation: Observe users interacting with existing systems to identify pain points and areas for improvement, providing real-world context.

What is the role of acceptance testing in User Stories Applied?

  • Validation of User Stories: Used to validate that software meets requirements outlined in user stories, ensuring alignment with user expectations.
  • Customer Involvement: Customers specify acceptance tests, clarifying user story details and ensuring development team understanding.
  • Part of the Development Process: Integrated into the development process, catching issues early and ensuring software alignment with user needs.

How does User Stories Applied define the concept of velocity?

  • Definition of Velocity: Velocity is the amount of work (measured in story points) a team can complete in a single iteration, serving as a key planning metric.
  • Importance for Planning: Helps teams estimate completion time for remaining work and plan future iterations effectively.
  • Adjusting Expectations: Velocity can change over time; regular measurement allows teams to adjust plans and expectations based on performance.

What are the best practices for planning a release according to User Stories Applied?

  • Prioritize Stories: Collaboratively prioritize user stories based on organizational value and user needs, using techniques like the MoSCoW method.
  • Estimate Workload: Estimate total story points for the release and use team velocity to predict needed iterations, setting realistic timelines.
  • Flexibility in Planning: Be prepared to adjust the release plan as new information emerges or priorities change, maintaining flexibility for success.

What are "story smells" in User Stories Applied?

  • Indicators of Problems: Story smells are signs of issues with user stories, such as being too small or too large.
  • Guidance for Improvement: Provides a catalog of common story smells and suggests ways to address them, refining user story practices.
  • Promotes Better Practices: Recognizing and addressing story smells leads to more effective user stories, improving the development process.

How does User Stories Applied integrate with Scrum?

  • User Stories in Scrum: Explains how user stories can be used within Scrum, particularly in managing the product backlog.
  • Sprint Planning: Discusses how user stories help prioritize work during sprint planning, ensuring valuable features are developed first.
  • Daily Scrums: Provides context for daily scrum meetings, helping teams stay focused on delivering user value throughout the sprint.

What are some common pitfalls to avoid when using user stories according to User Stories Applied?

  • Avoid Over-Detailing: Writing too many details can lead to confusion and detract from facilitating conversation.
  • Don't Ignore User Input: Failing to involve users in the story-writing process can result in stories that don't reflect user needs.
  • Neglecting to Prioritize: Not prioritizing user stories can lead to wasted effort on non-valuable features, impacting project success.

About the Author

Mike Cohn is a prominent figure in the agile software development community. As the owner of Mountain Goat Software, he has made significant contributions to the Scrum methodology. Cohn is recognized as one of the inventors of Scrum and co-founded the Scrum Alliance. He holds the title of Certified Scrum Trainer and specializes in training others on Scrum and agile techniques. Cohn is credited with popularizing Planning Poker, a technique for estimating effort in software development, and provides a free online planning tool for this purpose. His expertise and influence in the field have made him a respected author and trainer in agile methodologies.

Download PDF

To save this User Stories Applied summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.39 MB     Pages: 22

Download EPUB

To read this User Stories Applied summary on your e-reader device or app, download the free EPUB. The .epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.
Download EPUB
File size: 1.38 MB     Pages: 25
Want to read the full book?
Follow
Listen
Home
Swipe
Library
Get App
Try Full Access for 3 Days
Listen, bookmark, and more
Compare Features Free Pro
📖 Read Summaries
Read unlimited summaries. Free users get 3 per month
🎧 Listen to Summaries
Listen to unlimited summaries in 40 languages
—
❤️ Unlimited Bookmarks
Free users are limited to 4
—
📜 Unlimited History
Free users are limited to 4
—
📥 Unlimited Downloads
Free users are limited to 1
—
Risk-Free Timeline
Today: Get Instant Access
Listen to full summaries of 26,000+ books. That's 12,000+ hours of audio!
Day 2: Trial Reminder
We'll send you a notification that your trial is ending soon.
Day 3: Your subscription begins
You'll be charged on Nov 24,
cancel anytime before.
Consume 2.8× More Books
2.8× more books Listening Reading
Our users love us
1M+ readers
Trustpilot Rating
TrustPilot
4.6 Excellent
This site is a total game-changer. I've been flying through book summaries like never before. Highly, highly recommend.
— Dave G
Worth my money and time, and really well made. I've never seen this quality of summaries on other websites. Very helpful!
— Em
Highly recommended!! Fantastic service. Perfect for those that want a little more than a teaser but not all the intricate details of a full audio book.
— Greg M
Save 62%
Yearly
$119.88 $44.99/year/yr
$3.75/mo
Monthly
$9.99/mo
Start a 3-Day Free Trial
3 days free, then $44.99/year. Cancel anytime.
Unlock a world of fiction & nonfiction books
26,000+ books for the price of 2 books
Read any book in 10 minutes
Discover new books like Tinder
Request any book if it's not summarized
Read more books than anyone you know
#1 app for book lovers
Lifelike & immersive summaries
30-day money-back guarantee
Download summaries in EPUBs or PDFs
Cancel anytime in a few clicks

Why one summary?

Scanner
Find a barcode to scan

⭐
⭐
⭐
We have a special gift for you
Open
38% off
DISCOUNT FOR YOU
⭐
⭐
⭐
$79.99
$49.99/year
Only $4.16 per month
Continue
2 taps to start, super easy to cancel
Settings
General
Widget
Loading...