A Primer on Prioritization

By Bobby Gill on April 3, 2020

If you are about to embark on a mobile project, get ready to hear the term “prioritization” thrown at you endlessly. From triaging bugs, to planning out your release milestones, mastering how to prioritize during development is key to successful mobile app projects

Here are some hard-won tips on how you can approach prioritization in your own software projects.

What is Prioritization?

Prioritization is the process of attaching a value to a task/feature/scenario and then ordering what gets done based on priority. Here at Blue Label Labs we often undertake massive software development projects that span multiple platforms (iOS, Android, Web) and which have numerous end user stories and countless features. 

The key to our ability to successfully deliver projects at this scale is an inherent ability by every Program Manager (PM) on our team to effectively prioritize and order the workflow of development, be it bugs, features, user stories or epics. 

When you are planning a mobile app release, you will use prioritization to attach value to the scenarios you are looking to enable with that release. You will use these priorities to schedule when specific items are developed and how you prioritize bugs that emerge during development. Prioritization allows everybody on your team to understand what is most important and what they should be working on.

How to Prioritize During Development

The prioritization model I like to use is a simple 3-choice priority scale that we used to use back in my time at Microsoft:

What Does Priority 0 (P0) Mean?

P0s represent the highest priority items to be completed. What is P0? A P0 is defined as something so critical to the release of the product that you would hold the release to include/fix it.

By definition of what P0 means there should be no outstanding P0 tasks at the end of the release; otherwise, it wasn’t a real P0.

Definition of Priority 1 (P1)

P1s are high priority items, but they aren’t necessarily things you would hold up a release for. Releasing a product with outstanding P1 bugs is painful, because a P1 is still a major bug that someone might notice yet it is one you will have to live with. 

So, how does the definition of P1 translate into real life? An example of a P1 bug would be your app not being able to install on an older iPhone. While this might be a major bug, it usually isn’t enough to warrant you holding up the entire release of your product to fix.

Priority 2 (P2)

P2s is the ‘other’ bucket where bugs end up when they aren’t important enough to be considered P1s. You should view P2 items as things that are “nice to have”, rather than “must have”. P2 items can be anything from changes in color schemes or re-designing UI flow.

The Reality of Prioritization

Everyone wants an app that’s full of beautiful features and a seamless UI that users will love. But, creating a multi-functional app inevitably means dealing with bumps in the road along the way. The more features of your app, the higher the likelihood you’ll have more bugs. This is where knowing how to prioritize during development is key. Determining your answer to the question of “what does P0 mean?” can help you sort bug fixes into buckets and keep development on track.

However, a sad reality of app development is that there are usually so many P0s and P1s that you might not ever get around to something marked as a P2. Typically the first few beta releases of an app are so chock full of bugs or missing functionality that P2 bugs only ever get fixed in the final release once the app has stabilized. 

Prioritization is your friend. Learn how to use it, and develop your own scale for what you think is a  P0 is versus a P1. Prioritization only works if other people believe the priorities are valid, so it’s important to make sure that you are consistent and predictable when evaluating bugs and features.

Until the next article, keep on prioritizing folks!

 

Photo by Kelly Sikkema on Unsplash