When problems appear in an app or website, for some people the first move is to blame the developer(s). Sure, it’s true that the developers wrote the code. But the reality is that bugs are rarely the fault of any one person or group. There are many reasons why developers shouldn’t always be blamed for bugs. A developer’s build could have a bug for many different reasons, including:

  • Vague or incomplete acceptance criteria
  • A regression (when a fix or new feature causes problems with older code)
  • Issues with specific devices or browsers based on new updates
  • Rushed timelines in an Agile process

Between these explanations and the reasons below, it’s a good idea to think twice before defaulting blame to developers.

Why Developers Shouldn’t Always Be Blamed for Bugs

1. It’s counter-productive.Reasons Developers Shouldn't Be Blamed for Bugs (picture depicts a developer sitting in front of a laptop with their head in their hands)

Adding extra pressure is only going to make bugs more likely, as insecurity and nervousness interfere with focus. Of course, having some level of accountability is usually helpful (and reasonable). But there’s a difference between asking someone why certain bugs made it through vs. interrogating them with negative assumptions. 

2. Blaming developers for bugs doesn’t always make sense.

There will always be bugs. If that weren’t the case, only teams with awful developers would need QA testers. A typical understanding of the software development life cycle means expecting a certain level of bugs in any staging build.

3. Blame gets passed around.Blaming Developers (picture depicts an office meeting room with four different people appearing to be arguing)

Even if a team places all of the blame on developers, it won’t stay there. When this is the mindset that a team cultivates, the developer(s) will likely end up passing it forward. This can result in blame being directed at QA for missing a bug (that they may not have known was a requirement to begin with), a project manager for not managing Sprint timelines, and many other roles involved.

Again, if a person or group is at fault for an error, they can (and should) still be liable for an explanation or fix. But each situation should be handled based on the specific details involved, rather than painting a role or team with broad strokes.

4. It can delay releases — significantly.

If a developer feels that their code has to be 100% perfect before it can get to QA, it’s no exaggeration to say that they might need months instead of weeks to hand it off. QA exists for a reason, so a developer should be able to do their best first pass and pass it along, knowing that QA testers can identify any bugs in need of fixing. While QA is finding and reporting bugs, the developer(s) can use the extra time to make progress on other new features. This is one of the top reasons why developers shouldn’t be blamed by default for bugs.

Developer Communication (picture depicts two programmers discussing information in an office)

5. Unless you’re the manager, blaming developers for bugs is not your place.

For example, as QA testers, our job is to focus on the bugs themselves. Even if a colleague’s development efforts are problematic enough to be fired over, that’s management’s call. The QA and developer relationship is at its best when QA judges the severity of the bugs, not the worthiness of the developer(s) behind them.

Setting Limits

Avoiding unnecessary blame doesn’t mean that developers shouldn’t be held accountable when their code is riddled with problems. In some instances, it may even be appropriate to let someone go, if their programming issues are severe and consistent enough. But having “some” bugs in any given build is not reason enough to accost a developer. And if you approach each situation rationally, you just might find a reasonable explanation below the surface.

Want to Work with Developer-Friendly QA Testers?

Look no further — we love creating great working relationships with devs. Check out our QA testing services to learn more.