What Are Story Points and Why You Might Be Using Them Wrong
Amongst people in the software industry, there is a lot of confusion around story points.
Story points are part of scrum, right? Wrong. There is no mention of story points, or even user stories, in the 2020 scrum guide.
So what are story points and why might you be using them wrong?
This blog is my summary of the opinions of great minds on the topic of story points with some of my own opinions thrown in as well. This article covers the what and why of story points, goes into how to use them well, and covers some anti-patterns to watch out for.
The goal of this article is not to give the reader a set of hard rules. Instead, the reader should work to understand this as a starting point and then evolve into what best suits the team.
What Are Story Points?
Story points are an arbitrary and imprecise, relative estimate of effort, complexity, and uncertainty.
What is meant by relative?
Story points are relative to previously sized stories.
What is meant by arbitrary?
A team invents their own pointing system. The first story sized is given an arbitrary point value as decided by the team. From then on stories are sized in relation to that story. This means that the first sets of stories won’t be as useful as they have nothing to be relative to and many assumptions have to be made. The first stories are intended to be the first step in making future relative decisions, so this is okay.
What is meant by estimate?
Story points are an estimate of a story's size. There are three key size parameters:
- Complexity
- Uncertainty
- Effort
What Story Points Are Not
Story points are not…
- An estimate of time: It is very difficult to estimate time. Story points trade off precision to make estimating easier
- Exact end dates
- Measure of exact time spent
- Time tracking
- To be used for comparing team’s “output”: Story points are, by definition, relative and unique to each team. Thus, comparing one team’s velocity to another team’s velocity is pointless (pun intended). Once points leave a team they are useless.
Why Story Points?
Story points are an imprecise forecast of a team’s capacity/velocity, helping to develop shared understanding, and useful in negotiating task priority.
Nowadays, there is a big debate surrounding the use of story points, with many experts recommending not to use story points at all, arguing they do more harm than good (more on that debate here).
Before deciding to use story points it is crucial to have a good understanding of why you want to use them. What benefits will the team get from story points? What are the downsides?
Why should we use story points? Why not just estimate time?
- Cost of estimation is low:
- The imprecision of story points allows us to more quickly make estimations
- High accuracy and low precision:
- Relative sizing requires less effort to be accurate than time based estimations. Asking how complex / effortful is this thing compared to that thing is much easier than estimating how long it will take.
Purposes of Story Points
Please note that this is a contentious topic—there is significant debate surrounding how and why to use story points. I have highlighted three common purposes below.
1. Negotiating Priority
“If you want A by the end of the month then we are going to have to push B until next month.”
Story points can be used as a metric to push back against excessive work and prevent burn-out. This stops the team from committing to doing too much in a period of time(iteration) and helps the team say no by providing healthy boundaries.
Remember, the numbers are for the product team’s use only. They shouldn’t be allowed to be turned into a currency.
2. Develop Shared Understanding
If a story is sized, it shows the team has developed a shared understanding of what it will take to complete it.
Story points are a prompt for conversation to get the whole team to understand what will go into completing the task.
“What are you thinking so I can think like that?”
Get in the same headspace about everything which will go into a story.
Example:
John: “This is about a 1, we just need to make a quick update to the Shaw-Fujikawa Translight function.”
Jill: “You’re forgetting we have not implemented automated testing for rupture generation, this will be a 3.”
3. Slicing Signal
Story points can be used as a signal that a task has not been broken down enough.
- “That is a lot of points, has this been broken down enough?”
- “Can this fit into the iteration?”
How to Use Story Points
Make sure to remember the first few iterations the estimates will be highly inaccurate. Over time this will improve.
You should map story points to approximate effort/complexity/uncertainty.
Story Pointing Frameworks
There are a number of frameworks for story points. Here are a few, listed below:
1. T-shirt sizes: easy to start with, low complexity (S, M, L, XL)
2. Integers: tools like Jira can provide burndown charts, scope creep indicators and other metrics when using integers
- Standard Integers: (1, 2, 3, 4, 5, ect)
- Fibonacci-style scale (1, 2, 3, 5, 8)
- Fibonacci-style scale without 2 (1, 3, 5, 8) — Why use Fibonacci? “Less is more” Here is a good article
3. Time based: antiquated, not recommended (Read more here on why story points are better than time)
- Time
- Ideal Time
Tips For Choosing a Framework
There are a few things to consider when the team is deciding on their story pointing framework:
Less is more
You don’t want to allow for too many options; this will lead to analysis paralysis. Remember, story points are meant to be imprecise, we don’t want to spend too much time trying to pick the perfect number.
We are trading off precision for ease of use on purpose.
Upper Limit
Decide on an upper limit of effort/complexity (e.g. your team may decide that for them a 13 is “too large for one feature/story”)
If a story breaks the upper limit then it needs to be broken down into smaller pieces.
Have it your way
Teams should pick their own standard; it shouldn’t be imposed by anyone else. Remember, story points are to be used by the team for themselves.
Planning for New Teams
When a new team comes together their estimates will be difficult to agree on and very uncertain. That’s okay, they don’t have a point of reference yet.
Find 1–2 well defined/known stories and understand “what a 1 vs 3 vs 5 looks like”. Once the team has these stories, they can start to use relative estimation.
Golden Story
Some teams use what is called a golden story. This is the first story estimated for a product. It is then used as a point of reference throughout the lifecycle of the product.
For another take on golden stories checkout this article on the Blizzard Computing blog.
Example of a Team Using Relative Pointing
The team decides on 1–8 of the Fibonacci sequence, so 3 is a medium, 1 is extra small, and 8 is extra large.
Login is a story of about medium size, the team guesses, so they decide to size it as a 3.
Next sprint, the team sizes logout.
They consider the following three size parameters:
- Complexity: Logout is a lot simpler than login
- Effort: There will be a lot less work to do than with login
- Uncertainty: Since the team just worked on login, the uncertainty is low, they are familiar with the code around this functionality and have a good idea of what needs to be done
Assessing logout in relation to login, the complexity is lower. There is less effort needed, and the uncertainty is low.
The team decides to size logout as a 1.
The following sprint, the team needs to estimate a story for allowing the user to update their email.
Again, they consider the following three parameters:
- Complexity: Updating email touches a lot of pieces, the UI, the API, the DB, as well as having the user verify the new email. Certainly this is less complex than login but probably a bit more complex than logout
- Effort: The complexity suggests the effort will be between logout and login
- Uncertainty: There isn’t too much uncertainty here, the team has sent emails from the application before and nothing else is too experimental
The team decides this is larger than logout but smaller than login, so they estimate it at a 2.
Next up, the business has asked us to port over 102 static pages from an old application.
They consider the parameters once again:
- Complexity: Complexity is very low, these are just simple html and css pages which need to be copied over, maybe a few small css changes here and there just make them fit in
- Effort: Effort is high, there are 102 pages to port over, largely this is an effort in using copy and paste
- Uncertainty: The uncertainty is low, just some basic pages added to the UI
While the complexity and uncertainty are low, the team decides, in relation to the other stories, this should be sized the same as login due to the large amount of effort it will take to move overall the pages over.
The story gets a 3.
Example Takeaways
Notice how in the example we did not discuss time, but always talked about effort, complexity, and uncertainty. This is how story points should be thought of.
These sizes are not meant to be precise, they are meant to be quick and easy.
What to Watch Out For
Talking about days
Remember to use relative effort/complexity/uncertainty, not time.
Spending too much time discussing process intricacies
Don’t get stuck in the weeds. If there are some “3s” and a “5” then don’t spend a lot of time discussing if you should introduce a “4”
Management using the team’s points against them
Remember, the only people who should be looking at the points are the product team
What Happens When the Team Doesn’t Agree?
The team discusses the story with the goal of achieving shared understanding.
Figure out why the team does not agree.
Is there something part of the team isn’t thinking about? Refer back to the example in the Develop Shared Understanding section.
Maybe less experienced devs are estimating higher due to more uncertainty on their part. In this case, pick a team norm for how to handle this and move on quickly. Some possible norms would be taking the average if there is a wide range or taking the larger size if the sizes are close.
The pattern to avoid is spending many minutes during a team-wide meeting debating back and forth. If the story needs more work, drop it and save it for later, don’t waste the whole team's time.
In Summary
If you’ve been considering what side of the ‘story points debate’ you sit on, I hope this blog has given you some food for thought.
There are certainly risks involved in relying too heavily on ‘metrics’ in agile but there are also many advantages to story points when used correctly.
If you’d like to continue the conversation, get in touch!
