Chapter 6: Flow in your development cycle
The introduction frames software delivery as a value stream from idea to production and explains why unfinished work and delays between steps matter more than visible activity.
After this chapter you will be able to
- Development value stream. Describe the development value stream as the complete path from an idea to working behavior in production, including steps, queues, and handoffs where value can stop moving.
- Unfinished work as inventory. Explain why work in progress is software inventory and how leaving it undelivered hides problems and increases the chance of rework.
- Flow versus team velocity. Distinguish flow from velocity and explain why speeding up one development step may not shorten the time until users receive a feature.
- End-to-end development value stream. Explain how the manufacturing value-stream idea applies to software: an idea becomes working behavior in production, and coding is only one step among queues, checks, and possible rework.
- Coding speed versus delivery flow. Explain why the session-timeout fix's short coding time did not mean fast flow, and identify the constraints the value-stream view exposed.
- Mapping actual work flow. Explain what a value stream map should show and why improving flow depends on the real process rather than the clean documented process.
- Measured software value streams. Explain how timestamps at stages such as ticket creation, review, merge, and deployment turn a value stream map into a picture of how work actually behaves.
- Feature lead time and activity. Distinguish lead time from cycle time in a feature stream, and explain what a low activity ratio reveals about its delays.
- Constraints across delivery streams. Explain why faster coding or builds may barely change defect or deployment lead time when downstream waits dominate.
- Targeted Kaizen bursts. Describe how a Kaizen burst focuses a value stream improvement on the specific delay whose reduction would most shorten lead time.
- Value beyond deployment. Explain why production deployment does not necessarily mean customers have received value, and describe how the value stream can extend beyond the repository.
- Systemwide flow constraints. Explain why flow is a system metric rather than a team metric, and describe how examining the whole stream can expose hidden dependencies.
- Batch size and feedback flow. Explain how pull request size affects review, feedback, rework, cycle time, and lead time in the value stream.
- Invisible software work inventory. Explain what counts as work in progress in software and why accumulating unfinished items harms delivery.
- Completion before new starts. Describe how a WIP limit changes what a developer or team does when work is blocked or the limit is reached.
- Capacity governed pull system. Explain how WIP limits make intake a pull system rather than a push driven by incoming demand.
- The binding delivery constraint. Explain why a delivery pipeline’s throughput is governed by its constraint, and distinguish a bottleneck from a stage that merely takes a long time to process an item.
- Improvement at the constraint. Justify why reducing wait at the review constraint improves lead time more than speeding up coding or deployment in the example.
- Constraint and system throughput. Explain why the constraint governs throughput and why speeding up other stages does not improve it.
- Four constraint elevation patterns. Describe the four ways the section says a constraint can be elevated.
- Subordination to staging capacity. Explain subordination using the shared-infrastructure example, distinguishing it from elevation.
- Current and future value streams. Distinguish a current-state value stream from a future-state value stream, and explain why the future state must be a documented, measurable redesign rather than an aspiration.
- Meeting cadence as constraint. Explain why the twice-weekly breakdown meetings delay development even though breakdown itself is brief.
- Redesign against structural waiting. Describe the proposed replacement for twice-weekly breakdown and how the future-state map records its outcome and standard work.
- CI/CD and end-to-end flow. Explain why CI/CD does not guarantee flow, and describe ways it can either help or hinder the movement of changes.
- Timely validation for flow. Explain why flow-oriented CI/CD favors fast, reliable validation at the right time over maximum validation. Describe how early defect detection and low-ceremony deployment help small batches move continuously.
- Release waiting and lead time. Trace how replacing a weekly release window with deploy-on-merge, automated compliance checks, and feature flags changes the movement of work. Explain why lead time and inventory fall even though engineers do not perform the transformation work faster.
- Validation as a flow constraint. Trace how accumulating validation stages and congested build runners slow feedback, queue commits, and turn CI/CD into the narrowest part of the value stream.
- Validation safety and waiting. Explain why valuable testing can still produce waiting and overprocessing waste, and why the section calls for changing validation sequencing rather than abandoning deep validation.
- Balanced CI/CD validation. Explain why a flow-oriented CI/CD scorecard considers speed, safety, and stability together instead of optimizing pipeline speed or test coverage alone.
- Paired scorecard readings. Apply the section’s paired-metric examples to explain when added validation is overprocessing and when a fast pipeline has sacrificed safety.
- Deployment and release separation. Explain why coupling deployment to release creates delays and risk, and how controlled exposure lets validated changes reach users in smaller, reversible steps.
- Feature value stream map. Trace a real feature shipped in the last month backward from production, recording its distinct states and, where possible, timestamps. Describe the waiting time, active work time, queue depth, and batch size at each stage.
- Structural delay identification. Calculate total lead time and cycle time, divide cycle time by lead time for the activity ratio, and identify the single longest sustained structural delay as a constraint candidate. Describe the questions used to investigate that delay.
- Measured Kaizen iteration. Design a small Kaizen burst aimed at halving the selected delay, apply it to the next feature, and compare the measurements. Explain why a delay that moves elsewhere calls for remapping and another iteration.
What it builds on
- Inventory (chapter 2) · Introduces inventory as a form of waste.
- From idea to delivered feature in a modern system (chapter 1) · The path from an idea to a delivered feature.
- Necessary non-value-adding work (NNVA) (chapter 2) · Necessary non-value-adding work as a distinct category.
- Waiting (chapter 2) · Waiting as a form of waste in software development.
- Gemba and Kaizen in software development (chapter 2) · Introduces Kaizen as improvement practice.
- The code review (chapter 4) · Assumes familiarity with code review as a step through which a change must pass.
- Standard work for coding (chapter 4) · Standard work as an explicit way of guiding development.
- The eight wastes in software development (chapter 2) · The categories of waste in software development.
Section by section
Introduction
The introduction frames software delivery as a value stream from idea to production and explains why unfinished work and delays between steps matter more than visible activity.
- Development value stream: Describe the development value stream as the complete path from an idea to working behavior in production, including steps, queues, and handoffs where value can stop moving.
Why it matters: Looking at the entire path makes delays outside coding visible. - Unfinished work as inventory: Explain why work in progress is software inventory and how leaving it undelivered hides problems and increases the chance of rework.
Why it matters: A growing pile of unfinished work can conceal delivery problems even when the team looks busy. - Flow versus team velocity: Distinguish flow from velocity and explain why speeding up one development step may not shorten the time until users receive a feature.
Why it matters: A team can complete plenty of work internally while customers still wait a long time for each feature.
Key terms: development value stream, idea, working behavior in production, inventory, work in progress, unshipped work, flow, velocity, story points
6.1 Understanding flow, from idea to production
Defines development flow as the movement of an idea through the full value stream to working behavior in production, showing why fast coding can coexist with slow delivery.
- End-to-end development value stream: Explain how the manufacturing value-stream idea applies to software: an idea becomes working behavior in production, and coding is only one step among queues, checks, and possible rework.
Why it matters: Looking beyond coding makes delays elsewhere in delivery visible. - Value-stream activity categories: Distinguish value-adding work, necessary non-value-adding work, and pure waste using the section's customer-value test and examples.
Why it matters: These categories help separate valuable transformation from required overhead and waste. - Coding speed versus delivery flow: Explain why the session-timeout fix's short coding time did not mean fast flow, and identify the constraints the value-stream view exposed.
Why it matters: A fast local task can hide days of waiting before users receive value.
Key terms: value stream, flow, working behavior in production, value-adding work, necessary but non-value-adding work, pure waste, process time, wait time, activity ratio, queue depth
6.1.1 Multiple value streams
This section distinguishes several software-delivery value streams and shows why improving flow requires mapping the real process rather than relying on the documented one.
- Distinct delivery value streams: Distinguish the feature, defect, and deployment value streams by where each begins and ends, and explain why they may have different obstacles to flow.
Why it matters: Choosing the stream you mean makes its particular delays and constraints easier to see. - Mapping actual work flow: Explain what a value stream map should show and why improving flow depends on the real process rather than the clean documented process.
Why it matters: A tidy process diagram cannot reveal delays and rework that it leaves out.
Key terms: feature value stream, defect value stream, deployment value stream, value stream map, waits, rework loops, queues, time metrics
6.1.2 The metrics value stream
Shows how timing data on software value stream maps exposes waiting and helps teams target the constraint that most delays delivery.
- Measured software value streams: Explain how timestamps at stages such as ticket creation, review, merge, and deployment turn a value stream map into a picture of how work actually behaves.
Why it matters: Measured flow reveals delays that a process diagram alone can hide. - Feature lead time and activity: Distinguish lead time from cycle time in a feature stream, and explain what a low activity ratio reveals about its delays.
Why it matters: A feature can take little time to code yet a long time to reach users. - Constraints across delivery streams: Explain why faster coding or builds may barely change defect or deployment lead time when downstream waits dominate.
Why it matters: Improving a fast step can make people busier without delivering work sooner. - Targeted Kaizen bursts: Describe how a Kaizen burst focuses a value stream improvement on the specific delay whose reduction would most shorten lead time.
Why it matters: A specific intervention directs effort toward a delay that can change the delivery outcome.
Key terms: value stream map (VSM), metrics value stream, timestamps, queue aging, feature value stream, lead time, cycle time, activity ratio, defect value stream, deployment value stream
6.1.3 The tip of the iceberg
The section expands the value stream beyond engineering delivery and shows why delays anywhere between an idea and user benefit govern flow.
- Value beyond deployment: Explain why production deployment does not necessarily mean customers have received value, and describe how the value stream can extend beyond the repository.
Why it matters: A deployment-only view can miss work still standing between a feature and its users. - Systemwide flow constraints: Explain why flow is a system metric rather than a team metric, and describe how examining the whole stream can expose hidden dependencies.
Why it matters: Speeding up one team will not improve delivery if another necessary step still holds up user benefit.
Key terms: value stream, value delivery, flow, system metric, hidden dependencies, Kaizen bursts
6.2 Reducing batch sizes for faster feedback
This section explains how smaller, single-concern pull requests speed feedback and flow, while warning that many small changes can still create inventory.
- Batch size and feedback flow: Explain how pull request size affects review, feedback, rework, cycle time, and lead time in the value stream.
Why it matters: Changing the size of work can shorten the time between making a change and learning whether it is right. - Refactoring as separate work: Explain why a useful refactor should usually flow as its own pull request rather than being hidden inside a feature change.
Why it matters: Separating worthwhile structural work makes its cost and value visible without slowing an unrelated feature review. - Small batch inventory risk: Distinguish reducing the size of each change from reducing the number of changes in the system at once.
Why it matters: A team can improve the flow of individual changes yet still overload its system with too many changes at once.
Key terms: batch size, pull request, cycle time, lead time, value stream, refactor, unit of value, flow, small batches, inventory
6.3 Limiting work in progress
This section explains how limiting unfinished software work protects delivery, changes the response to blockers, and makes constraints visible.
- Invisible software work inventory: Explain what counts as work in progress in software and why accumulating unfinished items harms delivery.
Why it matters: Being busy on several items is not the same as delivering value. - Completion before new starts: Describe how a WIP limit changes what a developer or team does when work is blocked or the limit is reached.
Why it matters: A limit only protects flow when it changes what people do at a blockage. - Capacity governed pull system: Explain how WIP limits make intake a pull system rather than a push driven by incoming demand.
Why it matters: Capacity-based intake keeps new work from continually piling into an already constrained stage. - Visible waste and constraints: Describe what limiting WIP makes visible at the places where software work flows.
Why it matters: Visible delays give the team a concrete place to investigate rather than mistaking activity for progress.
Key terms: work in progress (WIP), inventory waste, WIP limit, blockers, swarm, Kanban, pull system, downstream capacity, standard work, gemba
6.4 Identifying and avoiding bottlenecks
This section explains how a capacity-constrained stage governs delivery flow, creates queues and waste, and should be the focus of improvement.
- The binding delivery constraint: Explain why a delivery pipeline’s throughput is governed by its constraint, and distinguish a bottleneck from a stage that merely takes a long time to process an item.
Why it matters: Finding the actual constraint keeps a team from speeding up work that cannot get through the pipeline. - Review queues and upstream waste: Trace what happens when pull requests arrive faster than they can be reviewed, including signs of the bottleneck and the waste that accumulates.
Why it matters: A growing review queue shows why more completed coding does not necessarily mean faster delivery. - Improvement at the constraint: Justify why reducing wait at the review constraint improves lead time more than speeding up coding or deployment in the example.
Why it matters: Targeting the dominant wait can shorten delivery without merely producing more work for an existing queue.
Key terms: Theory of Constraints (ToC), constraint, throughput, bottleneck, value stream, review capacity, queue depth, lead time, aging work items, waiting
6.4.1 Elevating the constraint
This section explains why improving throughput requires elevating the binding constraint while aligning upstream work with its capacity.
- Constraint and system throughput: Explain why the constraint governs throughput and why speeding up other stages does not improve it.
Why it matters: It keeps improvement effort focused on the stage that actually limits delivery. - Four constraint elevation patterns: Describe the four ways the section says a constraint can be elevated.
Why it matters: These patterns turn a diagnosed bottleneck into a targeted improvement. - Subordination to staging capacity: Explain subordination using the shared-infrastructure example, distinguishing it from elevation.
Why it matters: Without pacing incoming work, a constrained environment accumulates queues even when developers stay busy.
Key terms: ToC, constraint, throughput, elevating a constraint, binding constraint, subordination, shared staging environment, environment throughput, lead time
6.4.2 Designing the future value stream
The section shows how to design a measurable future value stream that removes waiting caused by a scheduling constraint.
- Current and future value streams: Distinguish a current-state value stream from a future-state value stream, and explain why the future state must be a documented, measurable redesign rather than an aspiration.
Why it matters: Comparing the two states turns an improvement idea into a specific change that can be evaluated. - Meeting cadence as constraint: Explain why the twice-weekly breakdown meetings delay development even though breakdown itself is brief.
Why it matters: A short task can still create a long lead time when work must wait for a calendar slot. - Redesign against structural waiting: Describe the proposed replacement for twice-weekly breakdown and how the future-state map records its outcome and standard work.
Why it matters: The example shows how changing when work can be handled removes delay without making the breakdown task faster.
Key terms: Current State Value Stream, Future State Value Stream, standard work, lead time, cycle time, meeting cadence, waiting waste, temporal, countermeasure, rotating breakdown coverage
6.5 CI/CD: Flow enabler or disruptor?
This section distinguishes faster CI/CD from end-to-end flow and shows that automation can either help or disrupt the movement of changes toward delivery.
- CI/CD and end-to-end flow: Explain why CI/CD does not guarantee flow, and describe ways it can either help or hinder the movement of changes.
Why it matters: A faster pipeline stage is only useful if changes keep moving through the whole delivery process.
Key terms: CI/CD, flow, feedback loops, queue depth, validation delay
6.5.1 CI/CD as flow enabler
This section explains how fast, reliable CI/CD improves flow by removing waiting and release gates rather than making engineers code faster.
- Timely validation for flow: Explain why flow-oriented CI/CD favors fast, reliable validation at the right time over maximum validation. Describe how early defect detection and low-ceremony deployment help small batches move continuously.
Why it matters: The point of pipeline automation is to move valuable changes safely, not to add validation for its own sake. - Release waiting and lead time: Trace how replacing a weekly release window with deploy-on-merge, automated compliance checks, and feature flags changes the movement of work. Explain why lead time and inventory fall even though engineers do not perform the transformation work faster.
Why it matters: Removing a release queue can deliver value sooner without asking developers to code faster.
Key terms: CI/CD, optimal validation, feedback loops, small batches, deploy-on-merge, release window, waiting waste, inventory, lead time, blast radius
6.5.2 CI/CD as flow disruptor
This section shows how an overloaded CI/CD pipeline can become the bottleneck in development flow, even when its validation work is valuable.
- Validation as a flow constraint: Trace how accumulating validation stages and congested build runners slow feedback, queue commits, and turn CI/CD into the narrowest part of the value stream.
Why it matters: Improving coding speed will not improve flow when validation is where completed work waits. - Validation safety and waiting: Explain why valuable testing can still produce waiting and overprocessing waste, and why the section calls for changing validation sequencing rather than abandoning deep validation.
Why it matters: The aim is to preserve safety without letting every check delay feedback for every change.
Key terms: validation runtime, constraint, value stream, feedback, inventory, deep validation, sequencing, alignment, overprocessing, waiting
6.5.3 A balanced scorecard for flow-centric CI/CD
This section explains how to judge whether a CI/CD pipeline protects flow by balancing speed, quality, and stability rather than optimizing one metric.
- Balanced CI/CD validation: Explain why a flow-oriented CI/CD scorecard considers speed, safety, and stability together instead of optimizing pipeline speed or test coverage alone.
Why it matters: A faster pipeline is not an improvement if it lets more defects through, and more validation is not an improvement if it adds delay without benefit. - Paired scorecard readings: Apply the section’s paired-metric examples to explain when added validation is overprocessing and when a fast pipeline has sacrificed safety.
Why it matters: Reading measures together helps distinguish useful validation from delay and genuine speed from increased defect risk.
Key terms: balanced scorecard, flow, validation, coverage, merge-to-production lead time, defect escape rate, pipeline runtime, overprocessing
6.5.4 Lean release strategies: Designing flow beyond deployment
The section explains how separating deployment from release keeps work flowing to users, and why teams must move toward that model incrementally.
- Deployment and release separation: Explain why coupling deployment to release creates delays and risk, and how controlled exposure lets validated changes reach users in smaller, reversible steps.
Why it matters: It shows why flow must continue past deployment to the point where users can receive value. - Incremental release transformation: Describe why a Lean release strategy takes sustained organizational change and how teams can move toward it through incremental improvements.
Why it matters: It makes release improvement a practical series of capability-building steps rather than a switch teams are expected to flip.
Key terms: deployment, release, controlled exposure, feature flags, batch size, Lean release, Kaizen, observability, constraint, future state
6.6 Exercise: Trace one feature and remove one delay
This exercise guides readers to map a shipped feature’s path, find its longest structural delay, and test a small change to improve flow.
- Feature value stream map: Trace a real feature shipped in the last month backward from production, recording its distinct states and, where possible, timestamps. Describe the waiting time, active work time, queue depth, and batch size at each stage.
Why it matters: A map grounded in an actual shipment gives you evidence for locating delays. - Structural delay identification: Calculate total lead time and cycle time, divide cycle time by lead time for the activity ratio, and identify the single longest sustained structural delay as a constraint candidate. Describe the questions used to investigate that delay.
Why it matters: Choosing the delay from measured flow keeps the improvement focused on a plausible constraint. - Measured Kaizen iteration: Design a small Kaizen burst aimed at halving the selected delay, apply it to the next feature, and compare the measurements. Explain why a delay that moves elsewhere calls for remapping and another iteration.
Why it matters: Remeasuring shows whether the change improved flow and where to focus next.
Key terms: lead time contribution, cycle time, queue depth, batch size, lead time, activity ratio, constraint candidate, structural delay, Kaizen burst, elevated the constraint
6.7 Summary
Where this is used later
- (chapter intro) (chapter 7) · Uses the concept of development flow to explain the cost of slow feedback.
- Activity time (chapter 9) · The contrast between activity and elapsed time informs discussion of activity time.
- Decisions that cannot wait (chapter 11) · Assumes that work can be viewed across more than one value stream.
- Lean metrics for developers (chapter 9) · Provides the value-stream context for software flow metrics.
- Lead time (chapter 9) · Develops lead time as a flow metric.
- Cycle time (chapter 9) · Develops cycle time as a flow metric.
- Two traps (chapter 7) · The value of smaller batches for faster feedback.
- Beyond the fundamentals (chapter 9) · The relationship between smaller batches and faster feedback.
Concepts explained in this chapter
- wip limitA rule that caps the number of work items that may be in progress at once.
- bottleneckA stage whose capacity persistently falls short of demand and limits the output of a value stream.
- work in progressWork in progress is the quantity of work that has been started but not yet completed in a process.
- flowA Lean principle of moving work continuously by reducing queues, delays, and interruptions.
- value stream mappingA Lean technique for representing and analyzing the flow of work through a value stream.
- value streamA value stream is the complete sequence of activities and handoffs through which work produces an outcome for a customer or user.
- activity ratioThe proportion of elapsed work time spent on productive activity rather than waiting or other non-progressing periods.
- kaizen burstA visual marker on a value stream map that identifies a focused improvement intervention.
- batch sizeThe number of work items grouped together for processing or delivery as one batch.
- theory of constraintsA management discipline that improves system performance by identifying and addressing the constraint that limits throughput.
- constraintA condition or limitation that restricts how work can proceed within a delivery system.
- queue timeThe elapsed time a work item spends waiting rather than being actively processed.
- inventoryInventory is the waste of work items, information, or decisions that have been started or accumulated but are not yet needed downstream.
- automationThe use of software or machines to perform tasks with reduced manual intervention.
- waiting wasteLean waste caused by people or work items being unable to proceed while awaiting input, feedback, a decision, or another process step.
- feedbackInformation about the effects or results of work that can guide subsequent decisions or changes.
- over-processingLean waste caused by doing more work or adding more complexity than is required to deliver the desired outcome.
- cycle timeThe elapsed time required for work to move through a production or delivery process.
- lead timeThe elapsed time between the start of work and delivery of its result.
- queue depthThe number of work items waiting in a queue for downstream processing.
- surface areaThe set of interfaces, behaviors, integration points, and change obligations exposed by a software component or dependency.
- CPU timeThe time spent actively progressing a change through activities such as coding, testing, fixing, and reviewing.
- wasteWork that creates no customer value and can be eliminated without harming delivery or its outcomes.
- continuous improvementA feedback loop is a process in which information about outcomes is returned to influence subsequent decisions or actions.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.
