How to Solve Blockers Slowing Down Your Development Team

Challenges are bound to happen, but it’s all about how you address them.

In this article, we will delve into some of the typical issues that can impede the progress of development teams and discover strategies to overcome them, preventing expensive delays or rushed, substandard outcomes.

Understanding blockers in Agile development

There is a common misconception that for something to be labeled a “blocker,” it must completely stop your work. However, in development, blockers often act as impediments that slow down progress rather than bring it to a standstill. They significantly impede development teams from reaching their goals without necessarily stopping them altogether.

In simple terms, anything that stops or hinders delivery can be considered a blocker or impediment. In Agile, the primary focus is on resolving issues that hinder the team’s progress before they escalate to the point of complete blockage.

Blockers can emerge at any stage of the development process, ranging from coding and code reviews to testing and deployment. Here are some scenarios:

1. Development takes longer than anticipated due to unexpected technical challenges, growing requirements, or resource limitations.
2. Commits are delayed towards the end of the sprint, leading to larger pull requests that make code reviews time-consuming and issues harder to identify.
3. Testing and quality assurance are delayed until late in the development process, resulting in the late discovery of errors and bugs that require additional resources to correct.
4. Last-minute fixes introduce new vulnerabilities, requiring reruns or, worse, the rewriting of tests to cover all potential cases, delaying deployment.

Handling dependencies

Software development processes are intricately linked, and this connection can affect both the immediate and next stages of development. Moreover, development teams often rely on various dependencies, which can be a double-edged sword. While dependencies help maintain an organized workflow, they can also introduce potential bottlenecks and decrease developer productivity.

Internal dependencies emerge when one task depends on the successful completion of another within the same project. For instance, implementing authentication requires a secure user data storage system, requiring the setup of the database before authentication can be developed. Internal dependencies are inherent to the project and are managed within the team’s control.

On the other hand, external dependencies typically lie beyond the direct influence of the team and include interactions with third-party services, APIs, vendors, and other teams to address the issue.

Efficiently managing both internal and external dependencies is essential to ensure the project progresses smoothly, without one element obstructing the advancement of the other.

Uncovering silent blockers

Blockers in software development are often noticeable, as they disrupt the team’s workflow and progress. However, there are also silent blockers that operate more subtly, affecting team productivity and well-being over time, and these can ultimately prove more costly.

For instance, a Product Owner might be juggling multiple teams and is unable to fully support any of them.

Alternatively, team members might hesitate to communicate the challenges they encounter, afraid of criticism or consequences.

To effectively identify and tackle blockers, it’s essential to be attentive to all the signs hinting at potential issues, whether they are visible disruptions or quieter, but equally impactful limitations.

Signs you might be experiencing a blocker

Being alert about these symptoms enables you to tackle issues before they even show themselves:

1. Missing deadlines or tasks consistently, stalling with uncertain completion dates.
2. A growing backlog of tickets in the “On Hold” category or an excessive number of tickets marked as “In Progress” without genuine progress.
3. Rising tensions among team members, resulting in poor communication and delayed or inadequate feedback.
4. Frequent task-switching among team members until dependencies are resolved, causing confusion and workflow troubles.
5. The team resorts to working extended hours to compensate for lost time.
6. A lack of clarity, coupled with intensified conflict and workload, promotes burnout and low team morale.

Working with blockers, instead of against them

Blockers, despite the troubles, can serve as valuable opportunities for problem-solving and growth when managed effectively.

Working “against blockers” offers a quick fix, addressing the issue without delving into its root cause.

However, adopting a “working with blockers” mindset allows you to discern the deeper messages they convey about your processes, team management, and the broader technical ecosystem. Blockers can often point to underlying issues that require attention.

Let’s delve into the steps you can take to maximize the potential benefits of project blockers.

Step 1. Identify blockers and understand what`s causing them

Project status meetings offer valuable opportunities to uncover and discuss any challenges encountered or anticipated by your team. Agile methodologies, such as daily stand-up meetings, retrospectives, and sprint planning, facilitate the early identification of issues and dependencies during development, helping prevent them from escalating.

Frequent and comprehensive testing is another crucial aspect of identifying and addressing blockers. Continuous code integration and testing enable a fast resolution of unexpected problems as they arise, rather than waiting until the production phase.

Regular code reviews, automated testing, and integration testing provide additional insights into potential blockers for your agile development team.

When you’ve pinpointed a slowdown within your team, the next step is to prevent its recurrence. Several methods can help you address the root of the problem effectively.

Understanding the 5 Whys

“The 5 whys” is a straightforward technique involving repetitive questioning and answering with “why” to delve into a problem and its solution. Here’s a quick illustration:

The issue: Unclear project requirements.

Why? Because not all key stakeholders were involved in the initial requirements-gathering phase.

Why? Due to a misunderstanding regarding who should participate in the process.

Why? Because there was no established plan outlining roles and responsibilities.

Why? Because the project kickoff lacked a discussion about communication protocols and stakeholder engagement.

Why? Because the primary focus was on technical aspects rather than overall project management and coordination.

Solution: Implement a communication plan detailing stakeholder roles and responsibilities during the project requirements-gathering phase.

Exploring cause and effect

The Ishikawa or fishbone diagram is another approach to dividing a problem into interconnected issues and uncovering its root cause.

In this diagram, the head of the fish symbolizes the blocker you aim to resolve, and the ribs represent related dependencies.

For intricate projects, you can categorize dependencies into different groups such as “People,” “Processes,” or “Tools” to maintain clarity and prevent excessive complexity.

Source: https://clickup.com/blog/fishbone-diagram-templates/

Finding patterns

Usually, once a problem is resolved, people return to their normal routines, and the issue is left behind. However, documenting blockers and identifying patterns is a critical method to prevent the problem from recurring.

Blocker clustering, a Kanban technique, aids in categorizing similar obstacles based on a shared cause and addressing them collectively. When used in combination with root-cause analysis techniques mentioned earlier, blocker clustering can substantially quicken the problem-solving process.

Step 2. Evaluate and prioritize blockers

Occasionally, removing a blocker can be more expensive than the delay it creates. Therefore, it’s essential to assess and prioritize obstacles. Consider these questions before determining whether and how to address them:

Impact

• How is the blocker influencing progress? Is work slowing down or at a standstill?
• What are the repercussions of not resolving it?
• Does it impact productivity alone, or does it also increase risk?

Time

• How time-sensitive is the blocker? Is it affecting critical milestones?
• How long has the blocker been impeding work?
• What’s the estimated time required to resolve it?

Cost

• How expensive is it to fix the blocker?
• What’s the cost of the delay caused by it?
• Are there additional non-monetary expenses involved?

Step 3. Implement solutions and track progress

Once you have a comprehensive understanding of blockers and have prioritized them, you can decide on the appropriate solutions. This might involve allocating more resources, streamlining processes, or upgrading technology.

Whatever course of action you choose, it’s crucial to monitor progress.

Performance evaluation should be a two-way process:

• Verify if the implemented solutions effectively solved the issue.
• Measure software engineering productivity to detect any lingering problems or potential bottlenecks.

While there’s ongoing debate about productivity metrics, a useful approach is to assess processes rather than outputs. Instead of focusing on metrics like lines of code, consider evaluating factors such as the duration of code reviews to identify any obstacles in the workflow.

Types of blockers affecting development teams and how to solve them

There are various forms and dimensions of blockers. Let’s examine a few instances of obstacles impacting software development teams and methods to resolve them.

1. Technical blockers

Bugs and Errors

Bugs and errors are well-known for causing delays and requiring code rewrites, and the later they’re identified, the costlier they become to fix. Practices like test-driven development (TDD), automated testing, and enhanced code review techniques can significantly mitigate the impact of these errors and bugs.

By crafting tests prior to coding, teams can detect issues in the early stages and uphold a clean codebase. Likewise, employing a continuous integration/continuous deployment (CI/CD) approach ensures that automated tests are executed immediately upon code integration, creating a robust feedback mechanism for development teams. Maintaining pull requests at a manageable scale can quicken the code review process and facilitate the removal of obstacles more easily.

Integration and dependency problems

Integrating various components, modules, and services can create bottlenecks for software engineering teams, thanks to the numerous dependencies in play. These can encompass waiting for internal tasks to be finalized or delays resulting from the integration of third-party APIs and assorted libraries.

To streamline the integration of external libraries and packages in your application, dependency managers prove invaluable. Moreover, incorporating dependency management into your project management strategy enables you to proactively monitor these interconnected tasks and resources, preventing them from evolving into blockers.

The Critical Path Method stands out as a useful technique for identifying the longest sequence of dependent activities and assessing it systematically.

Infrastructure Limitations

Obsolete tools and technologies, along with limitations imposed by hardware, software, or network infrastructure, have the potential to become productivity hindrances.

Conducting routine infrastructure evaluations and implementing updates guarantee that your development team possesses the essential resources to complete tasks without the need to address unexpected issues.

Technical debt

Taking shortcuts and opting for quick fixes during development can accumulate over time, restricting progress. This results in code that’s more challenging to comprehend and a system that’s tougher to maintain and update.

Establishing coding standards to validate code quality and allocating time for periodic refactoring can proactively prevent the accumulation of technical debt.

Yet, in certain scenarios, technical debt may be inevitable, especially for dedicated development teams working on legacy applications. The multitude of modifications made by previous teams can transform refactoring into a complex effort, possibly needing a complete rebuild.

Blockers arising from legacy software should be tackled through comprehensive documentation, testing, and release processes, in addition to a thorough assessment of code quality, stability, and security.

Unfamiliar tools and technologies

Engaging with new tools or technologies inevitably involves a learning curve, even though the initial slowdown will certainly yield long-term benefits.

Prioritizing continuous training and providing support to developers as they adapt is a necessary component of developing high-performing teams.

Peer programming emerges as a valuable technique for enhancing skills and mentoring junior developers by teaming them up with seasoned team members.

2. Process blockers

Poorly defined requirements and workflows

Vague project requirements can lead to chaos. When team members lack a clear understanding of the project’s direction, they may either overestimate or underestimate the workload, making it difficult to anticipate potential technical hurdles.

Furthermore, this can result in assigning tasks to developers who lack the necessary skill set for the project.

To protect your project from future bottlenecks, a well-defined procedure for gathering requirements is critical. This includes defining distinct roles, responsibilities, and objectives within the team, documenting requirements comprehensively, and establishing a roadmap that team members can reference.

Clear requirements and efficient workflows are closely connected.

Scope creep

Scope creep becomes a concern when requirements extend beyond the originally agreed-upon vision. When projects exceed their initial objectives, tasks can accumulate, resulting in missed deadlines and excessive workloads.

To fight scope creep, it’s important to establish clear user stories, specifications, and a change-management strategy. Any proposed additions to these documents should be thoroughly discussed and require agreement from all relevant stakeholders.

Additionally, it’s essential to conduct a thorough evaluation of how these additional features may impact the project’s timeline and resource allocation.

Inadequate task and time management

When your team struggles with an excessive workload, multitasking, or frequent task-switching, it shows task management challenges. These issues can impede your ability to maintain a clear project overview, making it harder to prioritize tasks and set achievable deadlines.

Instead of piling on more tasks, concentrate on removing obstacles to progress. Encourage team members to assume ownership and assist in advancing tasks. This approach minimizes the time spent switching between tasks until dependencies are resolved and promotes more concentrated problem-solving.

Lastly, to encourage deep work, limit distractions and unnecessary meetings.

Source: https://www.atlassian.com/

3. Communication blockers

Communication breakdown

Ineffective communication can pose not only a source of frustration and misunderstandings but also a significant limitation. Communication barriers have the potential to impact work quality and team efficiency.

To address this, regular check-ins, the usage of collaboration tools, and the implementation of feedback and follow-up procedures can mitigate issues before they evolve into major problems.

Furthermore, boosting cross-team collaboration by implementing a centralized communication method accessible to everyone can enhance overall communication effectiveness.

Knowledge silos

As development projects expand, project knowledge often becomes fragmented and spread within the team. In essence, knowledge silos emerge when one individual possesses information that others do not.

This situation can result in both redundant work and a substantial amount of miscommunication.

To counter this, cultivating a culture of knowledge-sharing ensures that everyone is well-informed, promoting a common understanding of the project.

This, in turn, promotes effective communication and equips the team to address bottlenecks as they arise.

Moving forward

In the dynamic realm of development, blockers serve as challenges that assess your team’s adaptability and resolve.

Through the identification of these limitations, implementation of strategic methods, promotion of effective communication, and the optimization of resources, you can empower your development team to advance and turn blockers into opportunities for growth.