3 KPIs for Software Development Team Efficiency

A lot of development teams want to be more efficient in their work. The word efficiency may have various meanings. The definition that I see more suited for software development is “a situation in which a person, system, or machine works well and quickly”. Or to put it another way, a team is efficient when it is doing things right. In this post, I will talk about three key performance indicators (KPIs) you should keep under control to review the health of your codebase and of your team.

KPIs for Software Development

In this first section, we will examine three different KPIs for software development that together will give you a quick glance at your codebase and on your development process. These are not the only KPIs that you can measure, but they easily give you a lot of information and they are quite easy to measure. These features make them a great choice when choosing the KPIs that you want to keep under control.

1. Code Coverage

The first metric that I want to analyze is Code Coverage.  Code Coverage is a measure to describe the amount (percentage) of code covered by automated tests. Most of the test runners have some kind of option to show the coverage after each test suite execution.

Why Code Coverage is Important

Automated tests are a very important factor for a healthy codebase for a lot of reasons, probably too much to cover all of them in this post. Two characteristics in particular related to efficiency stand out. The first is correctness. If a specific piece of code is heavily tested we are more confident that the code is doing what it is supposed to do, leading to less rework or bugs. The second is evolvability. If I work with a codebase that has a high degree of coverage, I feel quite confident to change the code quickly to adapt to new business needs, without the fear of breaking things in production.

How to Improve Code Coverage

Like I said before, most of the test runners have the specific option to show coverage. Usually, to improve the coverage you need to grow awareness on the importance of testing in your team. In order to do that, the first step is to keep the coverage monitored after every commit and visible to all the members of the team. There are a lot of tools that you can integrate into your continuous integration pipeline. For example, coveralls can easily integrate with your Github repository and show a coverage report for every commit as you can see in this live example.

2. Code Quality

With Code Quality metrics we want to measure some intrinsic characteristics of the codebase. You can think about these metrics like some kind of overall picture of the code, where you can easily pinpoint the major problems. There are a lot of code metrics that you can measure, but the most important ones are:

• Cyclomatic complexity
• Duplicated blocks
• Lines of code per element
• Coupling

Why Code Quality is important

Usually, code quality comes hand in hand with a codebase with a good level of maintainability. It’s quite intuitive that looking for a bug in a complex or coupled codebase is not easy. Some quality metric tools like CodeClimate assign a rating from E to A to your codebase, taking into consideration many elements. It also provides a fancy Github badge.

How to Improve Code Quality

Some of these metrics are inherently related to the seniority of the team members. For a junior developer, it could be really hard to understand why it’s important to keep your codebase “tidy” and in good shape. Good techniques that you can use to help your developers in building a better codebase are Pair Programming and Peer Review.

3. Availability Metrics

The first two KPIs for software development that I’ve covered focus on code metrics.  These alone do not uncover the full picture about your team’s efficiency.  To do this, you should also consider measuring availability metrics to holistically evaluate the complete process, from coding to delivery. To measure availability we can evaluate  KPIs such as:

• Mean-time between failures (MTBF)
• Mean-time to recover/repair (MTTR)

To measure both metrics you can rely on the tool chosen with your Q&A team or, if you work with a smaller team, you can build a custom solution. For example, you can use a simple Trello board to track incidents or bugs and build a custom plugin to track failures/repairs.

Why Availability is Important

These kind of metrics are extremely important because it’s a very good way to understand if there’s any bottleneck in the process. By understanding your team’s availability metrics, you can also be more realistic with timelines, as you can better understand what areas require more or fewer resources based on how much rework will realistically occur.

How to Improve Availability

When your availability is not good enough, and all your code metrics seem fine, there’s probably a communication problem in your organization. For example, if you have a short MTBF and good quality metrics, but a very long MTTR, there might be a problem in your deployment process.  Perhaps a siloed OPS department or other communication problems exist. In this scenario, start introducing DevOps methodologies to reduce the MTTR.

The Human Factor

An interesting thing to notice is that most of the time, to improve the values of your KPIs you should work on developing your people. This may seem strange at first, but it’s completely normal. Remember that Uncle Bob says that “Programming is a social activity”. Another way to explain this characteristic of custom software development is with Conway's law, that states 

“Any organization that designs a system (defined broadly) will produce a design whose structure is a copy of the organization's communication structure.”

So, when you have some underperforming KPIs, that are mining your efficiency, try to focus on the people who may need more development as they have a direct impact on these KPIs.  You might find this article on Skills Every Junior Dev Needs for Success quite helpful for addressing how to develop those team members.

Doing the Right Thing

I would like to conclude this post with a paradigm shift. All the KPIs for software development that I explained until now help to better understand and improve efficiency. But concentrating just on the efficiency of your team may not be enough to build successful products. It’s like concentrating on driving a car as fast as possible, but without looking if the car is going in the right direction. 

A focus on your team’s effectiveness shifts our mindset to not just doing things right, but also to doing the right thing. To better understand the meaning of efficiency and effectiveness, remember that the former one measures outputs, while the other one measures outcomes. This concept is explained extremely well in this video by Jeff Patton.

Output vs. Outcome & Impact from Jeff Patton on Vimeo.

How to Improve Effectiveness: Measuring Outcomes

As you can imagine, measuring outcomes is way more complex than measuring outputs. So’ it’s impossible to define a pool of metrics that can actually measure effectiveness for every kind of business. You may correlate the effectiveness for your team with customer retention, annual revenue or even customer satisfaction. It is deeply tied with your business and your actual context. Nevertheless, there are some exercises that you can use to define goals and metrics for your project like this one from Atlassian. If you have a team (and managers) that feel at home talking about goals and outcomes you can also try to use some more advanced tools like Impact Mapping and Lean Value Tree in order to create a backlog of user stories that will be driven by a measurable business goal.

Conclusion

If your software development team is looking to step up their performance and has not had a key set of KPIs to measure efficiency and effectiveness to date, introducing these metrics to the team may be a challenge in the beginning. Changing is hard, and everybody knows it. But changing without measuring is impossible. KPIs for sofware development are a fundamental part of every improvement path for high performing teams that your team should want to embrace. At the end of the day, KPIs are simply numbers, but by regularly reviewing these metrics and goals for improvement you can ensure your team’s reputation for quality and dependability will be one to imitate. 

If your team has implemented a set of KPIs and has seen some awesome results, I’d love to hear about your story in the comments below!