Obstacles are inevitable, it`s how you handle them that matters.

In this article, we`re going to explore some of the most common blockers slowing down development teams and how to overcome them to avoid costly delays or rushed, subpar deliverables.

Understanding blockers in Agile development

There`s a common misconception that to consider something a “blocker” it needs to bring work completely to a halt. However, most of the time in development, blockers act more as drag factors than show-stoppers. This means they can significantly slow down progress and prevent development teams from reaching their goals without stopping them entirely.

Simply put, anything that either stops or slows down delivery can be considered a blocker or impediment. The main focus in Agile is to solve issues that slow down the team before they get to a point where development is blocked entirely.

Blockers can manifest at any stage of the development process, from the actual coding and code review to testing and deployment. Here are a few scenarios:

• The development step takes longer than expected due to unforeseen technical challenges, shifting requirements, or resource constraints.

• Commits are delayed towards the end of the sprint. Pull requests grow larger and larger making the code review process more time-consuming and issues harder to spot.

• Testing and QA are postponed until the end of the development process. Errors and bugs are caught late and additional resources are needed to fix them.

• Last-minute fixes introduce new vulnerabilities. Tests have to be rerun or even worse rewritten to cover all possible cases, therefore delaying deployment.

Handling dependencies

Software development processes are highly interconnected. Not only because blockers in one step can have a ripple effect on the next step, but also because software development teams work with a lot of dependencies. While dependencies help maintain a structured workflow, they can also introduce additional bottlenecks and interfere with developer efficiency.

Internal dependencies arise when one task depends on the successful completion of another. For example, authentication relies on storing user data securely, therefore the team must first set up the database before implementing authentication. Internal dependencies are intrinsic to the project and they are managed within the team.

In comparison, external dependencies are typically beyond the team's direct control and involve interacting with other third-party services, APIs, vendors, and teams to solve the issue.

Managing both internal and external dependencies is crucial for the project to move forward smoothly without one element blocking the progress of the next.

Uncovering silent blockers

Most of the time, blockers are easy to spot because they have a visible effect on the rhythm of your work. However, silent blockers can chip away at your team`s productivity or well-being in a more subtle manner and even be more costly in the long run.

Maybe a Product Owner is overcommitted and cannot support any of the multiple teams they are working with 100%.

Or maybe the team doesn`t feel comfortable sharing the challenges they are facing because they fear judgment and reprimand.

Whatever the case might be, to understand and address blockers effectively you need to consider all the signs pointing to a potential issue.

Signs you might be experiencing a blocker

Paying attention to these symptoms allows you to address them before they become a deeply rooted problem.

1. Deadlines are consistently missed or tasks are stalled without being sure when they will be completed.

2. Tickets are accumulating in the “On Hold” column or there are too many tickets marked as “In Progress” without any real progress.

3. There is increasing conflict between team members. Communication breaks down and feedback is delayed or insufficient.

4. Team members keep switching between tasks until dependencies are resolved, leading to confusion and disruptions in the workflow. 

5. The team has to work additional hours to compensate for the lost time.

6. The lack of clarity combined with increased conflict and workload led to burnout and low morale within the team.

Working with blockers, instead of against them

Although they can be very disruptive, blockers are also great opportunities for problem-solving and growth if handled correctly.

Working “against blockers” provides only a limited solution, because you are focused on fixing the issue without understanding its underlying cause.

By working “with blockers” instead of against them, you can understand what they are telling you about your processes, team management, and technical ecosystem overall. Sometimes blockers point to a broader problem that you need to address.

Let`s explore the steps you can take to make the most out of project impediments.

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

Project status meetings are great opportunities to discover and discuss any challenges your team might be facing or has faced. Agile practices like daily stand-up meetings, retrospectives, and sprint planning can help you identify issues and dependencies early on in development and prevent them from escalating.

Testing early and often is also key in identifying and handling blockers. As code is continuously integrated and tested, you can deal with unexpected issues as they surface instead of during the production process. Regular code reviews, automated testing, and integration testing can provide your agile development team with additional insight into potential blockers.

Once you`ve identified that something is slowing down your team, how can you prevent it from happening again? There are several methods you can use to get to the root of the problem.

Understanding the 5 Whys

“The 5 whys” is a simple technique where you ask and answer “why” repeatedly to understand a problem you are facing and the solution. Here is a quick example:

The blocker: Project requirements are unclear.

Why?  Because the initial requirements-gathering phase did not involve all key stakeholders.

Why?  Because there was a miscommunication about who should be involved in the process.  

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

Why?  Because the project kickoff did not include a discussion about communication protocols and stakeholder engagement.

Why?  Because the focus was primarily on technical aspects and not on the overall project management and coordination.

Solution: Implement a communication plan that outlines stakeholder roles and responsibilities when gathering project requirements.

Exploring cause and effect

Ishikawa or fishbone diagram is another method you can use to break down a problem into connected issues and discover the real cause behind it.

The head of the fish represents the blocker you are trying to solve, while the ribs are associated dependencies.

For complex projects, you can group dependencies under various categories like “People”, “Processes” or “Tools” to prevent you from going too far down the rabbit hole.

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

Finding patterns

Most times, after an issue is resolved everyone gets back to their regular business and the problem is forgotten. Documenting blockers and finding patterns is an essential way to make sure the problem doesn`t reappear.

Blocker clustering is a Kanban technique that helps you group similar obstacles according to a common cause and solve them all at once. Combined with root cause analysis techniques like the ones above, blocker clustering can significantly speed up problem-solving.

Step 2. Evaluate and prioritize blockers

Sometimes eliminating a blocker can cost more than the actual delay it causes. This is why it`s important to evaluate and prioritize obstacles. Ask yourself these questions first before deciding if and how you should address them.

Impact

• How is the blocker affecting progress? Has work slowed down or stopped?

• What are the consequences of not addressing it?

• Does it have an impact only on productivity or does it also increase risk?

Time

• How time-sensitive is the blocker, is it affecting critical milestones?

• For how long has the blocker been affecting work?

• How long will it take to solve it?

Cost

• How costly is the blocker to fix?

• How costly is the delay caused by it?

• Are there other non-monetary costs involved?

Step 3. Implement solutions and track progress

Once you understand blockers in-depth and prioritize them you can determine how to solve them, whether it`s allocating more resources, improving processes, or updating technology. Whatever your action plan is, make sure to track progress.

Evaluating performance should go both ways:

• Check if the provided solutions actually solved the issue.

• Measure software engineering productivity to catch any latent issues or new potential bottlenecks.

While there`s a lot of debate surrounding productivity metrics, a good practice is to track processes instead of outputs. So instead of counting lines of code you can look for example at how long code review takes to see if something is interfering with the workflow.

Types of blockers affecting development teams and how to solve them

Blockers come in many shapes and sizes. Let`s look at a few more examples of blockers affecting software development teams and ways to address them.

1. Technical blockers

Bugs and Errors

Bugs and errors are notorious for causing delays and forcing developers to rewrite code. The later you catch them, the more expensive they are to fix. Test-driven development (TDD), automated testing, and better code review practices can significantly reduce the impact of errors and bugs.

By writing tests before writing the actual code, teams can spot issues early and maintain a clean codebase. Similarly, using a CI/CD approach means automated tests are run as soon as the code is integrated, providing a solid feedback loop for development teams. Keeping pull requests at a manageable size can speed up the code review process and help remove blockers faster.

Integration and dependency problems

The need to integrate different components, modules, and services can slow down software engineering teams due to the countless dependencies involved. These can range from waiting for internal work to be completed to delays caused by integrating third-party APIs or various libraries.

Dependency managers can help coordinate the integration of external libraries and packages in your application. Also, by including dependency management into your project management approach you can start keeping track of all these interrelated tasks and resources before they become blockers.

The Critical Path Method is a technique that allows you to determine the longest stretch of dependent activities and measure it accordingly.

Infrastructure Limitations

Outdated tools and technologies, as well as constraints imposed by hardware, software, or network infrastructure, can quickly turn into productivity blockers. Regular infrastructure assessments and updates ensure that your development team has all the necessary resources to complete tasks without having to put out additional fires.

Technical debt

Shortcuts and quick fixes during development can accumulate over time slowing down progress. The code becomes harder to read and understand and the system harder to maintain and update. Putting in place coding standards to verify code quality, as well as setting aside time for regular refactoring can prevent technical debt from accumulating in the first place.

However, sometimes technical debt is inevitable, as in the case of dedicated development teams working on legacy applications. Fixes made by countless teams before them can turn refactoring into a difficult process, maybe even requiring a complete rebuild.

Blockers stemming from legacy software need to be addressed through proper documentation, testing, and release processes, and a thorough analysis of code quality, stability, and security.

Unfamiliar tools and technologies

Working with new tools or technologies comes with its own learning curve, although the initial slow-down will surely pay off in the long run. Investing in continuous training and supporting developers while they get up to speed is an important aspect of building high-performing teams.

Peer programming is a useful method to upskill and mentor junior developers by pairing them with experienced team members.

2. Process blockers

Poorly defined requirements and workflows

Unclear project requirements can quickly spiral out of control. Because team members don`t understand the direction of the project, they can either overestimate or underestimate the amount of work and they have a harder time anticipating potential technical challenges.

This can also lead to assigning tasks to developers who don`t have the required skill set for that particular project.

A well-defined procedure for gathering requirements is essential in safeguarding your project against future bottlenecks. Establish clear roles, responsibilities, and goals within the team, document requirements in-depth and establish a roadmap team members can fall back on.

Clear requirements go hand in hand with efficient workflows.

Scope creep

Scope creep occurs when requirements stretch beyond the initial, agreed-upon vision. When projects overstep their initial goals, tasks can start piling up leading to missed deadlines and overwork.

To counter scope creep, it's essential to have in place clear user stories, specs, and a change management strategy. Discuss any additions to these documents and agree upon the changes with all involved stakeholders.

Carefully evaluate the impact of these additional features on the project timeline and resources.

Inadequate task and time management

If your team has too much work in progress, is multitasking a lot, or is switching between tasks frequently, then you might be experiencing task management issues. These issues might prevent you from having a clear view of the project, making it more difficult to prioritize tasks, and set realistic deadlines.

Focus on unblocking work rather than adding more assignments. Motivate team members to take ownership and help move the tasks forward. This will reduce the time spent switching between tickets until dependencies are resolved and it will encourage more focused problem-solving.

Last but not least, limit the amount of distractions and unnecessary meetings to encourage deep work.

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

3. Communication blockers

Communication breakdown

Poor communication can be not only a source of frustration and misunderstandings but also a serious blocker. Communication barriers can affect the quality of work and the efficiency of the team.

Regular check-ins, investing in collaboration tools, and establishing feedback and follow-up protocols can nip problems in the bud before they escalate into a full-blown crisis.

Support cross-team collaboration by setting up a centralized communication method anyone can use.

Knowledge silos

As development projects grow, knowledge about the project tends to get fragmented and spread across the team. To put it simply, knowledge silos appear when one person has information that someone else doesn`t.

This can lead not only to duplicate work but also to a lot of miscommunication.

Fostering a culture of knowledge-sharing ensures everyone is on the same page and has enough information to understand the project, communicate efficiently, and tackle bottlenecks when show up.

Moving forward

In the fast-paced world of development, blockers are the hurdles that test your team's agility and determination. By identifying blockers, implementing strategic approaches, fostering communication, and optimizing resources, you can empower your development team to move forward and transform blockers into growth opportunities.