What is Developer Velocity and Why It Matters?

Did you know that companies with better developer work environments achieved 4-5x greater revenue growth than their competitors?

But what exactly is developer velocity? And how would you improve it?

Sections: 

‍

The idea of velocity originates from physics: Velocity is a vector quantity that has units of distance divided by time in a certain direction.

Examples include such as miles per second north or kilometers per hour south.

Applied to the world of software development, what largely changes the numerator — the rate at which development work is completed. At a high level it refers to the speed and efficiency with which software developers can create, modify, and deploy high-quality code.

We like the Microsoft definition, which is quite exhaustive it as:

Developer Velocity (DV) is a broad term that describes how we can increase efficiency for developers building software solutions. It involves using the right tools to write software, implementing automated processes for continuous integration and deployment, properly monitoring our software, providing feedback loops, and any method or tool that removes friction for the development team.

‍

The importance of developer velocity (as measured by McKinsey's Developer Velocity Index - how well organizations empower developers through tools, culture, and processes) is strongly correlated with success in today's software-driven world.

McKinsey has identified two key correlations:

1. Faster revenue growth: Organizations with high developer velocity show 4-5 times faster revenue growth compared to their peers

‍

2. Increased innovation: Companies that prioritize developer velocity correlate strongly with a 55% increase in innovation

‍

Without measuring developer velocity, it is difficult to determine whether to assess team performance and identify areas for improvement.

While there's no one-size-fits-all approach, below are the leading frameworks used to assess developer velocity. We also share our process of choosing metrics and implementing here.

DORA metrics

DORA metrics, when first introduced by Google's DevOps Research and Assessment team, focused on 4 key metrics (”the four keys”) that are strong indicators of software delivery performance. This has evolved over time, with updates to a metric and an introduction of a 5th:

• Change Lead Time: The time it takes to go from first commit to code successfully running in production.
• Deployment Frequency: How often an organization deploys code to production or releases it to end users.
• Failed Deployment Recovery Time (Formerly Mean Time to Recovery): The time it takes to restore service when a deployment causes an outage or service failure in production (whereas previously Mean Time to Recovery also included uncontrollable failure events such as an earthquake disrupting service).
• Change Failure Rate: The percentage of changes that result in degraded service or require remediation (e.g., that lead to service impairment or outage, and require a hotfix, rollback, fix forward, or patch).
• Rework rate: This fifth metric was introduced later in 2024, and together with Change Failure Rate provide an indicator of software delivery stability. Since it's a newer addition, there aren’t yet established quantifiable benchmarks and so this metric tends to receive less focus.

SPACE framework

The SPACE framework, proposed by Nicole Forsgren et al. takes a holistic view of developer satisfaction by considering 5 key dimensions:

• Satisfaction and Well-being: Measures satisfaction, fulfillment, and well-being, both at work and off work.
• Performance: Outcomes that the organization aims to reach or create value for customers and stakeholders.
• Activity: Combines outputs that are countable, discrete tasks and the time it takes to complete them.
• Communication and Collaboration: Represents the interactions, discussions, and other acts of collaboration that take place within teams.
• Efficiency and Flow: Focuses on the ability of a developer to complete work or make progress.

DORA and SPACE aren’t necessarily alternatives. In fact, key author Nicole Forsgren has said it is most helpful to consider DORA an implementation of the SPACE framework (specifically capturing Performance, Activity and Efficiency). While DORA is based on metrics that are good for the psychological safety of the teams, it doesn’t directly measure how people are doing. SPACE fills that gap by bringing in more human-centric metrics, such as the well-being of developers, alongside their efforts.

DevEx Framework For Developer Velocity

The DevEx Framework focuses on measuring the lived experience of developers and the points of friction they encounter in their everyday work. The DevEx framework aims to provide a holistic view of the developer experience by considering 3 key dimensions:

• Feedback Loops: The speed and quality of responses to developer actions.
• Cognitive Load: The mental effort required to perform tasks.
• Flow State: The ability to work with focus and enjoyment.

Remember to focus on team level metrics

While individual contributions are important, we recommend emphasizing team-level metrics to encourage collaboration and shared responsibility.

The reality is that the best software is built by cohesive, high-performing teams. PRs are a team sport. When scrutinizing the output of single developers, it becomes difficult to assign credit or accountability because software development inherently depends on teamwork.

In fact, excessive focus on individual performance can actually make the overall performance worse – imagine the brilliant jerk who gets their work done quickly, but at a cost to the rest of the team. In fact, a two-year study by Google called Project Aristotle found that the number one thing for improving performance is building strong team factors, particularly psychological safety.

For all these reasons, we focus on team performance over individual performance.

‍

Research from McKinsey based on an in-depth survey of senior executives at 440 large enterprises shows that boosting developer velocity requires a holistic view across process, tooling, and culture.

According to the research, this is what high-performing engineering organizations focus on:

Empower with the Right Tools

McKinsey research demonstrates that developer tooling is the primary driver of Developer Velocity.

Organizations providing robust tools across planning, development environments, collaboration, and continuous integration and delivery demonstrate 65% higher innovation compared to bottom-quartile companies.

Furthermore, access to effective tools throughout the software lifecycle correlates with 47% higher developer satisfaction and retention rates in top-quartile companies versus bottom-quartile performers.

Leading organizations implement a balanced approach to tooling—offering developers a curated selection of 2-5 options to address diverse needs and preferences, while maintaining governance over ad-hoc additions.

Create a Collaborative Culture

Research shows that organizations achieve superior outcomes when they create environments where software teams can safely experiment and learn - and where everyone feels they can fully contribute, regardless of their background.

While knowledge sharing, continuous improvement, servant leadership, and customer-centricity all correlate with better business performance, psychological safety emerges as the most crucial cultural factor This means fostering an environment where all team members feel supported in taking calculated risks and where diverse perspectives are actively sought out and valued.

High-performing organizations pair this cultural shift with robust technical safeguards to minimize the impact of failures.

These include implementing controlled releases, feature flags that enable quick feature toggles without code redeployment, and automated rollback capabilities.

They also conduct thoughtful postmortems and retrospectives, creating spaces for teams to analyze both successes and setbacks constructively.

Creating a comprehensive product-management function

Product management extends beyond delivering releases on schedule and within budget.  It is about ensuring that the right products are built in the right ways to deliver a compelling customer experience.

This emphasis on customer experience explains why product management has emerged as a critical function over the past decade and why these capabilities now rank as the third most significant driver of Developer Velocity.

A McKinsey research evaluated product management across six key dimensions: customer experience, strategic skills, business acumen, technical skills, leadership skills, and organizational enablers—including mechanisms for strategic prioritization, funding, and product telemetry adoption.

The findings reveal that Developer Velocity Index (DVI) scores respond most strongly to a well-balanced product management function rather than excellence in isolated areas.

Organizations demonstrating above-average performance across all six dimensions achieve DVI scores 1.5 times higher than those excelling in only one or two areas

Focusing talent management on the developer experience

The technology industry has historically emphasized the concept of exceptional developers—individuals who demonstrate productivity rates significantly higher than their peers.

While discussions continue about the precise multiplier effect, evidence clearly shows that highly talented developers accelerate team velocity.

McKinsey’s research identifies 5 key factors that correlate with enhanced Developer Velocity:

1. strategic incentives
2. comprehensive recruiting programs
3. robust learning opportunities
4. structured engineering career paths
5. systematic team health monitoring

High-performing organizations recognize team health as fundamental to productivity and retention.

They implement regular feedback cycles—typically after each sprint—using a combination of surveys, collaborative whiteboard sessions, and visual metrics dashboards. These teams also actively monitor for patterns of inclusion and potential bias in how work is distributed and recognized across the team.

This enables teams to address challenges and optimize processes promptly.

These frequent check-ins are supplemented by detailed annual or semi-annual assessments examining deeper aspects of team dynamics, including shared vision, leadership effectiveness, motivation factors, and incentive structures.

‍

To effectively measure developer velocity, teams can use Multitudes, which is an engineering insights platform for sustainable delivery. Multitudes integrates with your existing development tools, such as GitHub and Jira, to provide insights into your team's productivity and collaboration patterns.

With Multitudes, you can:

• Automatically track your developer velocity with key DORA metrics
• Get visibility into work patterns and where the team’s time went, e.g. into feature development vs. bug fixing
• Identify collaboration patterns and potential silos within your team
• Understand individual and team well-being through metrics like out-of-hours work, incidents, and meetings
• Integrate with Slack to give you automated nudges and strategies on exactly what you should do next to improve team performance

By leveraging Multitudes, teams can spend more time acting on insights to improve their developer velocity.

Our clients ship 25% faster without sacrificing code quality.

Ready to unlock happier, higher-performing teams?

Try Multitudes today!