Measuring the actual performance and productivity of a development team is no easy feat. So it can be difficult for managers of software development teams to challenge their team members and help them improve their performance. At Apriorit, we’ve found that using both team and individual metrics helps our managers guide their development teams, and it’s resulted in higher-quality work and better communication.

Measuring Team and Individual Productivity

Because we work by the agile methodology, velocity is a relevant measure of team productivity. We use this metric to help estimate the scope for the next sprint, but it’s limited. Case in point: Leaders can’t compare the velocity of different teams; in fact, they can hardly compare the velocity of the same team in different periods because that also varies — people join and leave the team, go on vacation, and take sick days.

In his book on scrum, Ivan Selikhovkin notes that velocity can hardly be used to predict final delivery schedules.

The delivery schedules can be known not just because the velocity of the team changes with time, but also because team members work on different tasks within the same sprint. Analysts prepare the tasks for the next sprint. Developers implement the current scope, testers finalize quality assurance checks on the tasks from the previous sprint, and so on. Due to these variables, team velocity on sprints won’t be consistent, especially in terms of productivity.

Instead, we rely more on the earned value analysis technique to understand whether we’ll deliver a project on time and within budget, assuming the team performance and project environment remain the same. But we also use an approach that isn’t part of the agile methodology: individual productivity.

Scrum rejects individual metrics, as they contradict the team spirit at the core of the methodology. But as a software development company, we need to measure a developer’s individual productivity in order to create personal development plans, promote employees, detect problems in advance, etc.

When assessing individual productivity, we measure:

• Work within the budget: the percentage of tasks delivered out of the budget and the percentage of extra hours compared to the total amount of time spent
• Work within the schedule: the percentage of tasks delivered out of the schedule and the average percentage of days of delay compared to the total task length
• Implementation quality: the percentage of time spent fixing bugs as compared to the entire time spent on the tasks
• Support quality: the percentage of tickets returned by the quality assurance (feedback tickets) compared to the total amount of processed tickets.

By measuring individual productivity, we ensure that we’re keeping our developers engaged and challenged on both an individual and team level. When developers feel like they’re experts in their domains, they’ll find unique, exciting solutions to problems that less capable teams consider unsolvable.

Setting a Software Development Team Up for Success

Managers and leaders can use these tips to engage their software development teams with more challenging projects that spark their curiosity and competitiveness, thus inspiring them to perform at optimal levels.

1. Establish a non-negotiable system of values.

Rather than rely on situation-, project-, or team-based criteria to guide our work, we formulated seven core values: results, professionalism, cooperation, enjoyment, innovation, stability/predictability, and ecology. All our processes — limitations, decisions, performance criteria, tutorship guidelines — adhere to these traditional company values. And when a manager encounters a new situation with the team, he or she applies our values to determine next steps.

We also use these values in our hiring process. Rather than use IQ or emotional intelligence tests to determine whether a candidate is a good fit, we try to understand whether he or she shares our values. Because these principles guide all our processes, we know developers whose values align with our own will be productive employees.

2. Tutor junior employees.

New employees need a higher level of guidance. That’s why we have senior employees tutor junior team members. Junior employees are usually very creative but often don’t have the professional experience to produce high-quality work. It’s essential to preserve their thirst for creativity by giving them feedback on training and professional skill development. Then, we must show them how to transform those skills into a relevant experience.

At our company, developers produce estimates for their tasks themselves — with their own backgrounds in mind — thus taking responsibility for the task budget. At the early stages of a developer’s career, the project development leader and project manager thoroughly review the developer’s hourly estimate. They may initiate discussion with the developer, request explanations, and provide additional information to get a realistic assessment. The project manager and developer then set due dates according to the schedule and priorities.

As employees develop, we give them more autonomy. They still provide hourly estimates, but we don’t review them as thoroughly — and it works. Our most successful developers are those who entered the company as juniors and completed our tutoring program.

3. Give the team the right communication tools.

Communication within a team shouldn’t be limited to meetings. Several beautiful task management solutions — including Jira, GitLab, and GitHub — have great control tools at both the individual and group level. Regardless of which solution the team uses, effective communication starts with setting up task registration (e.g., questions, propositions, comments) and the management system.

Young, immature teams tend to underestimate the importance of communication tools and processes. They assume that meeting and taking situational notes will be enough. But proper communication is crucial, so teams should adopt an existing communication platform where all processes, objects, and flows are already set up for optimal performance.

4. Trust the team.

The manager understands what should be done, and the development team knows how to do it. Once team members understand the goal, managers must allow them to define the plan of action — and trust that they’ll execute on the strategy. Conversely, the team should trust that the manager knows exactly what to do and has set up the task correctly. Without mutual trust, the project will likely fail. That’s why it’s essential that both parties don’t enter each other’s scope of responsibility.

A good way for the manager to ensure the team’s plan is correctly formulated is to apply the SMART goals framework, describing tasks in explicit terms and making sure that the results are specific, measurable, achievable, realistic, and time-based. After tasks and SMART goals are specified, the manager sets up intermediate control points with defined methods of control, which allow him or her to track progress and detect risks in the process.

During the project, the team should also create a list of risks.

In each control point, there are three possible outcomes: either the team gets what is expected, it doesn’t “get” what is expected at all, or it gets almost what is expected. Trust the team — not the manager — to define the plan of action for each risk.

How to monitor for specific risks.

For example, let’s say the team needs to implement a specific system monitoring feature. The manager describes the task, explains the project’s context, and delivers on the requirements. The team analyzes those requirements, performs task decomposition, estimates each stage, and drafts a list of risks. If team specialists don’t know how to implement this feature, the plan will include a research stage. For example, what if implementation takes more time than expected? After the team has identified risks, the manager will set up a control point to review research results with the team and understand how they affect further feature development.

It’s not easy to measure the productivity and performance of development teams.

Taking the time to make sure that you are selecting the right people and tools is key. Focus on finding people who align with the company’s values and tutor them — then trust that they’ll build effective processes themselves and create corresponding tools to achieve results.

Dennis Turpitka

Founder and CEO of Apriorit

Dennis Turpitka is founder and CEO of Apriorit, a software development company that provides engineering services globally to tech companies, including Fortune 500 tech giants.