Blog Archives

Normalizing Story Points Across Teams

normalized story points

On a large-scale agile project/program with multiple Scrum teams working toward the same overall goal, having user stories sized in a way that makes it easier to re-assign them from one Scrum team to another provides provides a planning and execution advantage when balancing work across teams to optimize delivery dates.

 

Before adopting a common story points scale, there are a couple of keys to consider in designing the team structures:

  • Skill sets should be balanced across teams rather than having teams that are specialized (i.e. don’t have a user interface team, a database team, a services team, etc.). This allows each team to develop entire features rather than individual layers of the application. And just as importantly, it provides flexibility to move user stories from one team’s backlog to another’s, helping to avoid any one team from becoming the critical path.
  • Once the teams are formed, the teams are kept together rather than constantly re-assigning people to different teams. The philosophy of “taking the work to the team” helps high-performing teams to continue to produce rather than paying the price associated with forming/storming/norming/etc. every time new team members are added to a team. This can be a very difficult concept for organizations that are accustomed to traditional resource leveling across a department or organization, but it critical to keeping teams operating at peak productivity.

With the team structure in place, features to be developed can then be introduced into each team’s backlog. On a project that is not constrained by a minimum feature set and go-live date (the kind that we read about in text books), the product increment is released when each team completes the features in their backlog and necessary integration/regression testing is complete. When a feature set is needed by a certain date, the project manager will seek to understand if one of the teams is on the critical path and not able to meet the forecasted code complete date. If this is the case, they may need to move some of the features or stories to another team’s backlog. In order to do this, the features and stories need to be sized in a currency that is common across all teams – story points.

On a small, single-team project, each team would be free to define what a story point means to them. On a large-scale project/program, it is important that the story points scale is the same for each team in order to facilitate balancing work across teams. This can be accomplished by identifying stories in the backlog that are representative of each story point size and making those stories known to all of the teams. Team leads then attend other teams’ backlog grooming sessions (especially in the early going) to ensure teams to not deviate from the standard.

Reflections:

  • Features and stories belong to the overall project/program, not to an individual team.
  • Sizing stories using a common story points scale makes it easier to balance work across teams.
  • Sizing stories using a common story points scale allows for consistency in project reporting such as team-level burndowns or overall project/program

Getting Started with Story Points

A mature agile team intuitively knows what a story point means in terms of the relative size of a user story compared to other stories that it has sized in the past, but how does a new team that perhaps even has people who are new to agile get started with story points? As I mentioned in another blog post, Ideal Days is a story point estimation scale that blends size with effort and degrades the backlog sizing process into a drawn-out time estimation exercise. Given that a points scale like the Fibonacci sequence that relates more to size/complexity is preferred, how does a team get started when it does not have a baseline story against which to do relative sizing?

A few things should be in place to set the stage for establishing a baseline story:

  1. Definition of Done. This should include quality assurance and user testing.
  2. Sprint length. Should be no longer than two weeks.
  3. Understanding by the team that high throughput is achieved via low work in process, i.e. having a small number of user stories in flight (being worked on and not at ‘done’) in a sprint.

Once there is a set of stories in the backlog that are small enough to pull into a sprint, the next step is to discuss and assign story points. In asking the team to assign story points for the first time, I usually tell them something like this:

Team, we know that in order to meet our sprint goals we need to get the first story in this sprint coded, unit tested, and into QA by the second or third day of the sprint. Let’s call that a three point story.

With that in mind, the team sizes the first few stories. Some might argue that we are just using Ideal Days. We are not, because executing and supporting the QA and user testing efforts are not included in the goal of getting the story to QA by the second or third day of the sprint. The other reason we are not using Ideal Days is because we only use this method for sizing the first couple of stories in the backlog. After that, all estimations are done relative to those first couple of stories that were sized, by asking whether or not a story feels bigger or smaller than those stories.

Reflections:

  •  Establish the Defintion of Done, sprint length, and concept of high throughput via low work in process before sizing stories.
  •  Size stories with the goal of getting the first story into QA within the first few days of the sprint.

Story Points or Ideal Days?

Fibonacci CardsSizing user stories is a key part of understanding the overall effort required to create a product release. Getting started is simple: pick a baseline story and assign a number of Story Points or Ideal Days that it will take to complete the story. Next, look at other stories in the backlog and decide whether or not they are bigger or smaller than the baseline story and by how much. Lather, rinse, repeat.

Developers coming from waterfall teams are accustomed to doing time-based estimates. Junior or intermediate level developers were usually asked to estimate functionality that was well-understood and broken down into small units of work. But in waterfall efforts, sizings done during project inception were probably done using a high-level estimation technique such as function points by a more senior analyst, lead and/or architect. Agile user stories are not necessarily well-defined or split into small stories the first time that they are sized (they will be by the time they are brought into a sprint plan). Because of this legacy of thinking in terms of hours to build, developers often revert to using a time-based estimation technique when trying to size user stories.

Before we go any further, some quick definitions:

Story points: a points scale (possibly using the Fibonacci sequence – 1,2,3,5,8,13,21,etc.) that indicates the size of a story relative to a baseline story.

Ideal days: the number of days of effort that it would take the team to get a story done if the team worked with no interruptions.

Once the team has sized the baseline story, it is ready to start comparing other stories to it and assigning points to them. But along the way, developers may develop an ‘algorithm’ for assigning Story Points. You know they have done this when one of them says, “I think that story will take 8 hours, so it’s a two-pointer.” What is happening is that the developer is doing a time estimate of their effort and reverse-engineering the story points rather than sizing the story relative to other stories. This is when the ScrumMaster needs to remind the team about the goal of sizing stories and why Story Points are a better approach than a time-based estimation approach.

Story Points are for sizing, not for time estimation. This allows teams to:

  1. Quickly size features and create a release plan without getting bogged down in implementation details. Team members are often very reluctant to provide time estimates unless they have all of the details about a feature. Being agile means that it is okay not to have all of the details up front. Developers typically are more comfortable saying that Feature B is twice as big as Feature A knowing that they won’t be held to a specific time estimate.
  2. Use Story Points in conjunction with the team’s velocity to make delivery date projections that are not as prone to decay as those using story-level time estimates. Relative sizings based on Story Points are usually fairly stable; estimates based on time can change dramatically as a project unfolds. In conjunction with Story Points, velocity is a reflection the team’s productivity and expertise. This is much easier and more flexible than trying to bake size, effort, productivity, and expertise into one ideal days number for each story.
  3. Create sizings that include all of the effort to get a story to ‘done’. Story Points include development hours, user interaction design, QA testing, etc.
  4. Prevent stakeholders from using Ideal Days estimates to calculate unrealistic delivery dates which are then mandated to the team. It is not their call how many hours per day the team spends actually working on user stories. They do not have a sense of how the mix of skills on the team or other factors will impact productivity. It is up to the team to determine how much time it can spend working on stories, and how much time it needs for grooming the backlog, doing production support, etc.

Reflections

  • The team should size the backlog without having deep, detailed requirements conversations.
  • Story Points are a way to size features without having to calculate how much time it will take to do the work.
  • Story Points are less prone to decay than Ideal Days.