My project manager is losing confidence in the development team. The PMs are seeing late deliveries and bugs that suggest the devs just aren’t capable enough. I think that poor communication and differing team cultures might be part of the problem, but how can I know for sure?

It’s a good question. Lack of confidence in a dev team can be caused by any number of factors, including:

1. The dev team is, in fact, weak.
2. The team’s technical skills are solid, but they’re undermined by poor communication, especially around requirements and expectations.
3. Past failures, e.g., missed deadlines, bugs, or downtime make it impossible to reestablish trust. This can be true even if those failures had nothing to do with the current team.

But how do you know which? If you’re grappling with this issue, identifying the specific cause can be difficult, especially if you don’t have a software background. (This is where a technical review can be useful!) Don’t worry – we can help. In this post, we’ll show you how to identify common signs that a dev team isn’t performing as expected, even if you’re not that technical.

Before we review the symptoms, though, please bear this in mind: If your team shows these signs, it doesn’t necessarily mean they’re weak. It means that you – or someone you trust – need to dive in to figure out what’s going on.

The Founder-Developer Gap and A, B, C Players

The challenges that business leaders face when assessing development teams are a good example of the Founder-Developer Gap. The fact is, developers operate in a world that outsiders can’t easily understand. It’s hard to know if a developer is an A, B or C player, or a player at all. And in the software world, an A player is worth 10+ C players!

Unfortunately, there are a lot of C players out there. When we interview potential developers, we’re always amazed at how many can’t answer basic programming questions. It makes us wonder, how did these folks graduate from their CS program or their bootcamp? And how did they build their impressive resume? (Maybe with ChatGPT!)

The Symptoms

Here are the red flags we hear about most often. These are the worries that keep team leads up at night. Knowing how to spot these signs can help you keep your business on track.

1. Missed deadlines.
2. Last minute scope-cutting to avoid missing deadlines.
3. Delivery of code that has clearly not been tested.
4. Marking bugs as fixed that aren’t fixed.
5. Racking up massive overtime.
6. Lack of communication between developers.
7. Dev teams without a clear leader.
8. Rogue developers with their own agenda.
9. Private bits of code that are jealously protected by a single dev.
10. Shifting blame and finger pointing.
11. Fixing one bug breaks something else.
12. Developers seem unconcerned about bugs or system downtime.
13. Developers become annoyed at testers for finding bugs.
14. The same bugs/problems occur over and over again, and no one wants to find the source of the problem.
15. New features always require significant rewrites, and consequently a lot of time.
16. Developers can’t explain why changes will require more or less development time.
17. During team meetings, developers are quiet when bugs, features, changes are being discussed, only to come back with questions later.
18. Rapid turnover, especially of senior or “A” developers.
19. Developers aren’t aware of the progress of the current dev cycle, or even what’s in it.

And the #1 symptom relates to that old software engineering adage:

The first 90% of a project takes half the time. The last 10% takes the other half.

From a CEO’s perspective, this translates into:

The team made great strides early on, but it’s taking forever to get it done.

If you’re seeing some of these symptoms, you may have a weak development team. But to repeat our previous warning, you might not! There may well be other problems keeping your team from being effective. To find the answer, you’ll need a deep-dive analysis. But it’s best to start with a phone call for a quick reality check – and we are happy to do that with you.

What Makes a Team Strong?

It’s useful to approach this problem from the opposite direction. What are some characteristics of a strong team?

A strong development team should have the following:

• A high service level and availability of their product/system.
• A high throughput of effective change.
• A low amount of unplanned work.
• A culture of change management.
• A culture of continual improvement.
• And a culture of root-cause analysis.

If your team shows these characteristics, then make sure they know they’re appreciated! And don’t be surprised if you see some weaknesses and some strengths. That’s to be expected.

Recovery is Extremely Hard

Software development is challenging. Asking the right questions during requirements gathering – which is essential – doesn’t come naturally to most devs. Edge cases are easy to miss, even for experienced programmers. Aggressive timelines and pressure from management create plenty of opportunities to introduce bugs.

Early failures by a development team can make it difficult – next to impossible, really – to recover trust. If your co-workers or your manager think you’re doing a bad job, it’s very hard to overcome that perception.

Bottom line: If you have concerns about your development team, read the list of symptoms carefully. If you find yourself nodding your head in agreement, you might have a weak team.  And it never hurts to get an outside opinion!