# How to Measure Productivity in Software Engineering Teams | LinearB Blog

> The three-part methodology we use to measure software engineering productivity at Linear B.

_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)._

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

/

How to Measure Productivity in Software Engineering Teams

# How to Measure Productivity in Software Engineering Teams

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

By [Dan Lines](https://linearb.io/blog/how-to-measure-productivity-in-software-engineering-organizations#dan-lines)

|

February 18, 2019

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

Think about how weird the following situation is. We, as a software community, are obsessed with data, analytics, and measuring stuff (think IOPS). Yet, we are totally behind the times when it comes to measuring ourselves in order to improve our own productivity. Even more surprisingly, there are non-technical teams such as Sales, HR, Marketing, etc. who are way ahead of us in using data to improve their productivity.

Enough is enough. This cannot stand! It is time to improve….

New information has come to light. [Measuring productivity](https://linearb.io/blog/developer-productivity-metrics/) for continuous improvement in software organizations is 100% possible. We are doing it every day at Linear B. The thing is, it’s not easy and can by no means be done with a single metric like “lines of code produced.”

_Side note: Sometimes, I pitch Linear B to someone and they say, “this sounds really cool, but you’re not just measuring lines of code right?” The reactions inside my head sound like, “What? This question is offensive! …Calm down. Ok, tell them how we measure._ [_Let Me Blow Your Mind_](https://www.youtube.com/watch?v=6%5F15TL5lrOg)_.”_

Since there are many dimensions to “productivity” in software development, LinearB has created a foundational three-part methodology, which covers Quality/Value, Activity/Throughput and Teamwork/Social.

To understand how this works, read on for more details and examples. Let’s get it!

## **Part I: Quality / Value**

Without quality, everything you do is detrimental to sustained productivity and can be worse than actually doing nothing. A question software engineering leaders have to ask themselves is, “Is the stuff we are producing high quality, valuable to customers, and helping our delivery rate long term?” So, how do we get data-driven insights to answer that question?

LinearB measures quality in a few ways. One example of this is a metric called Code Longevity. If you’re familiar with the sports analytics world, Code Longevity would be considered an “advanced stat.”

_Side Note: Professional sports organizations that adopt a data-driven approach tend to win more games. Check out the_ [_Chicago Blackhawk’s success_](http://www.espn.com/nhl/story/%5F/id/12370826/analytics-give-blackhawks-advantage)_…3 recent Stanley Cups…dope!_

**Code Longevity:** Percent of code that remains in the codebase for a substantial period of time.

This is an excellent indicator of quality. Codebases that have a high longevity rate also tend to have a higher productivity rate. Here is why:

* Your codebase has a low churn rate. When you have a low churn rate, you are not rewriting the same code over and over again, which is a productivity killer.
* There is probably a sufficient testing strategy in place. It is likely automated enough that you are catching issues prior to “production ready” submissions.
* The product owner is on point. They are providing a stable [value stream](https://linearb.io/blog/value-stream-mapping-devops/) and not switching things up on the fly.

In addition to Code Longevity, LinearB uses many other measurements to give a holistic picture of Quality/Value. However, this only speaks to a part of a software engineering organization’s productivity.

## **Part II: Activity / Throughput**

The next area we feel it is important to focus on is the rate of output produced. The question asked by leaders in this category is, “How much stuff are we producing, what type of stuff, and at what efficiency rate?”

Consider the following. If your team is producing zero stuff, then there is no way you’re delivering on your projects. If your team is producing 1,000,000 stuffs with high quality, then there is a good chance (although not guaranteed) you’re delivering on your projects. This quick thought experiment shows that activity and throughput rate are important to measure and understand.

_Side note: When I’m in a situation where the best path forward is not obvious, I try to use thought visualizations to get a glimpse of what things may look like at each end of the possible extremes. (_[_Einstein’s thought experiments_](https://en.wikipedia.org/wiki/Einstein%27s%5Fthought%5Fexperiments) _style, because I like space/time stuff)_

Output from software organizations comes in many forms such as commits, PR reviews, story creation, and documentation. These are volume metrics, and yes, we measure these output types at LinearB.

There is also a family of metrics that focuses on throughput. This set of metrics tells a lifecycle story about time to value. Throughput [metrics measure value](https://linearb.io/blog/value-stream-metrics/) phases like time from idea generation to story creation, story creation to pull request open, pull request open to merge, and merge to production release. Throughput metrics are important because they bring to light the bottlenecks, efficiency to be gained, and work methodology. Let’s zoom in on one specific throughput metric.

**PR Time to Merge:** The time from pull request open to merge.

PR [Time to Merge](https://linearb.io/blog/critical-metrics-time-to-merge/) is an excellent Activity/Throughput metric. Software organizations that have a good PR Time to Merge rate also tend to have a higher productivity rate. Here is why:

* It speaks to your value delivery system. The faster value is able to stream through your delivery system, the better.
* Your teamwork and review process have to be solid. Open PR’s degrade over time. You want to have a review process that addresses open PR’s as quickly as possible and this requires teamwork.
* If “reviewing” a PR takes a lot of manual effort, your time to merge is going to be high. When you have automated checks running, you’re likely to have a lower Time to Merge rate.

It is easy to see how measuring Quality/Value and Activity/Throughput can provide insightful details about productivity. However, there is still a huge piece of the overall picture missing.

## **Part III: Social / Teamwork**

The final piece to our three-part methodology is all about the people. As we should all know by now, software development is a team sport, and people are the most important asset we have! Elite organizations optimize the productivity of their people by measuring things like morale, burnout rate, collaboration, knowledge share, and communication paths.

Leaders need to constantly ask themselves, “How are my people doing, how are we interacting, and how are we working together as a team?”

At LinearB, we feel there is nothing more important than the people. Therefore, we have a multitude of measurements in this category. A couple of examples are Pull Request Review Rate per person (team impact metric) and Connected Factor which quantifies the amount of interaction between teammates. These Social/Teamwork metrics have a [huge impact on productivity](https://www.fastcompany.com/3048751/happy-employees-are-12-more-productive-at-work). One, in particular, called Sentiment is detailed below.

**Sentiment:** The level of positivity or negativity expressed by people within your organization.

_Side note: A common reaction I get when discussing Sentiment analysis with software leaders is, “This is awesome, but can you really measure our Sentiment level?”. Yes, there are a lot of super smart PHD’s that have been analyzing language patterns for decades, and, at LinearB, we enhance the ability to measure this by integrating into multiple sensors such as Slack._

Sentiment analysis is important when it comes to understanding your team and people. Software organizations that have a positive Sentiment tend to have a higher productivity rate. Here is why:

* Have you ever worked on a team where things are clicking? Ideas and creativity are flowing, and there is an inherent positive energy. This type of team tends to deliver higher quality output at a faster rate.
* Have you ever worked on a team where things are not clicking? It’s terrible. The quality is often poor and the delivery of value often never occurs.
* Teams with positive sentiment are more likely to remain together. On the flip side, one way to destroy productivity is to have unhappy people on your team long term or to lose your unhappy top talent to other opportunities.

We take our metrics seriously at [LinearB](https://linearb.io), and we are continuously improving and innovating as we correlate more [productivity insights](https://linearb.io/blog/5-best-engineering-performance-metrics-to-measure-your-team/).

[](https://linearb.io/engineering-efficiency/)We know that improving engineering efficiency is important. Learn more about [our four-step recipe for improvement](https://linearb.io/engineering-efficiency/).

## Improve developer productivity with LinearB

Find us on

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

## Your next read

[![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...

[![Cover image for AI is rebuilding software delivery from SDLC to ADLC](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_AI_rebuilding_software_delivery_2400x1256_3fd5887e75?_a=BAVMn6ID0)](https://linearb.io/blog/sdlc-to-adlc-agentic-software-delivery-transformation)

Eng. Metrics

[AI is rebuilding software delivery from SDLC to ADLC](https://linearb.io/blog/sdlc-to-adlc-agentic-software-delivery-transformation)

Discover how engineering organizations are transitioning from the traditional SDLC to an Agentic Development Lifecycle (ADLC). Learn why rising token costs...

[![Cover image for 8 million pull requests reveal where engineering productivity breaks down](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_8_million_pull_requests_2400x1256_03724bfbb2?_a=BAVMn6ID0)](https://linearb.io/blog/8-million-prs-engineering-productivity)

Eng. Metrics

[8 million pull requests reveal where engineering productivity breaks down](https://linearb.io/blog/8-million-prs-engineering-productivity)

8.1M pull requests reveal the gap between AI adoption and engineering impact, and why code review is the bottleneck blocking real productivity gains.

## 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": "How to Measure Productivity in Software Engineering Teams",
  "url": "https://linearb.io/blog/how-to-measure-productivity-in-software-engineering-organizations",
  "author": {
    "@type": "Person",
    "name": "Dan Lines"
  },
  "datePublished": "2019-02-18T19:06:10.000Z",
  "dateModified": "2019-02-18T19:06:10.000Z",
  "image": "https://assets.linearb.io/image/upload/v1720000000/2018_AI_safety_grants_c6d19b02a9.jpg",
  "publisher": {
    "@type": "Organization",
    "name": "LinearB",
    "logo": "https://assets.linearb.io/image/upload/v1777485755/linearb-logo-2026.png"
  },
  "description": "The three-part methodology we use to measure software engineering productivity at Linear B.\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)
- [Register now](https://linearb.io/event/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 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)