In the past, I’ve read dozens of articles on software development performance metrics trying to understand how to measure programmers’ work. But instead of clear definitions, all I got was frustration and headache. It’s as if the authors deliberately chose the most twisted and wordy way of narration to confuse the readers.
So, I’ve decided to write an article on software development productivity measurement. I did my best to make it as clear as possible so that non-developers could understand software engineering metrics. Hopefully, you’ll enjoy reading this article as much as I enjoyed writing it.
- What are software development metrics?
- Role of metrics in software development
- Software development KPIs
- Types and Examples of Software Development Metrics
- Six Main KPIs in Agile Software Development
- How to measure productivity in software development
What are software development metrics?
Let’s start by breaking down the core term: software development metrics. In brief, these are groups of numerical measurements that give the full picture on the development team performance and efficiency; the extent of client satisfaction; software quality and performance; time, costs and other resources spent on the project; and more. From this article, you will realize that some of them are easy to understand and quantify while others are abstract and subjective.
Usually, all software development productivity metrics can be divided into two basic types:
- Project metrics. This type measures the effectiveness of the teamwork over a particular project throughout a specified time span.
- Software metrics. This type measures the quality of the software product delivered to the client.
There is much confusion between terms “metrics” and “key performance indicators” – “KPIs” in the context of software engineering. Prepare yourselves for the biggest secret: these terms are used interchangeably in various sources. Yes, metrics and KPIs are not technically the same, but the difference between them is considered irrelevant in this context. In fact, if you read several articles, you will definitely notice that in some of them, such terms as “velocity” or “code churn” are referred to as “metrics,” while in others as “KPIs.”
In order to bring clarity to this article, the term “metrics” is used here to denote a group of key performance indicators used to measure a common target. For example, metrics for software development projects comprise several KPIs, all of which are used to measure how well developers perform. It still may sound confusing, but don’t worry: the types of metrics and the definition of a KPI for software development will be described in more detail further in this article.
Role of metrics in software development
Metrics are important for companies and teams that want to increase the number of new projects as well as enhance the quality of communication and software and specialists’ working speed.
Thus, all relevant metrics are highly useful for:
defining strong sides of development and project management specialists;
- determining, analyzing and eliminating weak sides of specialists and processes;
- optimizing working processes;
- estimating capabilities and skills of specialists;
- reducing time and resources spent on the software development process;
- creating the most effective management patterns and business development strategy;
- increasing brand loyalty;
- getting more satisfied and returning clients.
Basically, the primary role of metrics in this context is to analyze the quality of the entire workflow of a particular team and make it the most efficient.
Software development KPIs
The term “KPI” stands for “key performance indicator” and means something that can be measured in order to evaluate a project, developer, team, and so on. A good KPI has to be SMART. This means it should:
have a Specific purpose, in our case – a purpose relevant to software engineering;
represent a Measurable entity in order to be easily evaluated and compared among different time periods;
be Achievable, not some unobtainable perfect score that can exist only in theory;
be Relevant to the performance of a particular software company and to to the specifics of the whole industry in general;
have Time constraints, meaning that a KPI should represent a value over a set period of time, such as a week, a year, a month, etc.
Basically, everything that can be calculated and presented in numbers can serve as KPIs. For example:
- rating from 1 to 10 (client satisfaction)
- number of tasks, sprints, and hours spent on their fulfillment
- percentage (such as code coverage by testing)
Types and Examples of Software Development Metrics
There are so many software metrics currently in use that it’s difficult to get a clear look at them. Luckily, it is possible to categorize them based on various factors or specific features. Perhaps, the most natural and plain choice is to distinguish the metrics depending on what is measured. So, in the software development industry, metrics are used to measure the following:
Developer productivity metrics show how many hours were spent on development and how efficient the work was. It is the main instrument to evaluate and plan the workflow of a team and a company as a whole. Examples:
- Assignment scope - an average amount of work generally assigned to a specialist. For programmers, it can be the amount of code they can write during one year/month.
- Active days - the number of days a specialist participates in a project.
- Code churn - an amount of code, usually measured in lines, that a team had to change, remove or add during a work period. Less churn means a team does not have to rewrite large parts of software because they work as intended, so the team is more efficient and productive than the teams with higher code churn.
- Efficiency - similar to the code churn metrics but applied each specialist separately. It shows the percentage of code provided by a particular programmer that does not have to be altered in relation to all amount of code written by that specialist. An efficient developer delivers more productive code and contributes little to code churn.
Agile metrics show how well a development team performs using the agile approach. This type is rather extensive and complex but also widely used in the software development industry. That’s why, to explain various agile metrics properly, they will be described in detail in a dedicated section below.
Software operation quality
Software quality metrics have a self-explanatory name – they indicate how well a software application is built. In particular, this group of performance indicators represents how often a “production” version of an application crashes and how fast it returns to the working state. The names of specific KPIs that belong to this group also speak for themselves. They are Mean Time Between Failures (MTBF), Mean Time to Recover (MTTR), and Application Crash Rate (ACR). The latter is the number of the application fails divided by the number of its uses. Software quality is also governed by international standards, such as ISO/IEC 25010:2011.
Even though software development companies have specialists called QA (quality assurance), every developer should test their own code. Testing metrics commonly include code coverage percentage, also known simply as “test coverage,” which should always go up to 100 percent because it is basically a self-check. Other indicators to mention are the number of automated tests created and conducted, and the number of bugs/defects found and fixed. All testing metrics are important for software quality, and they are easy to define and calculate, which makes them a popular choice among development teams. These metrics are also tied to the security of the resulting software product.
These metrics are tricky because the majority of client experience measurements are somehow subjective. The most widely used indicators among client satisfaction metrics are:
- Net Promoter Score (NPS) – shows to what extent a person or a company is loyal to your brand and services, and whether they will be your returned client or not. In addition, NPS indicates to what extent your client wants to recommend your products and/or services to other companies.
- Customer Effort Score (CES) – in other words, it is the measurement of a client’s engagement in the product development process. This indicator always depends on the clients themselves and their desire to be involved in the project. While some clients just want to get the final result and be occasionally informed on the progress, others want to check every task and be present on the daily meetings with the whole team.
- Customer Satisfaction Score (CSAT) is another client loyalty indicator with blurred lines. You can give two separate clients identical scopes of products and services, but you have no guarantee that they will be identically satisfied. Even though this score should be stable, the company’s services must be flexible to achieve the highest satisfaction of each client.
Code metrics represent the features of the program code that have a direct impact on the performance of the software product. Generally, they are considered less important than other types of metrics because they contribute less data to the improvement of a development team and rarely represent the team goals. Examples: Lines of Code (LOC) - literally, the number of code lines in a resulting product, and Instruction Path Length – how many instructions are required to execute a part of a software program.
As a rule, fewer lines and lower complexity are better. The principle of Occam’s razor works great in software development: a simple and concise solution is better than a complicated one. It requires fewer resources to store and execute, less time to test, and so on.
Six Main KPIs in Agile Software Development
Agile metrics are invaluable for teams that employ the agile approach to software development. They are the source of valuable insights for those who know how to use them and interpret the results. There are many KPIs that reveal different aspects of the work process. Here are the most popular and illustrative of them:
- Lead time. The universally accepted definition of the lead time is a period between the moment when a task is created and added to the backlog and the moment when this task is completed. However, pay attention: some teams use this indicator to show how long it takes to deliver a software product. In this broader sense, the lead time is a period from a client’s request to the release of a requested solution.
- Cycle time. It is a part of the lead time that comprises the period of work on an issue. Namely, it is the lead time of the task minus the time when that task was in the backlog and to-do list.
- Team velocity. Projects are commonly divided into sprints to make the development process the most efficient and optimized for the team. Each sprint has a number of certain tasks that must be completed and closed by its end. Team velocity indicates the number of completed tasks within a sprint. However, this indicator is rarely used for extensive productivity analysis and comparison between different teams and projects because sprints often have different scopes of tasks, task sizes and complexity, etc. That is why each team has a unique velocity. If one team has a higher velocity than the other, it does not mean that the team with lower velocity is less productive.
- Open/close rates. This KPI shows the number of issues that were taken in progress and successfully closed within a certain time period. Just the number of issues won’t give enough information for analyzing team efficiency because a specialist can work on one difficult task for a week while their peer developer can deliver twenty small and easy ones for the same period. That is why specific numbers are less important than the general trend.
- Sprint burndown. While this is not a KPI in the common meaning, it is very popular due to its easy-to-use and illustrative nature. A sprint burndown chart represents the workflow over the project. It clearly shows how much work has already been done and how much is still left. Ideally, the chart can be averaged as the straight line that steadily lowers towards the mark of zero tasks or work hours. By the way, if you encounter the term “story points” in the context of software engineering – that’s basically the synonym to “tasks.”
- Cumulative Flow. This is a diagram that illustrates the relationship between time and the number of tasks or issues on the project. It is specific to the kanban method and shows the whole bulk of work distributed according to different stages of the work process. Namely, the cumulative flow diagram indicates what percentage of tasks are in the backlog, in work, in review, and have been completed at certain points of time. It is an excellent illustration of the project workflow and task distribution that reveals all bottlenecks or excessive capacity of the team. Ideally, the capacity and the workload should be in equilibrium; otherwise, the product owner and the team members should discuss the ways to balance these two measures.
How to measure productivity in software development
The use and choice of metrics are highly subjective and depend on the peculiarities of a development company and the personal preference of managers. There are no strict rules and compulsory choices of metrics that guarantee success for a development team. However, there are some recommendations and useful tips to maximize the benefits of metrics for software developers.
- Do not try to use as many metrics as possible. Numerous ratings, scores, and indicators will just bury you in numbers. A few carefully selected metrics will provide a more significant advantage.
- Choose metrics that have synergy with each other. The selected combination of metrics must provide the full picture of the teamwork observed from different aspects.
- Metrics serve to improve the team. It is highly important to understand that metrics must be used to reveal the weak spots of the team, the bottlenecks in the working process, and other flaws in order to correct them. Do not just measure work for the sake of measurement.
- Metrics should not be imposed by the management as some compulsory law everyone has to obey. The best results can be achieved when the whole team discusses and agrees to adopt certain metrics to reach maximum efficiency.
- Choose only those metrics that are easy to understand, track, and analyze. Metrics are meant to guide the team, not to confuse it.
- The obtained numbers, scores, and other indicators should be the topic of regular meetings and conversations among the whole team. By discussing them, the team will find a common solution to optimize work processes and improve performance.
- Pay attention to trends, not just numbers. Use metrics to track the dynamics of the workflow, how it changes on a daily/weekly basis or after each adopted decision.
As you can see, there are numerous software development metrics to choose from. They can provide valuable insights that help your team improve. However, the wrong choice of metrics will provide you only sets of numbers loosely related to your work. Metrics are powerful instruments but only in the hands of specialists who know how to use them properly.Our development teams conveniently use a range of metrics that help them coordinate the work and deliver the top-quality products in time. Contact us to get effective software solutions built according to agile principles.
Leave your comment