Product backlog mistakes to avoid

The idea for a new product stems from a gap in an existing market or a problem that the business owner realizes. The idea ushers the mind to the solution in the form of a product, and the final impact or a future state. A product leads to becomes its vision which is nothing but “where” you want to go with the product that you’re planning to build. This article discusses the common product backlog mistakes to avoid and to help you recognize and fix them.

Agile teams across the world compile and translate the product’s vision provided by agile business analyst leaders into Roadmaps, Release plans, and finally, Product Backlogs. The former two are the guiding strategic documents for everyone – While the roadmap communicates a high-level product vision in the form of milestones and checkpoints, the release plan provides a deeper understanding of upcoming product features with roughly estimated dates. The third i.e., the Product Backlog Management is a list full of bite-sized product requirements that the team can invest their efforts on. The product requirements are generally represented in the form of user stories.

Product Backlog Item

A user story OR a Product Backlog item entails the story behind “why” a user needs something. We diarize all these “WHYs” on an initial Product Backlog. When the right time comes, these stories remind us of the user – needs and provide us with an opportunity to scrutinize what is required to fulfill those needs.

With these guiding strategies in place, the agile team starts implementing the solutions, and thus, “iteratively” and “incrementally”, a product starts taking shape:  Why incremental? Because, all the changes are not done at once but in small chunks i.e., feature by feature in a fixed amount of time intervals called sprints; and iterative because all the incremental changes are illustrated to the users, at the end of each sprint. The users provide their feedback and help the product get better with time. The loop continues until the product’s vision is realized and the finished product is launched for end users.

Although in theory, the agile process sounds perfect, the reality is quite different. More than often, the final products are not made right or as per the vision. It’s not rare to see the agile teams fail or not attain the target within the planned timeline. While there are many reasons that we could tabulate for this, the most important in my eyes is the product backlog mistakes that the product owner makes while creating the initial Product Backlog.

Since the product backlog forms the very base on which the entire product is to be created and is also the reference pointer for the agile team who builds the product; if the most common product backlog mistakes are avoided with the right approaches, the risk of having a non-efficient agile team or a weak product may be greatly mitigated.

Start your agile analysis certification course journey by following the steps with resources and products from Techcanvass learning!

This article states a few of the most common product backlog mistakes and the right approach required to avoid each one of them:

Product backlog Is Too Big

A product roadmap works as a plan for executing product strategies. It provides the direction one should take to realize the product’s vision. We use a product roadmap to communicate the product’s big picture, milestones, and current progress at any given time to internal teams and external stakeholders.

There are 2 common product backlog mistakes encountered w.r.t strategic documents.


First: The agile teams, often, suffice with having a release plan and not the roadmap. This is definitely not a good practice because a Release plan is not equivalent to a Product Roadmap as stated earlier. Both the documents serve distinct purposes.

Second: The product backlog is not connected to a strategic plan like a product roadmap governing the product’s vision. Without a vision and a roadmap to realize it, the product backlog items will not be appropriately prioritized and in turn, will not yield business value in the required duration.

The most common reason for not having an appropriate product roadmap or a long-range detailed product plan is because most of the businesses do not believe in having one and rather rely on the product to emerge and evolve with time. Although, this may not be entirely incorrect since there are cases where everything is highly dynamic and long-range detailed plans are less likely to work; in the cases where the product line is highly regulated, bounded by government rules or rules set by other authorities, the long-range plan is definitely required.


The right approach would be to start with the product mission which is nothing but “Why” is the product need in the first place and then link it via product roadmap to its final destination i.e., product vision. The journey from ‘mission’ to ‘vision’ requires many check-points in between which form releases. For a successful release, or crossing the milestones, every step taken in the right direction is an effective backlog item being “Done”. Since everything is linked intricately, skipping or devaluing the proper linkage will only lead to not reaching the destination in time and as envisioned. The idea would then have lost its opportunity!

Product Backlog Management Is Too Detailed

A Product Backlog Management is a single source of ‘product requirements’, which the development team works upon. It is a repository that feeds on to the product’s evolution; in other words, if it’s not on the Product Backlog, it’s not getting done. Hence, they are a great artifact – they help move from the requirement solution mindset and explain the purpose of the work in terms of what the end-user will get from it.

Let’s look at the common product backlog mistakes pertaining to the scope of the product backlog.


First: Since the development effort in an agile environment is characterized by uncertainty and change, including too much detail at the initial level will thwart the product’s evolution based on the feedbacks of customers and stakeholders. While the team must not get into the pitfalls of habitually writing one-liners, there is no need for the Product Backlog to be too intricate and explain all that is about to ensue a few increments down the road. This is a wasteful practice because it simply cannot accommodate the new information that would reveal itself while the product is being developed.

Second: Some scrum teams make every Product Backlog management is completely transparent to every stakeholder which is not required. For example, there will be some work that is solely technical or will become vague when created into a user story. Such user stories will not cater to every stakeholder, most of who will not be attentive to the technical or other details, anyways.

Third: While one should not only avoid including too many details from catering all stakeholder’s inputs in the Product Backlog, it should also not become a meager wish-list comprising everything and anything that one might ever need. Such a backlog will resemble a loose collection of inapt features leading to a weak value proposition and a poor user experience. Also, it becomes difficult to update and prioritize such a backlog.


The Product Backlog item should really be comprehensive for the development team to decide “what”, “how” and “how much” they can do in the next sprint during the sprint planning meeting. The rest of it should only be detailed enough so that the scrum team and other stakeholders can discern the direction in which the product development will move into the future. Let’s understand an effective way to author a product backlog with the help of a practical example:

Though not distinctively, a Product Backlog item can be a short template divided into three simple sections:

  1. Who – Example: As a website user
  2. What – Example: I want to retrieve my forgotten password
  3. Why – Example: So that I can log back in

The above-mentioned item is a very high-level description of what a user wants and that is to retrieve his password. Now, since there are multiple ways to retrieve a password, this user story can be further decomposed into sub-user stories such as:

  • Retrieval of forgotten passwords through email
  • Retrieval of forgotten passwords through mobile number and OTP

Each of the sub-user stories shall include the step-by-step action needed to retrieve the user’s password through his email or mobile number. It should also include ‘where’ the user will land after retrieval of the password from any of the methods. These details are enough to mark the feature as complete.

Notice that in the example given above, the user story is just a pointer about what needs to be done rather than including what inputs need to be fed or what technical infrastructure or back-end support shall be availed to retrieve the forgotten password. The stories are neither too detailed nor too vague. A fine balance between ‘too much information and just being a ‘wish/to-do list’ is the hallmark of a good Product Backlog and in turn a fine finished product.

Product Backlog Lacks Appropriate Refinement

One can frequently observe that most of the agile teams struggle with the completion of all the committed work in a sprint. Is it just a matter of over-commitment, part of the planning issue, or lack of sufficiently ready items? Upon a closer look, all the three are interrelated and part of one issue: lack of refinement.

Let’s look at the most common product backlog mistakes pertaining to the refinement of the product backlog.


First: The difference between the task and the product backlog items is NOT maintained.

A user story furnishes business value and is something that an end-user can understand while the task, contrastingly, neither provides any business value on its own nor makes much sense to the end-user. The task can be a technical or non-technical affair required to be done to complete a user story. While this difference seems apparent, in some cases, it becomes a thin line and one tends to add tasks as backlog items to only end up with wrong estimates and in turn, messed up priorities.

Second: Product Backlog Items/User Stories are NOT prioritized efficiently

Without clear priorities in place, the agile team lacks direction. Just stacking the product backlog in the list of highest to lowest business value is not prioritization because this approach lacks a key factor – “dependency”. For example, while a user story may be valuable to the business, if it has some technical dependency, due to which it cannot be done, it should be stacked below the item which carries the highest risk but can be done sooner.

Third: Product Backlog Management does not ensure a high fidelity

The product backlog management does not age well; in other words, the ability of the team to deliver pertinent value would be severely hampered if the product backlog is allowed to become irrelevant and not reflect the most current priorities at any given point in time.


Why must a backlog be refined? The answer is simple: so that it is clear to all stakeholders, done in the committed time and with the expected quality. Refining a Product Backlog is a series of important steps while ensuring that all the above mistakes are avoided. While there can be many ways and techniques of refining a backlog item, check-listing the below-mentioned broad areas will ensure quick closure of the process and ensure an efficient outcome. A product backlog can be called ready or refined when:

  1. All the items are complete, understood, and clear with no open questions from the development team.
  2. The items are testable.
  3. The efforts can be quantified through estimation.
  4. The items entailing requirements can be completed within a sprint.
  5. The backlog items are not tasks or features but a single unit of value addition in the product’s development.

Product Backlog Is Not Effectively Prioritized

A user story is shippable and valuable to the customer. Suppose a large user story is estimated to take 3 months to complete. So, it is divided into 6 equal chunks by size wherein each chunk is estimated to complete in 2 weeks. Now, if each chunk in itself is not independently shippable or valuable, then we are delivering the value to the customer only after 3 months (only when the user story is complete). This is somewhat like delivering the value as the waterfall approach which is not very efficient. So, the rule of thumb for splitting the user stories must be that each individual story is shippable and valuable to the customer and can be completed within a single sprint. Splitting user stories are instrumental for effective product creation. The key benefits are as follows:

  1. Small user stories are easier to understand. Smaller the user story, the less complicated it is and hence fewer chances of a misunderstanding about what is or what is not included as part of the story.
  2. It helps in identifying waste. If a product owner splits a large user story appropriately, one can realize that some of the user stories are not essential for the expected outcome. For example, if the split is across various scenarios, a few of those scenarios may be irrelevant or may not happen so the team can save time by not addressing those.
  3. Smaller user stories can be delivere faster which means that the team will get the feedback sooner. So, if the team was on the wrong path, they were wrong for a short time and the same can be rectified with less effort.


There are a few misapprehensions around splitting the user stories which must be avoided for better effect:

First: Only the Product Owner is responsible for maintaining the user stories

 Product Owners may lack the technical knowledge to split the user stories but still do being their owners.

Second: User stories can be split horizontally

Let’s understand this with the example of a software product. Any software has three distinct layers: the bottom-most database layer, the middle logic layer, and the topmost layer of the user interface. With these layers in mind, one apparent option is to split the stories horizontally and devise an easy way for many teams to start, by assigning each layer i.e., UI story to the Front end development team, Logic story to the Server Team, and so on. While each layer accords to the overall story, they don’t add much value on their own because we can’t ship a product with just a user interface but no backend server changes and expect a user to find value in it.

Third: All features can be broken in one go

Even ten initially prioritized features may result in hundred user stories spanning across multiple releases that may result in a lot of complexity. The team may not be ready to handle it.


For all the above items, below are the right approaches that can be taken:

  • In order to explore all alternatives, the entire team should come together to add various perspectives and skillsets required to split the stories.
  • Instead of horizontal, user stories must be split vertically, though it is not simple. Vertical slicing requires the developer to work vertically across the stack from UI to logic to database. The best way to accomplish this is to work with the full stack developers or add tasks for each individual layer of vertically sliced user stories and assign each task to each layer’s expert. One must ensure that the user stories are split logically or feature set-wise. To understand the feature set-wise split, refer to the example illustrated on Page 3.
  • Instead of fractionating everything, the product owner must focus to prioritize feature set. Then look for the related PBIs which can be fit into the next or near-future release.  The agile team is a self-organizing team that should be able to work on these prioritized PBIs.

A common question may arise at this point: How granular can one get by splitting the story? Well, the answer is that it can be as minute as possible but must not lose its elemental property of being valuable to the customer. It must also not look like a “task”.

You can also find out more about Product Owner vs Business Analyst vs Scrum Master, visit our official page to access more posts.

Hijacking Product Backlogs by Product Owners

The Product Owner expects to be the person having an intimate knowledge of the market. It involves the user community, and/or the customers. This often leads to the scenario wherein product owners author user stories on their own. Then hand over the high-priority items to the development teams. Although the teams do their best to correctly interpret the user stories. There are high chances for them to get it wrong, simply because they do not possess it. It has adequate knowledge about the end-users and their needs. On the other hand, a product owner is often not a technical expert (may not understand the underlying technology). Hence, there are again high chances that he/she may miss to include key scenarios or criteria in the stories that the technical team will need a solution for.

Let’s understand the primary product backlog mistakes in regards to the ownership of the product backlog.


A product backlog is primarily a product owner’s responsibility, however; it certainly does not mean product backlog management. It should only be looked at during sprint planning or product grooming. The product backlog must not become a hostage to the product owner. It should not just get refined and updated when the product owner considers it suitable. He or She must not do it without consulting the rest of the scrum team. Hijacking the Product Backlog is the most dangerous thing that a product owner can do. It will result in every bad outcome that one can think of – from creating mistrusting faux-agile teams to increments in entire products. It holds no value to anyone.


The product backlog management belongs to everyone. Everyone on the team should have a say in how it grows and evolves with time. Collaboration on co-creating the product backlog management offers these major benefits:

  1. Collaboration leverages the collective knowledge and creativity of the agile team. It helps in creating better ‘just as detailed as required’ backlog items. This in turn allows the product owner to transfer business knowledge and the user needs to the team.
  2. Collaboration and co-creation make the team members feel valued and respected. It empowers the individuals and increases their motivation to work on the product. Rather than just following the instructions and gathering the requirements. People contribute to the product decisions and help shape the solution.

You can read our detailed article on Agile Business Analysis Key Principles in this Business Analysis blog.


The Product Owners must avoid the aforementioned product backlog mistakes as effective backlogs are crucial to the success of agile teams. Backlog sets a strong foundation for a robust product in the coming future. Its creation involves getting all the right requirements and features. One must also aim to prioritize them in a way that satisfies the business needs while keeping the cost. It should be as low as possible. Agile coaches and scrum masters are expert facilitators who can help achieve this using various facilitation techniques. So, if the team has them, then the recommendation is to also leverage their valuable contribution.

Leave a Reply

Your email address will not be published.

Fill out this field
Fill out this field
Please enter a valid email address.
You need to agree with the terms to proceed