One of the hardest parts of overseeing an engineering organization is measuring productivity. The nature of the job makes it tough to see what your software development teams are struggling with, what areas they need improvement in, and how productive they’re actually being. Let alone convey their productivity to non-technical executives and board members.
Some companies resort to metrics like lines of code to stack rank devs (we’re looking at you, Elon), which is great — if you want to kill productivity and motivation.
The solution is to know the appropriate software developer productivity metrics — and how to track them. So, we’ll show you what productivity metrics really mean and give you the best ones to set up your company and dev teams for success.
Table of Contents
- What Are Developer Productivity Metrics?
- Why Tracking Developer Productivity Matters
- Top 5 Software Developer Productivity Metrics
- Start Improving Your Developer Productivity Metrics
What Are Developer Productivity Metrics?
Developer productivity metrics measure your team’s ability to ship high-quality code and deliver features that align to your business goals. TheseThese metrics monitor your teams’ software development lifecycle and enable you and your managers to spot bottlenecks in your development cycles, know what your teams are working on at all times, and improve your development processes.
Why Tracking Developer Productivity Matters
Even Musk — misguided as he is — recognizes the relevance of metrics (even if he’s using the wrong ones).
Whether you’re being asked to lay off staff or have been lucky enough just to get a hiring freeze, you’ve got to figure out how to do more with the same (or smaller) team. Measuring developer productivity helps you accomplish this in two ways:
- You can’t improve what you don’t measure
- Metrics can give you the context needed to have tough conversations with other leaders about prioritization
So let’s look at the right metrics that will help you improve developer productivity (without asking your teams to type faster) and shape conversations in the boardroom.
Top 5 Software Developer Productivity Metrics
1. Cycle Time
Cycle time is like the speedometer of your engineering organization. It’s an important metric that measures the time between when work starts and when it is delivered. We split cycle time into four phases:
Teams that have shorter cycle times in all phases are highly performant ones — and they frequently produce higher-quality code. Teams that rank highly in this area can deliver more features with greater speed and dependability.
This single metric is extremely helpful for identifying bottlenecks, too. When you take a look at each phase within your team’s cycle time, you’ll see exactly what parts of the process are slowing down your dev teams. You can then start to take action to resolve those pain points, giving your dev teams a breath of fresh air.
How to Track It
Your teams can (and probably do) track cycle time in a few different ways. The most common way is with the control chart in Jira, but this requires top-notch data hygiene in your project management tool. And let’s be honest, that’s not likely.
LinearB uses your Git data to measure your average cycle time, and it also measures the four phases of cycle time. This gives you valuable insight into what area needs improvement. With just one click, you can see which individual Git branches are creating bottlenecks. We even show you how you’re doing compared to industry benchmarks.
2. Deployment Frequency
Deployment frequency measures how often your organization successfully releases code to production. Your teams and your business want to deploy as often as possible because it means you’re delivering an improved product to your customers.
Elite teams often make deployments several times a day, while strong teams deploy anywhere from once a day to once a week. If your teams are deploying less frequently than that (and assuming you’re already using a CI/CD tool), it might be time to take a look into your other metrics — like cycle time or specifically deploy time — to find out why.
How to Track It
To determine your engineering org’s deployment frequency, you’ll want to track how many deployments you’re making in a given period. If you want to go old-school, just write down whenever your teams deploy and track it over time.
If you’re already using a CI/CD tool like Jenkins, you can get alerts when your teams deploy. Or better yet, you can integrate your Jenkins account with LinearB. Our Business tier comes with deployment frequency and the other 3 DORA metrics right out of the box.
3. Merge Frequency
Merge frequency is the total number of PRs or merge requests over a specific period. Let’s face it; no one likes a laundry list of unfinished tasks. The cognitive load required to stay on top of a PR that’s been sitting idle for 5+ days — constantly pinging the reviewer for updates and then finally trying to get back into the flow and review the requested changes — well, it sucks the life out of your devs and cuts into their productivity. When code finally gets merged, your devs get to cross this item off their to-do list — and we all know how amazing that feels.
Tracking your merge frequency is so much more effective at measuring developer productivity than individual metrics like lines of code because it demonstrates your teams’ ability to collaborate. Software development is a team sport. Typing more lines of code and creating more pull requests is useless unless that code is actually being merged. This is also why merge frequency is a great way to take the pulse of your developer experience. Merging devs = happy devs.
How to Track It
You could manually count the number of merges in a time frame to get an idea of your engineering org’s merge frequency, but who would want to do that?
LinearB tracks merge frequency for you automatically. You can get it — on top of cycle time and the other developer experience metrics — with our free tier because we think it’s that important of a metric for all teams to measure. We also offer tools that help you improve your merge frequency and developer experience.
4. Investment Profile
Your investment profile is a measurement of how much time your teams spend on different kinds of work. When you’re talking to other VPs and the C-suite, they always want to know how your engineering org is performing. But when you go to tell them about the commits and story points your teams completed, they shut you down. They don’t care about that!
They want the hard facts — are your teams working on things that align with business needs? Are they delivering new features and fixing bugs? Tracking your investment profile answers these questions perfectly. With it, you can show what your teams are working on, broken down by your issue types.
How to Track It
Some people use the single-level group by report in Jira to see issues grouped by a specified field. For example, you could create an issue filter to retrieve all issues completed by type, which might help you convey how much effort your team is putting into new features vs bugs vs technical debt. But this isn't great because each report only shows you one issue type at a time. What you need is one chart that combines all the different issue types.
Our Investment Profile report pulls in this information from Jira using your issue types and automatically calculates it all for you. And this way, you can see exactly what teams are working on — and where they’re spending too much effort — so you and your managers can help them maximize their productivity and prioritize tasks that really matter.
5. Planning Accuracy
Planning accuracy is a ratio of how many issues or story points were finished out of the total number that were planned for in an iteration. This metric determines how accurate your sprint planning is.
Our Engineering Metrics Benchmarks study found that the average planning accuracy across 1,900 Scrum teams was less than 50%. Meaning that, in most cases, your teams aren’t delivering what was planned on time.
When engineering can deliver on its promises, positive effects ripple through the entire company.
- Marketing campaigns can be designed and launched
- Executives can more confidently commit to revenue targets
- New features can be promised to clients, and deals can be signed
Tracking your planning accuracy breakdown helps you see what’s going on in your sprints, such as unplanned work and carryover work. If, for example, you have low planning accuracy and a trend of unplanned work each iteration, you can improve your planning accuracy by having a conversation with your product team about scope creep.
How to Track It
So far, not one single method proved to be a solid way to track planning accuracy. A burndown chart will show you the number of stories that have been completed during the sprint and the number of stories remaining. But it won’t tell you whether those story points were part of the planned story points. And we all know added work and carryover work will inevitably happen.
So we created the planning accuracy breakdown report as a part of Project Delivery Tracker. It helps you visualize all the things that impact your planning accuracy, so you can address and eliminate any issues.
Start Improving Your Software Developer Productivity Metrics
Now that you’ve got the right metrics, you can finally paint a picture of how your teams are being productive in multiple ways. And with these metrics in your arsenal, you’re equipped to confidently create and communicate a plan for developer productivity improvement to your board and execs where needed.
That’s why the LinearB platform is so great! It’s not just for measuring productivity, but improving it, too. For instance, our Team Goals feature and workflow automation tool, WorkerB, enable you to standardize your improvement plan and streamline your processes so you and your managers can actually help your devs to be more productive (rather than just harping on them).
If you’d like to see how much of an impact tracking these developer productivity metrics can make, check out how Hippo managed to increase their productivity with LinearB.