9 December 2015
In my last blog post, I wrote about the four most important attributes a dependency management tool should have: real-time visibility into process, peer-to-peer collaboration, program-level prioritization, and scalability. We took those four aspects as a starting point to build a practical, intuitive and easy to use dependency management solution. In this blog post, I’ll tell you how Mingle’s dependency management solution addresses all of the attributes needed for a first-rate dependency management tool.
At the project level, Mingle provides a project dependency tab. This view gives you a high level glance at all of the dependencies that your project has raised on others, or dependencies that have been raised on your project.
The Program-Level Board is where all the stakeholders concerned with cross-teamwork can see all dependencies across multiple teams and projects. To access the program board, you must first go to the project board, then click on the blue and white Mingle logo in the upper left-hand corner of the screen. Click “Programs”, opening up the list view of programs. Then click on “Dependencies” and you will see a view like the one below.
In this program-level dependency board, stakeholders can see a dependency move between New, Accepted and Resolved statuses. Mingle has supported real-time changes for a while, so that everyone is working on the most updated version of the card wall. This board allows people at higher levels to at least see all the dependencies, even if they don’t need to take action on them immediately.
The Dependency Raising and Accepting Mechanism allows a team to raise a dependency on the other team in or outside of a Mingle program. The dependency can be raised directly from any story or work item. Users can click the + symbol right next to Dependencies section on the story card as shown in the figure below to raise a dependency.
When a dependency is raised, the team on whom the dependency was raised is notified, and can choose to accept the new dependency. To accept a dependency, the resolving team needs to connect one of their existing story cards to it. Doing this allows underlying teams to follow their team-specific processes or methodologies and plan work on their own terms.
Team members also benefit from the easy-to-see, color-coded dependency icons in cards. Teams can use the icons to decide when they should work on a raising story that was blocked due to a dependency, for example.
On the program board, managers can identify the most important dependencies by applying filters based on their own criteria. This ability to filter the most important, conflict-causing or blocked dependencies means the program-level stakeholders can focus their attention on what’s most important and leave it up to teams to manage and resolve other dependencies.
Given the peer-to-peer nature of the solution, stakeholders are only required to help teams if they see a certain dependency not moving, or in scenarios where there is conflict or confusion.
As with the rest of Mingle, the dependency solution is very flexible and customizable to fit your team’s or program’s needs. You can create custom filters, alter card settings, and use one of the pre-made templates to get started, or just create your own workflow. Mingle can scale to even the most complex projects, and gives managers many ways to configure the boards to fit individual programs or teams.
The new dependency solution sits on top of the existing Mingle solution. Configuring a project to use the dependency feature is fairly simple. Each project admin can decide if other teams can raise dependencies on their projects by going to: Project Admin → Project Settings → Advanced Options → Dependency Settings → "Allow all projects to raise dependencies on this project”. Projects that accept dependencies will now have a new “Dependency Tab”. Also, adding a project to a program will by default allow other projects in that program to raise dependencies on each other.
This new feature was made available in our Mingle Plus edition on December 9th, 2015. In the first version of the solution, users will be able to:
1. Raise a dependency from a card in a project
2. Accept a dependency which was raised on your team by some other team
3. Provide end to end visibility of the dependencies raised across project at the program level
4. Provide teams the ability to show dependency transitions from New to Accepted to Resolved stages
5. Let audiences at the program level, filter program wide dependencies based on their unique criteria so that they can bubble up the most important dependencies matching their criteria
6. Provide visual indication on the card when a card raises or is resolving a dependency
7. Provide ability to view a dependency and its details at the raising project, resolving project and at the program level
8. Provide ability to delete dependencies
9. Provide ability to move a dependency forward – New – Accepted – resolved as well as backward from Resolved – Accepted – New