Teams who are building software and completing projects depend on customer feedback, internal resource constraints, third-party products...and, especially each other. 🤜🤛Keeping track of all of these dependencies is difficult for a single agile team and even harder for multiple teams. Fortunately, it can be managed — and managed at scale. Enter dependencies management — the process of identifying, troubleshooting, and resolving any dependencies that can keep other projects from being completed.
Let's say one piece of working software depends on an external plugin. If that plugin fails to operate, then the working software may fail as well. 🔌 Similarly, large organizations working on multiple software projects at once often have some projects that depend on others in order to get done. This is why agile teams need processes to monitor dependencies so they don't disrupt software development.
The more complex dependencies become, the more you need good dependencies management to control them at scale. Technical tools, like Maven, have their own use cases to manage dependencies among plugins and libraries across a software project.
Similarly, agile frameworks such as LeSS and SAFe can help with dependencies management in large organizations. Finally, finding ways to visualize the dependencies in an organization is a highly effective way to mitigate the risks of delaying projects.
Want to empower your team to implement the Scaled Agile Framework (SAFe)?Try Easy Agile Programs
Now, close your eyes and imagine the rest. Just kidding, read on...as if your agility depends on it. 😂
Types of dependencies in project management
Before we discuss tools and frameworks, let's outline a few different types of dependencies:
- Direct dependency: This common dependency type in project management is where one project directly depends on another.
- Transitive dependencies: This is an indirect connection between two projects, usually by way of another project that connects them. Ex., Project A depends on Project B; Project B depends on Project C. Therefore, Project A indirectly depends on Project C.
- External dependencies: These dependencies are out of your organization's direct control. For example, a portion of a project may not be able to proceed until your customer approves of it.
We'll mainly focus on agile frameworks for organizational dependency management, but if you are interested in dependency management software, let's start with an overview of Maven.
Maven: Dependencies management software
Maven is an open-source build automation tool primarily used in Java projects. One of its core pieces of functionality is managing the different types of dependencies in a software project via its Apache Maven dependency plugin.
Maven helps manage large dependency trees with many transitive dependencies. For example, if Plugin A depends on Plugin B, which depends on Library C, Maven can detect that with your project by using a Project Object Model (POM). This is an XML file that contains information about a project's configuration details and allows Maven to detect dependencies.
Ok, timeout — this can get a little confusing. Transitive dependencies are like making a pizza (really). You need dough to make it. But you need eggs and flour to make the dough. (You also need a farm with chickens and wheat, but you get it.) Similarly, with transitive dependencies, one task needs to be completed for the other to take place.
💡Pro tip: Make a dependency tree that looks like a pizza recipe. Your team will love it (pro tip #2: Bring pizza).
Here’s a high-level overview of how Maven operates, based on their comprehensive Introduction to Dependency Mechanism:
- Defines and maintains reproducible builds with well-defined classpaths and libraries
- Automatically discovers transitive dependencies in your classpaths and libraries
- Helps identify build version conflicts and dependency versions
- Creates dependency scopes to limit the transitivity of a dependency, with six different scopes: compile, provided, runtime, test, system, importing
Think of Maven as a technical framework that helps software development teams to identify, understand, and resolve dependencies across its entire system of plugins and libraries. Now, let's apply the same ideas to teams in large organizations who have the same types of dependencies. In other words, let's make dependencies management more human. 😁
Agile frameworks for organizations to improve dependency management
You're probably pretty familiar with the most common agile frameworks for software development — Kanban and Scrum. These frameworks are mostly suited for individual team organizations. But what about frameworks for cross-functional agile teams in a large organization who need help with dependencies management?
LeSS for dependency management
LeSS is a framework that helps multiple Scrum teams who are working together on a single project to scale. Think of LeSS as Scrum at a large enterprise scale — you still have a single product backlog, a product owner, a Scrum master, and software developers. But the key difference is that there are many teams working towards the same goal and the same definition of done (rather than a single team).
One of the most important tasks for the product owner role in the LeSS framework is making sure that dependency information is provided across teams. In LeSS, product backlog refinement (PBR) is an organized event that makes sure dependency risks are consistently identified. PBR allows multiple teams to plan sprints in parallel and to identify if there are any cross-team dependencies that risk project completion.
SAFe-ly managing dependencies
The SAFe framework provides principles and workflow patterns to guide organizations through their project dependencies. The idea behind SAFe is to promote transparency and alignment across large organizations so they can be more nimble in meeting their business objectives.
Unlike startups, who are small and can typically make organizational changes quickly, large organizations often become too big to make rapid changes. One common cause of this is the inability to manage dependency resolution because dependencies are less visible for cross-functional teams.
Just as Scrum has ceremonies to keep a single agile team aligned, an essential ceremony to keep multiple teams in the Scaled Agile Framework communicating with each other is Program Increment (PI) Planning. It’s a way to keep even the largest organizations nimble.
Program Increment Planning for large organizations
PI Planning is a periodic meeting that happens throughout the year. Teams within an organization gather to compile their thoughts on product features and the product roadmap, and to discover any dependencies that exist between them.
One key feature of PI Planning is a program board. Program boards help give programs — a group of agile teams working together on a common goal — a visual and digital representation of what the teams have planned to complete from their PI Planning.
Visualize your dependencies
Easy Agile Programs for Jira is a complete tool for dependencies management at a program level. By utilizing visualizations and by providing transparency across projects, teams can confidently scale without the risk of work disruptions. It does this by providing three views:
- Program roadmap: an overview of all of the scheduled increments or iterations for a program
- Increment overview: an at-a-glance visualization of all of the teams within a program, including all of their cross-team dependencies
- Team planning board: where teams schedule their work for the program increment
Unlock your organization's common dependencies
Additional functionality in Easy Agile Programs for Jira uses visual cues and views to assist in dependencies identification.
- Visualize dependencies: Red, Amber, and Green dependency lines highlight project bottlenecks and aid a project manager in where to focus.
- Team organization: Team swimlanes, dependencies, and milestones are all organized visually. Making sure that all of your organization's work is represented and visible on a board helps keep teams aligned.
- Focus mode: This involves focused views of tasks assigned to teams and how they are linked across sprints.