Developer Productivity: Shorter Cycles with High Quality
Short feedback loops with reliable quality are my mental model for developer productivity. Where the waiting actually happens has to be shown by your own lead time.
Lead time and processing time are two different quantities. Processing time is the span in which someone actually works on a change – reading, writing, testing. Lead time is the span from the first line to the feedback from production. The difference between the two is idle time: hours and days in which a finished change exists and nothing happens to it.
Take a change with two hours of processing time and three days in queues: before the build, before the review, before a free test environment. In this example, the call for more people targets the smaller quantity. Whether your own system looks the same can be read from the timestamps of commit, review, build and deployment – not from a general claim about developer work.
My mental model for this is: short feedback loops with reliable quality. That is not a measurable formula but a reminder of two limits. Speed without a quality net produces faster failures; quality assurance without timely feedback produces large queues. Which side is slowing you down right now is shown by the measured cycle time.
Productivity emerges in two connected feedback loops whose rhythm and result must not be confused.
Two loops, two kinds of feedback
- Question · How quickly does a small change reliably reach production?
- Sequence · Code, build, test, review and deploy
- Time scale · Minutes to hours
- Signal · Technical feedback and production behavior
- Question · Does the change solve the right problem?
- Sequence · Hypothesis, implementation, measurement and learning
- Time scale · Days to weeks
- Signal · Observed impact and validated learning
A fast delivery loop without discovery may quickly ship the wrong thing. A good hypothesis without a short delivery loop waits too long for reliable feedback.
Speed and stability are not a trade-off#
The most persistent fallacy in this discussion is the assumption that you have to choose between speed and stability. “We could deliver faster, but then more things break” – I hear this sentence regularly in steering meetings. The data says the opposite.
The central finding of Accelerate (Forsgren, Humble, Kim, 2018), the book version of the DORA research with over 23,000 responses from more than 2,000 organizations, is unambiguous: high performers are better at speed and quality. Nowhere in the data does a team buy one at the expense of the other. The fast teams are also the stable ones. That is a statistical correlation, not a question of attitude – and the foundation for the thesis that cycles and quality support each other.
This is operationalized through the four DORA metrics, which measure exactly these two dimensions. For throughput: Deployment Frequency and Lead Time for Changes – the time from commit to production. For stability: Time to Restore Service (the time to recover after an incident) and Change Failure Rate – the share of deployments that cause a failure. Lead time is the measurable version of the “short feedback loop” from my formula. If you lower it, you lower exactly the waiting time this is about.
A note on precision, because this is often quoted sloppily: for years, the State of DevOps reports sorted teams into clusters – in 2021 still with a separate “elite” group. The 2022 report found only three clusters (high, medium, low), no “elite” anymore. If you argue today with “according to DORA, elite teams…,” you should know which year the number comes from.
Why the bottleneck is waiting#
Continuous integration is often understood as “tooling” – you set up a build server and check the box. The point is a different one. Martin Fowler defines CI as a practice where members of a team integrate their work frequently and each integration is verified by an automated build, including tests, to detect integration errors as quickly as possible. The decisive word is “quickly.” CI is a latency machine: it shortens the time between a defect and its discovery. The bottleneck CI addresses is waiting and integration latency – not code volume.
The deployment pipeline (also Fowler) is the deliberate handling of this latency. You break the path to production into stages: early stages give initial confidence in seconds to minutes, later ones are more thorough and may be slower for it. This turns where feedback should be fast and where it should be thorough into a design decision.
pipeline:
- stage: commit # target: < 10 min -> fastest feedback
steps: [compile, unit_tests, static_analysis]
- stage: acceptance # target: minutes -> contract & integration
steps: [contract_tests, integration_tests]
- stage: deploy_staging # ephemeral environment on demand
steps: [provision_env, smoke_tests]
- stage: production # gated by feature_flag, not by branch age
steps: [progressive_rollout, health_check]
In front of such a skeleton, exactly one question matters: where is time really lost? The answer is rarely unit_tests. It is compile when the commit build takes twelve minutes instead of under ten. It is review when a pull request sits in the queue for two days. It is provision_env when a test environment is requested by hand and provided overnight. Those are the real latency levers. Writing the tests, meaning the time at the keyboard, is almost never the problem.
This also explains why “shift left” is more than a buzzword. A contract break between two services that only shows up in a nightly end-to-end environment costs a day. The same break showing up in the commit build costs minutes. It is the same defect – only the feedback latency differs by orders of magnitude.
The two loops#
Short cycles exist on two levels, and I often see teams optimizing only one of them. The inner loop is delivery: code → commit → build → automated tests → review → deploy, measured in minutes. The outer loop is discovery: hypothesis → build → measure → learn, measured in days to weeks. The inner loop makes sure you ship something quickly and safely. The outer one makes sure it is the right thing.
This outer loop is easily forgotten, even though it is the same idea at the product level. Eric Ries described it in The Lean Startup (2011) as Build–Measure–Learn with the goal of validated learning. Teresa Torres made it concrete in Continuous Discovery Habits (2021): weekly customer interviews, the opportunity solution tree that brings opportunities and solution ideas into a visible order, systematic assumption testing. Here, too, what counts is not more output but shorter learning cycles. A team that pushes its inner loop down to minutes but waits half a year before noticing that nobody needs the feature has optimized the wrong bottleneck.
flowchart LR
subgraph inner["Inner loop – Delivery (minutes)"]
code["code"] --> commit["commit"]
commit -->|"wait: build"| build["build"]
build --> tests["automated tests"]
tests -->|"wait: review"| review["review"]
review -->|"wait: provision env"| deploy["deploy"]
end
subgraph outer["Outer loop – Discovery (days / weeks)"]
hypothesis["hypothesis"] --> buildit["build"]
buildit --> measure["measure"]
measure --> learn["learn"]
learn --> hypothesis
end
deploy --> measure
learn -.-> codeThe labeled edges in this sketch are deliberately the waiting edges: build, review, provision env. That is where cycle time is decided. DORA lead time measures the inner loop, discovery cadence the outer one. Together they give the number that counts: how often per week a team learns something validated.
Quality is the net, not the brake#
Now the part that is easily skipped in the euphoria about speed. The formula is multiplicative. Short cycles without a quality net do not mean “delivering faster” but “breaking faster.” If you reduce batch size and deploy more often without automated tests, contract tests and a real deployment pipeline, you mainly lower one thing: the time to the next incident. Reducing batch size without stability mechanisms only shifts the bottleneck – from waiting before the deploy to cleaning up after it.
That is why quality belongs in the same pipeline as speed. Where services talk to each other across system boundaries, consumer-driven contract testing carries a large part of this load. The idea (it goes back to Ian Robinson and Fowler, 2006, and is widely established with frameworks like Pact): the consumer describes what it expects from the provider, and this expectation is verified independently on both sides – without having to spin up a shared, slow end-to-end environment.
// consumer side: describe the expectation, generate a pact file
consumerTest("fetches a user by id", () => {
provider
.given("a user exists")
.uponReceiving("a request for user 42")
.withRequest({ method: "GET", path: "/users/42" })
.willRespondWith({
status: 200,
body: { id: 42, name: like("Ada") }, // matcher, not a fixed value
});
// -> produces a pact contract, verified in the provider's own pipeline
});
The gain is twofold. The contract test runs in the acceptance stage in seconds instead of an end-to-end test running for minutes in a specially provisioned environment – the feedback loop at the service boundary gets shorter. And it is more precise: it does not just say “something is red,” but “the provider no longer returns name.” That is quality that enables speed instead of slowing it down.
The same idea belongs at the architecture level. Michael Nygard described the stability patterns in Release It! (2007, 2nd edition 2018) – circuit breaker, bulkhead and relatives – so that a failure in one part does not drag down the whole. And Neal Ford, Rebecca Parsons and Patrick Kua introduced the idea of fitness functions in Building Evolutionary Architecture (2017): automated, executable checks for architectural properties such as latency, coupling or security. Both are the same movement as with tests – quality is turned into something executable that gives fast feedback in the pipeline instead of gathering dust in a review document.
How to actually build short cycles#
From practice, a few levers that work reliably – ordered by what hits the waiting edges most directly.
The commit build has to be fast. Fowler’s rule of thumb of the “ten-minute build” is not nostalgia but a psychological limit: if the build takes longer, the team stops integrating frequently, and the batches grow again. A fast, broad base of unit tests and a narrow top of slow end-to-end tests – the classic test pyramid – keeps the build fast without losing coverage.
Keep branches short. Trunk-Based Development with short-lived feature branches and feature flags decouples “code is merged” from “feature is on.” This is the point at which production is gated by a feature flag, not by the age of a branch. Long-lived branches are the classic way integration waiting time builds up invisibly until the merge becomes a day-long project.
Environments on demand. If provision_env is a ticket to another team, your lead time is not a technical quantity but an organizational one. Ephemeral, script-generated environments take this edge out of the queue.
And the point that causes the most conflict: measure the system, not the person. The four DORA metrics are team and system outcome metrics. Misused as an individual developer ranking, they immediately produce Goodhart effects – you optimize the number instead of the thing. If you are measured by “deployments per developer,” you produce micro-deploys; if you are measured by change failure rate, you relabel incidents. Forsgren and colleagues explicitly warned against such vanity and individual metrics. The metrics show the health of a flow, not the performance of an individual.
Conclusion#
Productivity in software development cannot be described meaningfully by hours worked alone. In many flows, a large part of the lead time is spent waiting for build, review or environment; whether that is the bottleneck here has to be shown by measurement. DORA metrics describe the delivery capability of the system. Contract tests, stability patterns and fitness functions can make selected quality risks visible earlier, while the discovery loop checks whether the team is working on the right problem at all.
If you want to start tomorrow: draw your inner loop and write the real waiting time on every edge. The longest of them is a good candidate for the next improvement. Then measure again. Short cycles and reliable quality remain two separate quantities; neither may hide the other.
Further reading#
- Nicole Forsgren, Jez Humble, Gene Kim: Accelerate (2018) – the finding that speed and stability are not a trade-off: https://itrevolution.com/product/accelerate/
- Four Keys / DORA metrics explained: https://cloud.google.com/blog/products/devops-sre/using-the-four-keys-to-measure-your-devops-performance
- DORA metrics and the cluster classification: https://dora.dev/guides/dora-metrics-four-keys/
- Martin Fowler: Deployment Pipeline: https://www.martinfowler.com/bliki/DeploymentPipeline.html
- Martin Fowler: Continuous Delivery: https://martinfowler.com/bliki/ContinuousDelivery.html
- Teresa Torres: Continuous Discovery Habits (2021): https://businessofsoftware.org/talks/continuous-discovery/
Revised and translated from German with the help of AI.