Capturing different metrics will help you to measure and visualise your engineering team’s performance. This article discusses three different metrics you can measure to detect problems like lack of ownership during code reviews, technical debt, or choking points with key team members. Therefore, let’s look at how we can improve your team’s performance.
Here are three important metrics you can measure to understand your engineering team’s current performance. On top of that, these metrics form an excellent basis for further improving your engineering team’s performance by continuously measuring their performance.
Lead time refers to the time needed from feature description to feature implementation in the production environment. It’s a great metric to evaluate the smoothness of your engineering processes.
For instance, processes that cause a lot of friction, lack ownership, or don’t have a clear description will negatively affect the lead time. The level of automation is another crucial element that determines your engineering team’s lead time. For that reason, it’s a must-have metric to track your overall performance.
On top of that, your lead time can help your product team plan new features and their capacity. It helps them to make realistic feature roadmaps and allows for clear communication to your clients. Also, a realistic roadmap puts less pressure on your developers, which is good for the overall mood and retention. High developer stress is one of the primary reasons why developers decide to look for an alternative job.
Some teams prefer to count the number of PRs developers complete per sprint. However, it’s not a great metric to measure because it doesn’t represent your team’s actual velocity. On top of that, it’s not a fair metric as some developers prefer to create smaller PRs, and senior developers will often complete more PRs. The same is valid for counting the number of commits per sprint. It’s not a metric that you can easily compare week by week.
Therefore, it’s better to assign story points to each issue so you can measure the total number of story points you complete per sprint. You can then map this number week by week to get a graph.
Story points provide an effective way to detect technical debt. In other words, measuring sprint velocity is a great strategy to make technical debt more visible. It’s important to quickly detect the on-ramp of technical debt as it has a significant impact on your team’s performance in the long run.
You may have many automated processes to deploy your code to a test environment and run tests against it. However, code reviews can still slow you down. Therefore, you should measure the time needed to complete a code review.
Often, pull requests lack clear ownership, or the process lacks clear acceptance criteria. In these situations, teams don’t know when a pull request is ready to be accepted or not. This uncertainty will slow down the review process.
Also, many teams have more experienced developers who take care of most code reviews. They can easily get overwhelmed by all the pull requests they have to review besides their work. It’s a major blocker for development teams who put too much stress on their senior developers. For that reason, it’s important to diversify the knowledge across multiple developers so not only your senior developers are responsible for accepting pull requests.
In short, track who’s doing code reviews and how long it takes to accept pull requests into your codebase. It will help you to understand choking points that slow down your team’s code review completion time.
Here is a list of items to take note of to improve your engineering team’s productivity.
When doing a code review, it’s essential to tag the right people to review your code. As a best practice, you want to tag at least one person that has a good understanding of the part of the codebase you’re working on. Moreover, you should tag at least one other developer who knows less about this specific code so they can review if the code meets the style guide and acceptance criteria.
This approach makes sure that at least one other developer learns about a specific part of the code to avoid technical debt. Many teams lack clear ownership for code reviews because they don’t know who to tag for their review. Avoid this at all costs!
Internal documentation explains key concepts like your project’s architecture, tools, and technologies. On top of that, it should be a living document that reflects the current state of your codebase.
Documentation helps your team to make better strategic decisions about your code and improve your code quality.
Weekly or bi-weekly retrospective meetings allow your team to share progress updates and technical knowledge. Often, teams will pick one or multiple developers to showcase important code snippets or architectural design decisions that affect all developers in your team. It’s a great moment to actively share knowledge in an informal setting.
Often, junior developers perceive a barrier in regards to asking for additional explanations from senior developers. Therefore, a retrospective meeting can remove this barrier and boost knowledge sharing across your team.
Lastly, retrospective meetings help teams to discuss problems and propose solutions. For instance, a particular pull request took seven days to merge instead of the maximum three-day rule. You try to reason what went wrong and draw conclusions from the mistake. Each meeting should have a couple of working points for the team to review during the next meeting to see if the problem has been resolved and the team improved its performance.
Don’t expect immediate results from measuring several metrics related to your team’s performance. It’s important to consistently measure these metrics and plot them on a graph to get better insights. You’ll only be able to draw conclusions after a couple of weeks of collecting data. It’s a big mistake to give up early on measuring team performance data because you don’t see immediate results or can’t conclude.
If you want to improve your personal productivity, I highly recommend checking out these 10 VS Code extensions that my engineering team is using.
Start prioritising tech debt today.