# What Is Scrum Velocity? The Good, The Bad, and The Ugly | LinearB Blog

> Scrum velocity or team velocity is a measurement of development capacity. We’re looking at good, bad, and ugly uses of scrum team velocity.

_This is a markdown rendering of a live HTML page on linearb.io, generated for AI/LLM consumption — it is not a markdown-only site. To get the full HTML page instead, request this URL with an explicit `Accept: text/html` header (no wildcard, no markdown preference)._


```json
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://linearb.io/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Blog",
      "item": "https://linearb.io/blog"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "What Is Scrum Velocity? The Good, The Bad, and The Ugly",
      "item": "https://linearb.io/blog/what-is-scrum-velocity-the-good-the-bad-and-the-ugly"
    }
  ]
}
```

[Home](https://linearb.io/)

/

[Blog](https://linearb.io/blog)

/

What Is Scrum Velocity? The Good, The Bad, and The Ugly

# What Is Scrum Velocity? The Good, The Bad, and The Ugly

![Photo of Vlad Georgescu](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/logo-mark-lg?_a=BAVMn6ID0)

By [Vlad Georgescu](https://linearb.io/blog/what-is-scrum-velocity-the-good-the-bad-and-the-ugly#vlad-georgescu)

|

March 24, 2021

![scrum_velocity_638ae7f518](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/scrum_velocity_638ae7f518?_a=BAVMn6ID0)

All methodologies for agile software development, including scrum, start with a basic recognition. Per Wikipedia, [scrum recognizes](https://en.wikipedia.org/wiki/Scrum%5F%28software%5Fdevelopment%29#Key%5Fideas) that, “customers will change their minds about what they want or need and that there will be unpredictable challenges … for which a predictive or planned approach is not suited.”

[via GIPHY](https://giphy.com/gifs/nbcmanifest-season-2-nbc-manifest-jpiVXEEqSGsVCkz5QI)

Let’s unpack this statement a bit.

Market changes, competitor comparisons, cost efficiency, and technology changes represent only a few of the common pressures of software development that never let up. Recognizing such pressures leads to embracing change. Software requirements must also frequently change to reflect these pressures. So how are we supposed to build software if the requirements keep changing?

Here is where scrum comes to the rescue. The scrum framework for software development empowers members of a small development team to make their own decisions.

While it doesn’t reduce any of these pressures, it provides a structure for addressing them while producing useful, working software by enabling small teams to organize themselves to better collaborate and communicate with each other.

## Table of Contents

* [User Stories & Story Points](#user-stories-story-points)
* [What is Scrum Velocity?](#what-is-scrum-velocity)
* [Why Velocity is Important in Scrum](#why-velocity-is-important-in-scrum)
* [The Bad](#the-bad)
* [The Ugly](#the-ugly)
* [Alternatives to Scrum Velocity](#alternatives-to-scrum-velocity)

![scrum framework pull quote](https://assets.linearb.io/uploads/scrum-blog-quote-1.png)

## **User Stories & Story Points**

One of the first steps in a scrum framework is establishing the user stories. The product owner of a scrum team defines what needs to be built (the software requirements) and in which order (the product backlog). Typically, the product owner breaks down requirements into workable chunks, or user stories, that will be implemented in development sprints.

But how do you determine how many user stories can your team members can complete during a sprint? In other words, what is your team’s capacity to complete work?

![scrum unitless points](https://assets.linearb.io/uploads/scrum-blog-quote-2.png)

Typical measuring units for work in manufacturing are time-based (hours, weeks, or months) or human-based (man-hours). This usually translates to managers saying things like, “We need ten people working for ten weeks to finish this work.”

However, we do not use any of these measuring units in scrum software development because [they simply don’t work](https://linearb.io/blog/story-points-vs-hours). I hope the reasons why are pretty clear in light of what we’ve talked about so far: dynamic requirements and unexpected changes make precise predictions impossible.

Instead of using unit-based measurement, scrum developers use unitless points to [estimate user stories.](https://linearb.io/blog/story-points-definition-caution-on-estimating)

A typical discussion during a sprint planning meeting would not be about how long implementation will take. The discussion centers around how complex implementation is. Even more important, you estimate by comparing current work with previously completed work.

Unitless story points provide a useful metric. However, unitless story points do not provide a precise measurement that correlates easily to time and budget.

## **What is Scrum Velocity?**

The term _velocity_ comes from physics. It involves speed, but it has an additional attribute, too: direction. So think of velocity as speed with direction.

I like that analogy when it comes to software development. Development speed without direction is an utter waste of time. Developers busily build software that turns out to be useless.

Team velocity in scrum development is the capacity a team has for producing useful, working software. Simply put, scrum velocity represents the capacity of a development team to achieve a given purpose.

![scrum velocity](https://assets.linearb.io/uploads/scrum-blog-quote-3.png)

## Why Velocity Is Important in Scrum

When we total the number of story points completed during a sprint, we get a good measurement of the amount of work accomplished. It is after multiple sprints when [measuring sprint velocity](https://linearb.io/blog/sprint-velocity) becomes really useful.

By comparing work over multiple sprints, we can gauge the amount of work that our team can complete. This is scrum velocity. Calculating velocity means dividing the total number of story points completed by the number of sprints completed.

Knowing scrum velocity, the development team can have a good idea about how much work they can accomplish during one sprint. While not meant for precision, scrum velocity can be a good estimator of capacity and can assist with sprint planning.

This is the good of scrum velocity. However, scrum velocity can also serve as a bad measurement. Let’s look at how.

## **The Bad**

Sometimes management uses scrum velocity to estimate precisely when a project will be completed. This is unfortunate.

Ben Matthews, Director of Engineering at Stack Overflow, noted that velocity is one of many data points. Check it out.

Remember that some key ideas in scrum development are frequent requirements changes and short development sprints. There are many changing variables during software development, and using a static measurement for precise predictions is a bad combination. Yes, team velocity can indicate an approximate time. However, scrum velocity must remain an approximation of capacity to execute work.

A manager might say, “Based on our current team velocity over the last three sprints, we can complete forty story points this month.” 

I understand the great desire to assign points to all user stories prior to development. You can add them all up. Then you can divide by team velocity and get the number of sprints required to complete a project.

It sounds so simple, but it’s not. Since team velocity always looks in the past, in practice, team velocity has proved to be an inaccurate predictor of the future.

It’s important to [improve planning accuracy](https://linearb.io/planning-accuracy) though. Velocity is just not the right agile metric. LinearB has developed Project Delivery Tracker as an alternative solution for managers looking to improve their sprint planning accuracy and answer the age-old question: “When is Project XYZ going to be ready?”

[](https://linearb.io/project-delivery-tracker)

Your CEO will love this! You can see your team’s investment profile, project allocation, and planning accuracy by boards, epics, labels or custom fields. [Learn more about Project Delivery Tracker.](https://linearb.io/project-delivery-tracker)

## **The Ugly**

Not only is team velocity a bad predictor of future timelines, but it can also turn into a terrible measurement for team efficiency, especially when used to compare teams with each other.

Why? Because each team uses story points differently. One team assigns three points to a user story, while another team assigns five points to the same type of story.

Why? Because user story points don’t use units. User story estimation procedures are internal to a development team and should stay within the team.

Consequently, a manager should not compare development teams based on their velocity. It turns even uglier when comparing one developer to another based on story points.

Remember that velocity is for the team, not for the individual. In addition, team velocity is an estimate of team capacity over many sprints.

Being part of a few scrum teams over the years, I have experienced many user stories that were labeled as “not complex.” However, these user stories have turned out to be very difficult to complete, not only technically but also because of interaction with other parts of the company.

## **Alternatives to Scrum Velocity**

This is where the rubber meets the road. In my experience, team velocity is rarely discussed inside a development team, but it sometimes circulates outside the team, which is exactly the opposite of what should happen. 

Rather than using scrum velocity to gauge sprint planning accuracy and [improve team performance](https://linearb.io/blog/how-is-performance-measured-in-scrum), at LinearB, we correlate project management, Git, and release data to track your planning accuracy metric. 

Why does planning accuracy matter so much? Because it shows whether or not your engineering team will deliver on your promises.

High planning accuracy means that more features are shipped on time. Other departments can align with engineering, like sales and marketing. Plus, customers get new products and features when they expect them, leading to better experiences, less churn, and more renewals. Unfortunately for most teams, their [average planning accuracy is below 50%](https://linearb.io/engineering-benchmarks).  
  
With LinearB, you’ll be able to investigate and discover the problem, create initiatives to improve and put those initiatives into action. We’d love to show you how!

[![Improve your engineering organization at every level with LinearB](https://assets.linearb.io/uploads/GenericLineaRB3Pillars-1024x497.png)](https://linearb.io/get-started/)

Want to improve your engineering processes at every level? [Get started with a LinearB free-forever account today!](https://linearb.io/get-started)

## Improve developer productivity with LinearB

Find us on

[](https://www.linkedin.com/company/linearb)
[](https://devinterrupted.substack.com/)

## Your next read

[![Cover image for Your software factory needs a context layer](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/unnamed_4_b35455ae7a?_a=BAVMn6ID0)](https://linearb.io/blog/software-factory-2026-ai-benchmarks-code-review-roi)

Eng. Metrics

[Your software factory needs a context layer](https://linearb.io/blog/software-factory-2026-ai-benchmarks-code-review-roi)

Data from 2.7 million pull requests across 253 engineering organizations shows a widening gap between developers using AI deeply and everyone else. An adoption...

[![Cover image for AI agents are killing the pull request and reinventing CI/CD](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_5_496cdfde2d?_a=BAVMn6ID0)](https://linearb.io/blog/circleci-rob-zuber-ai-agents-pull-request-cicd-sdlc)

Eng. Metrics

[AI agents are killing the pull request and reinventing CI/CD](https://linearb.io/blog/circleci-rob-zuber-ai-agents-pull-request-cicd-sdlc)

CircleCI CTO Rob Zuber explains why AI adoption is killing the pull request and forcing engineering teams to completely reimagine the software development...

[![Cover image for AI ROI comes from measuring engineering outcomes on day one](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_AI_ROI_comes_from_measuring_engineering_software_security_2400x1256_2c5eae0862?_a=BAVMn6ID0)](https://linearb.io/blog/kraken-nik-sudan-measure-ai-roi-engineering-outcomes)

Eng. Metrics

[AI ROI comes from measuring engineering outcomes on day one](https://linearb.io/blog/kraken-nik-sudan-measure-ai-roi-engineering-outcomes)

Kraken Engineering Operations Lead Nik Sudan details how to establish day-one data infrastructure to accurately measure AI ROI. Discover why raw token adoption...

## Structured data

_Machine-readable metadata (JSON-LD) embedded in the page for search/AI context — not content rendered on the page itself._

```json
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "LinearB",
  "url": "https://linearb.io/",
  "logo": "https://assets.linearb.io/image/upload/v1715628027/logo-mark-lg.svg",
  "description": "LinearB is the engineering productivity platform that helps engineering leaders prove AI is improving throughput without sacrificing delivery confidence, flow efficiency, or developer experience.",
  "sameAs": [
    "https://www.linkedin.com/company/linearb"
  ],
  "award": [
    {
      "@type": "Award",
      "name": "LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms",
      "dateAwarded": "2026",
      "awardedBy": {
        "@type": "Organization",
        "name": "Gartner®"
      }
    },
    {
      "@type": "Award",
      "name": "Great Place to Work Certification",
      "dateAwarded": "2025-2027",
      "awardedBy": {
        "@type": "Organization",
        "name": "Great Place to Work"
      }
    },
    {
      "@type": "Award",
      "name": "America's Best Startup Employers 2025",
      "dateAwarded": "2025",
      "awardedBy": {
        "@type": "Organization",
        "name": "Forbes Magazine"
      }
    }
  ],
  "hasCertification": [
    {
      "@type": "Certification",
      "name": "SOC 1 Type 2"
    },
    {
      "@type": "Certification",
      "name": "SOC 2 Type 2"
    },
    {
      "@type": "Certification",
      "name": "GDPR Compliance certification"
    },
    {
      "@type": "Certification",
      "name": "ISO 27001"
    }
  ]
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "What Is Scrum Velocity? The Good, The Bad, and The Ugly",
  "url": "https://linearb.io/blog/what-is-scrum-velocity-the-good-the-bad-and-the-ugly",
  "author": {
    "@type": "Person",
    "name": "Vlad Georgescu"
  },
  "datePublished": "2021-03-24T22:23:47.000Z",
  "dateModified": "2021-03-24T22:23:47.000Z",
  "image": "https://assets.linearb.io/image/upload/v1720000000/scrum_velocity_638ae7f518.jpg",
  "publisher": {
    "@type": "Organization",
    "name": "LinearB",
    "logo": "https://assets.linearb.io/image/upload/v1777485755/linearb-logo-2026.png"
  },
  "description": "Scrum velocity or team velocity is a measurement of development capacity. We’re looking at good, bad, and ugly uses of scrum team velocity.\n"
}
```

## More on linearb.io

### Top navigation

- [Book a Demo](https://linearb.io/book-a-demo)
- [AI Code Reviews — Catch security risks, bugs, and spec mismatches](https://linearb.io/platform/ai-code-reviews)
- [AI & Productivity Insights — See how AI tools affect cycle time and delivery speed](https://linearb.io/platform/ai-developer-productivity-insights)
- [Measure AI Impact — Track AI adoption and tie it to delivery outcomes](https://linearb.io/use-case/measure-ai-impact)
- [MCP Server — Chat with your data to spot patterns and boost output](https://linearb.io/platform/mcp-server)
- [Resource Allocation — Cost initiatives and shape your investment strategy](https://linearb.io/platform/resource-allocation)
- [Cost Capitalization — Capitalize engineering costs with audit-ready reports](https://linearb.io/platform/cost-capitalization)
- [Dev Team Management — Set targets and tie throughput to business outcomes](https://linearb.io/platform/goals-and-reporting)
- [DevOps Workflow Automation — Policy-based PR routing, approvals, and tests](https://linearb.io/platform/ai-workflow-governance)
- [AI Powered Support — Unify AI and human code delivery in one clear view](https://linearb.io/use-case/ai-powered-support)
- [Optimization — Surface friction with feedback and MCP insights](https://linearb.io/platform/developer-experience)
- [Reporting — Spot what's working and what needs attention](https://linearb.io/use-case/measuring-developer-experience)
- [Surveys — Turn developer feedback into actionable signals](https://linearb.io/platform/developer-surveys)
- [Platform overview](https://linearb.io/platform/overview)
- [Watch now](https://linearb.io/resources/engineering-productivity-gap)
- [Customers](https://linearb.io/customers)
- [Pricing](https://linearb.io/pricing)
- [Why choose LinearB — Explore your data. Measure performance. Act to improve it.](https://linearb.io/why-linearb)
- [APEX framework — The operating model for AI-era engineering teams](https://linearb.io/resources/apex-framework)
- [Anti-FAQ — The questions other vendors won't answer](https://linearb.io/why-linearb/anti-faq)
- [Security — Enterprise-grade compliance and zero code access](https://linearb.io/security)
- [Build vs. buy — The hidden cost of building it yourself](https://linearb.io/resources/build-vs-buy)
- [Dev Interrupted Podcast — Conversations with engineering leaders](https://linearb.io/dev-interrupted/podcasts)
- [Reports & Guides — Deep dives on productivity and delivery](https://linearb.io/resources)
- [Webinars — Expert sessions on productivity and AI](https://linearb.io/resources?category=workshops)
- [Metrics Benchmarks — See how your engineering org stacks up](https://linearb.io/resources/software-engineering-benchmarks-report)
- [Blog — Product updates and practical insights](https://linearb.io/blog)
- [Help Center — Documentation, setup, and support](https://linearb.helpdocs.io)
- [API Docs](https://docs.linearb.io/api-overview)
- [Status](https://www.linearbstatus.com/)
- [Integrations](https://linearb.io/integrations)
- [LinearB Library](https://linearb.io/library)
- [Engineering metrics](https://linearb.io/library/engineering-metrics)
- [Platform engineering](https://linearb.io/library/platform-engineering)
- [Engineering glossary](https://linearb.io/library/engineering-glossary)
- [Developer productivity](https://linearb.io/library/developer-productivity)
- [AI in software development](https://linearb.io/library/ai-in-software-development)
- [Engineering management](https://linearb.io/library/engineering-management)
- [Developer experience](https://linearb.io/library/developer-experience)
- [DevOps](https://linearb.io/library/devops)
- [Engineering operations and the context layer](https://linearb.io/library/engineering-operations)
- [Engineering efficiency](https://linearb.io/library/engineering-efficiency)
- [Software delivery](https://linearb.io/library/software-delivery)
- [Research and data](https://linearb.io/library/engineering-benchmarks-and-research)
- [LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms](https://linearb.io/resources/gartner-magic-quadrant-dpi-platforms-2026)
- [Sign in](https://app.linearb.io/login)
- [Enterprise](https://linearb.io/solutions/enterprise)
- [Contact](https://linearb.io/contact-us)
- [About us](https://linearb.io/about-us)
- [Careers](https://linearb.io/careers)
- [Service agreement](https://linearb.io/services-agreement)
- [Privacy policy](https://linearb.io/privacy-policy)
- [DPA](https://linearb.io/data-processing-agreement)
- [Security FAQ](https://linearb.io/security-faq)
- [Substack](https://devinterrupted.substack.com/)

### Footer

_Additional links from the site footer, not repeated from the top navigation above._

- [GitHub](https://github.com/linear-b)
- [LinkedIn](https://www.linkedin.com/company/linearb)
- [Twitter](https://twitter.com/LinearB_Inc)