Are You Using AI In Your Job?

We want to understand the real-world applications of AL and ML in business and the impact it will have on all our jobs.

Want to help? Complete the survey, your insights could make a big difference. It will just take one minute.
You'll be the first to get access to the final report.-->

The Best Way to Prioritize Tasks For App Development

Bobby Gill | February 15, 2022

Updated on 02/15/22

If you are about to embark on a mobile project, get ready to hear the term “prioritization” thrown at you endlessly – if you’re new to digital product development you’re bound to have questions like, “What is P1?” among many others. 

Here, we explain the differences between P0, P1, and P2 as well as offer a few hard-won tips on how you can approach prioritization in your own software projects.

Why Is Prioritization Important?

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, the Web, and beyond), which have numerous end-user stories and countless features. 

Project prioritization is integral in effectively managing and executing our tasks as we iteratively develop each and every project, layer by layer.

what is p1

Source: Belinda Fewings at Unsplash

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

Mastering prioritization is foundational to your business’s future success. Whether you have an app idea that’s Uber-like or some on-demand service the world’s never seen, we can prioritize order and workflow to deliver your app into reality.

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.

P0 P1 P2 | How we prioritize during software 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 is P0 priority?

In software development, P0 is one of the few codes that we use to denote the severity of bugs discovered by developers, testers, and users. P0s represent the highest priority items to be completed – unlike a P1 that can feel like an app breaker to a product owner, a P0 is something so critical to the release of the product that you would hold the release to include or fix it. 

By definition, P0 priority there should be no outstanding codes of this nature at the end of the release – otherwise, it wasn’t a real P0.

Think if you were building Uber and it did everything it was supposed to, except collect payment.

If Uber’s payment processing were to go down, related issues would be tagged with P0 priority and the app would be considered broken until the issues are resolved.

What is P1?

Next is P1 which falls in the middle of p-code severity meaning they’re high-priority items, but they aren’t necessarily things you would hold up a release for. 

Most MVPs will have P1s at release – consider the following quote from LinkedIn co-founder, Reid Hoffman:

what is p1

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 it. These are problems that might be addressed in updates. Releasing a product with outstanding P1 bugs will likely feel painful (it usually is for us too) as a P1 is still a major bug that someone might notice but you’ll have to live with.

It’s a lot if you’ve ever been dressed to nines for an important meeting but dripped mustard on your outfit from a gas station hot dog you smashed in your car on the way. It sucks but you need to keep moving.

Last and certainly least: P2 priority

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.

Anything beyond P2 exists but is marginally useful at best

Though P3 and P4 exist, they’re more symbolic than anything else. As you know by now, P2 is considered low priority however, some like to incorporate even lower priorities like P3 and P4 then upgrade them as needed. 

It’s not that you can’t use them, but the problem that tends to occur is that these lower priority codes tend to accumulate ideas from team members. Some, like myself and most of my team, prefer to use a different method for tracking such information as this keeps the ticketing system clear of anything that isn’t actionable.

Facing The Realities 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 projects 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 for app developers is that there are usually so many P0s and P1s that you might not ever get around to something marked as a P2 (with some exceptions such as those that surface often in user feedback).

Typically, the first few beta releases of an app are so chock full of bugs or missing functionality that P2 bugs aren’t tackled until the final release has stabilized. 

Prioritization is your friend. Learn how to use it, and develop your own scale for what you think is a P0 versus a P1. Practice prioritization while working with your collaborators to gain clarity on projects and urgency.

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!

Bobby Gill
Co-Founder & Chief Architect at BlueLabel | + posts

Blue Label Labs Is Hiring

We are looking for exceptional people to join our exceptional team and build great things together.

See Our Current Open Positions