[tmnvdb]

I've never encountered cycle time recommended as a metric for evaluating individual developer productivity, making the central premise of this article rather misguided.

The primary value of measuring cycle time is precisely that it captures end-to-end process inefficiencies, variability, and bottlenecks, rather than individual effort. This systemic perspective is fundamental in Kanban methodology, where cycle time and its variance are commonly used to forecast delivery timelines.

[octo888]

> The primary value of measuring cycle time is precisely that it captures end-to-end process inefficiencies, variability, and bottlenecks, rather than individual effort

Yes! Waiting for responses from colleagues, slow CI pipelines, inefficient local dev processes, other teams constantly breaking things and affecting you, someone changing JIRA yet again, someone's calendar being full, stakeholders not available to clear up questions around requirements, poor internal documentation, spiraling testing complexity due to microservices etc. The list is endless

It's borderline cruel to take cycle time and measure and judge the developer alone.

[dagmx]

Imho cycle time perhaps can only be taken as a reflection across people who are doing similar things (likely team mates) or against recurring estimates if they’re incorrect.

But generally when I’m evaluating cycle efficiency, it’s much better to look at everything around the teams instead. It’s a good way to improve things for everyone across the space as well, because it helps other people too.

[to11mtm]

YES ALL OF THIS.

- Dev gets a bug report.

- Dev finds problem and identifies fix.

- Dev has to get people to review PR. Oh BTW the CI takes 5-10 minutes just to tell them whether their change passes everything on CI, despite the fact only new code is having tests written for and overall coverage is only 20-30%.

- Dev has to fill out a document to deploy to even Test Environment, get it approved, wait for a deployment window.

- Dev has to fill out another document to deploy to QA Environment, get it approved, wait for a deployment window.

- Dev has to fill out another document for Prod, get it approved....

- Dev may have to go to a meeting to get approval for PROD.

That's the -happy- path, mind you...

... And then the Devs are told they are slow rather than the org acknowledging their processes are inefficient.

[tmnvdb]

It's not just cruel, it's stupid. Not only does cycle time form a very poor measure of individual productivity, using cycle time to measure individuals will create very bad incentives that will make your team perform significantly worse!

[vasco]

If all things considered within cycle time - as you correctly say - indicate a developer's forecast for delivery timelines, and one developer over a large enough period of time working on the same codebase has half the cycle time as another, does that really tell you nothing?

Assume you're in a team where work is distributed uniformly and not some of this faster person only picking up small items.

[Etheryte]

No, it doesn't tell you anything. Someone is consistently delivering half the tickets compared to another person. Are they slow, lazy or etc? Or are they working on difficult tickets that the other person wouldn't even be able to tackle? Cycle time doesn't tell you anything about what's behind the number.

[hobs]

Work is never distributed uniformly, that's a silly assumption.

[tmnvdb]

You've misunderstood: cycle time is neither a forecast nor a measure of individual productivity.

Cycle time measures how long it takes for a unit of work (usually a ticket) to move from initiation to completion within a team's workflow. It is a property of the team / process, not individuals. It can be used to generate statistical forecasts for when a number of tasks are likely to be completed by the team process.

For most teams, actual programming or development tasks usually represent only a small portion—often less than 20%—of the total cycle time. The bulk of cycle time typically results from process inefficiencies like waiting periods, bottlenecks, handoffs between team members, external dependencies (such as waiting for stakeholder approval or code review), and other friction points within the workflow. Because of this, many Kanban-based forecasting methods don't even attempt to estimate technical complexity. They focus instead on historical cycle time data.

For example, consider a development task estimated to take a developer only two days of actual programming. If the developer has to wait on code reviews, deal with shifting priorities, or coordinate with external teams, the total cycle time from task initiation to completion might end up taking two weeks. Here, focusing on the individual’s performance misses the bigger issue: the structural inefficiencies embedded within the workflow itself.

Even if tasks were perfectly and uniformly distributed across all developers—a scenario both unlikely and probably undesirable—this fact would remain. The purpose of measuring cycle time is to identify and address overall process problems, not to evaluate individual contributions.

If you're using cycle time as an individual performance metric, you're missing the fundamental point of what cycle time actually measures.

[CSMastermind]

Making an efficent software team is literally all about reducing communication overhead.