Dependency Management

What is dependency management in Product Management?

Simply put, dependency management is the process of identifying and tracking crucial tasks, activities, or components that rely on each other to keep your product development on track, and then working to resolve any conflicts that could prevent the successful execution of each initiative. It’s about making sure all the pieces fall into place at the right time, in the right order, so nothing topples your development or release planning.

Before we get ahead of ourselves, let’s just make sure you’re all clear on what a dependency is.

There are many types of dependencies – don’t worry we’ll get to those in a bit. But, to help illustrate what we’re yacking off about, here’s an example. 

Imagine you’re working on a new feature that requires input from Designers before development can begin. The dependency here is that the designers need to deliver the final designs before the development team can start building the feature. If the designs aren’t ready, the whole process gets delayed.

This dependency impacts time coordination and creates a risk of miscommunication. That’s why managing dependencies is so important. 

Dependency management is like playing a high-stakes game of Jenga: if one block isn’t where it should be, the whole tower comes tumbling down. By managing what needs to be done in order to complete another thing, you’ll keep your team aligned, well-communicated, and prevent risk to avoid any bottlenecks.

Why is dependency management important? 

If not properly managed, dependencies can be disruptive. They can be roadblocks that slow down your product development, leaving team members waiting on others in order to continue. At best, this can be a minor disruption, like a lane closure causing a bottleneck. At worst, it can be a road closure, causing a massive delay in your journey. Poor dependency management can halt the progress on your roadmap. 

And that’s not all. What else can happen when people are delayed on the road? Road rage! If you’ve got team members waiting on other folk to move on, that can cause friction and frustration between your teams, impacting your work environment. This issue shouldn’t be understated. Prolonged delays and issues can lead to teams preferring to work in silos, which isn’t great if you want to create an efficient and aligned product. 

As a Product Manager, the dream is to have your roadmap followed to the exact pixel. Of course, we all know that in reality, things can go overschedule and be delivered late. That’s a massive reason why we prefer the agile product development process over timeline-based options. It’s flexible. Still, by following dependency management best practices, you can increase the likelihood that your product-led launch will go as planned.  

Want a full list of all the juicy benefits of dependency management? Of course you do! By managing dependencies well, you’ll: 

• Prevents delays: Poorly managed dependencies can cause bottlenecks. Effective management helps identify and mitigate potential delays by tracking these dependencies in advance.
• Improves cross-team collaboration: Dependencies often involve multiple teams. Managing these relationships ensures clear communication and proper coordination.
• Reduces risks: Unchecked dependencies can introduce risks, like a critical feature not being ready or a resource becoming unavailable.
• Ensures resource alignment: Managing dependencies allows Product Managers to allocate resources more effectively. It helps them prioritize tasks, so resources aren’t wasted. You don’t want expensive Developers sitting there with nothing to do!
• Boosts accountability: By clearly defining dependencies, teams and individuals know who is responsible for what and when. This enhances ownership and accountability.
• Supports better planning and forecasting: Managing dependencies enables better timeline estimations and more accurate release planning, ensuring that all components are aligned and ready when needed.

What are the types of dependencies in Product Management? 

There are different ways that tasks and ideas can be dependent on others. If you’re to manage them all successfully, it’s important to get a good grip on the different variations that you’ll come across.

Internal dependencies

These are dependencies that are in your control. Dependencies that you set yourself. They’re all the blockers and stuff that must be done within your team before a different task can be started. 

For example, an internal dependency might be when Engineers need designs from the UX Team before they’re able to start writing code.

External dependencies

These dependencies are when you’re waiting on things from people or teams outside of your direct control. You could be waiting for things from a different team within your organization, or waiting for something from a third party or external team.

A very common example of this is when you’re waiting for assets from a third-party vendor before you can crack on.

Mandatory dependencies 

These are non-negotiable dependencies. Fixed, and unavoidable walls that you’re going to have to smash through before you can continue. A mandatory dependency describes a step that must happen before another. You can’t jiggle the order around to make things work. 

This article – or more so the process of creating this article – is a great example of a mandatory dependency. It needs to be written before it can be published. Otherwise, there’d be nothing to publish. 

Of course, this example sounds like common sense, but a lot of the time mandatory dependencies are just that. That’s why it also goes by the name of ‘hard logic’. 

Discretionary dependencies

These dependencies are more flexible and can be changed and ignored if you really really need to. Of course, you shouldn’t just ignore discretionary dependencies. Often, they’re ensuring that you’re following best practices and going about your product development in a way that suits your team’s preferences.

This article once again brings up a good example of a discretionary dependency. Before the article is published, it needs to be peer-reviewed by another product expert. Now we can ignore this step and just get the content out there, but we follow this step to make sure our content maintains the accuracy and quality you come to expect from ProdPad.  

Setting up discretionary dependencies helps you build a more efficient order of work.

Time-sensitive dependencies

These dependencies are exactly what they say they are. They’re deadlines. Things that need to be done by a certain point in order to move on and keep the development on schedule. There are multiple different types of time-sensitive dependencies, such as:

• Finish to start: One task can’t begin until another is completed. 
• Start to start: Can’t start one task until another is kicked off. 
• Finish to finish: You need to finish one task before you can finish another. 
• Start to finish: You can’t finish one task until another starts. This one is rare but could describe moving from a legacy system where you can’t shut down the old one until the new one is all up and running.

Now time-sensitive dependencies get a lot of focus and are the type that many Product Managers try to get a handle on quickly. This is because having a strict deadline adds innate pressure. This need can lead Product Managers to plan their roadmaps with dates and deadlines front and center in their mind, producing hellish Gantt charts. 

We don’t think this is the way it should be. We think you should break up with Gantt chart roadmaps. Instead, you should manage your dependencies in an Agile roadmap like our Now-Next-Later horizon-based roadmap (invented by our very own Co-Founders). Now there’s a bit of a belief, a myth, that you can’t manage deadlines on an Agile roadmap. We’ve got our heads in the cloud and just do things when we feel like it. That couldn’t be further from the truth. 

Yes, we don’t want you to get bogged down in the deadlines, planning your entire roadmap by hard dates that add arbitrary pressure and lead to corner-cutting. But, if there’s a dependency you can’t avoid, there’s a dependency. In ProdPad, you can manage dependencies by adding them to your Ideas and Initiatives giving you visibility when refining and prioritizing your Roadmap. 

Want to see what else you didn’t know you could do in ProdPad? Book a demo and we’ll walk you through all the ways ProdPad can save your time and supercharge your Product Management.

What are dependency management best practices?

Here’s a quick snapshot of some of the things you should be doing to nail your dependency management. If you want a more comprehensive rundown, offered by one of the top product thought leaders around (we’re slightly biased as she’s our Co-Founder) on how to approach dependency management when working to an agile framework and using a Now-Next-Later roadmap, Janna Bastow has written a great article which is worth a read.. Consider this glossary post as the flashcards, and Janna’s piece below as our thesis on Dependency Management.  

Identify them early

When planning the development of a product, make sure you’re aware of all dependencies early on. Having eyes on them from the start prevents any nasty surprises. Do this for both internal and external dependencies. 

Prioritize your dependencies

Once you know what your dependencies are, rank them in terms of importance. Not all dependencies are going to hit the same. Figure out and highlight the ones that if missed could derail the whole process and work hard to resolve these dependencies first to prevent blockages down the line. 

Create clear ownership

There’s only one thing worse than waiting on someone to get things done. Waiting on someone who doesn’t know they’re being waited on. Make sure every dependency has a clear ownership. Whose responsibility is it? Whose shoulder does it fall on?

By giving your dependencies an owner, it ensures that someone is on hand to manage the potential blockade and stay accountable. 

Review and update dependencies 

Your dependencies aren’t always set in stone. They can change as your product does. Deadlines can get shorter or further away, and an important blocker may not be a blocker anymore. Plus, new risks and roadblocks could crop up that you’ll want to address quickly. That’s why it’s important to review your dependencies and reprioritize. 

It’s exactly the same principle as backlog refinement. By keeping your roadmap up to date, you’ll be able to edit dependencies to ensure that it’s current and reflects where you are in the Product Management life cycle. 

Avoid hard deadlines 

Say you have to get something done before you can get the next task started. For the love of God, don’t wed yourself to an exact deadline and declare to all the world that the subsequent task will kick off on that same date. You have to maintain a degree of flexibility so you’re not having to rework your entire release plan when one task (somewhat inevitably) overruns. 

Because, let’s face it, things do overrun. A lot. Deadlines can be missed. If you set a firm deadline for the first task, and miss it, that’ll just knock back all the other hard deadlines for everything else that’s dependent on it, making things far more stressful and creating a bunch of planning admin to do. 

Instead, you want to remain flexible, and avoid committing to exact deadlines so you limit the number of interested parties who are waiting at the other end for the feature and have expectations of an exact date. 

And look, if something has to have a hard deadline (say there’s a legal requirement to meet a compliance standard by a certain date), then work backward in your planning from that deadline and make sure you have enough buffer time between dependencies to give yourself a fighting chance of hitting those dates. Yes, you probably have to start earlier, but you’ll get yourself into far less of a tangle when it comes to your dependency management.

Use a tool

You don’t want to track dependencies in your calendar or a tool separate from your roadmap. That’s messy, confusing, and just gives you another tool to worry about. Instead, you should manage your dependencies directly on your roadmap, where they can be seen alongside the tasks and ideas you have prioritized and that are in the pipeline. 

These best Product Management tools will give you this dependency management functionality, so look for a tool that gives you these options. Book a demo and we’ll show you how to manage dependencies directly in ProdPad. 

Who’s responsible for Dependency Management?

Dependency management is the responsibility of everyone that’s working off a single roadmap. Everyone needs to be aware of their dependencies, and have an idea of what they’re waiting on for others. It’s a team effort to get a product built and launched, so it’s a team effort to manage these roadblocks and ensure that work is done in the correct order. 

With all that said about shared responsibility, the Product Manager does hold ultimate responsibility. So although it’s down to the whole team, the Product Manager is the one that’s overseeing the smooth execution of the roadmap – so this falls under that remit. 

In your role, you need to identify the dependencies during the planning phase, track how these impact your plan, and communicate with the stakeholders on what they need to do and what the risks are if dependencies aren’t executed.

Within the rest of the product trio in the product team structure, some responsibility also falls on your Engineers, especially the lead Engineers and Developers. These folk will be responsible for finding and disclosing technical dependencies, so will need to share progress and make sure that they deliver on time. 

In short, as the Product Manager, the buck stops with you, but you can take comfort that the rest of your team will also be on hand to help out.