Chapter 12: Lean operations and production
A deployment scenario shows why Lean operations must look beyond successful delivery and green dashboards to how the system actually runs.
After this chapter you will be able to
- Deployment success versus production health. Explain why a successful deployment and green dashboards did not mean the search feature was running well: requests became much slower, but the alert watched errors rather than latency.
- Development and operations questions. Distinguish a test-backed answer to whether code works from the observed, ongoing question of whether the system serves users. Explain why a feature that works in staging but degrades production is not complete.
- Continuous production outcomes. Describe why a green CI pipeline and staging are checks rather than the outcome, and why developers must observe user experience in production over time.
- Flow With Operational Quality. Explain why development velocity alone can become overproduction and why a team must consider delivery flow and operational stability together.
- Operational Lean Toolkit Shifts. Describe how gemba, standard work, jidoka, and kaizen change focus when applied after deployment.
- Distributional Production Behavior. Distinguish a binary test result from the range of behaviors a running system shows under real conditions.
- Production gemba versus dashboards. Explain why the running system, rather than a dashboard or alert channel, is the gemba in operations. Describe how summarized metrics can hide an outlier such as a slow request path.
- Single-request production tracing. Describe how to follow one real request through services, queues, database calls, and cache lookups, measuring time at each hop to locate hidden delays or a bottleneck.
- Silent degradation signature. Explain how a change can worsen user experience without triggering tests or production alerts, using the section’s examples of work moved into a synchronous request path or a cache lookup replaced by a database query.
- Production observation and its limit. Describe how looking directly at production logs revealed the misplaced resize operation, and explain why reverting that change did not prevent the same category of mistake from recurring.
- Poka-yoke for recurring mistakes. Distinguish detecting an accidental production defect from preventing it with poka-yoke, and describe the proposed CI constraint for moving async work into a synchronous request handler.
- Cause-focused production alerts. Explain why operational alerts should point to a failing resource or shared dependency rather than only to errors in a consuming service.
- Diagnostic context in alerts. Describe how including why an alert fired and what to check first makes it more actionable than a bare symptom notification.
- Urgency-based alert tiers. Distinguish when a production condition warrants a page from when a lower-urgency notification is appropriate, and explain the risk of paging for everything.
- The signal-to-stop gap. Explain why alerts alone are only half of production andon and what it means to stop the line when a signal fires.
- The cost of delayed recovery. Explain how a slow response can consume a tight availability budget and cause harm beyond the minutes of downtime.
- Internal service level expectations. Distinguish an SLE from a customer SLA and describe how a team uses SLE breaches to improve reliability.
- Cause-aware response selection. Describe how a cause-aware alert helps an engineer choose the right cord, using the analytics batch-job example.
- Predefined production stopping options. Explain what a team must define and build before an incident so it can pull the appropriate cord for each failure mode.
- Three levels of andon. Distinguish signal-only, automatic containment, and automatic recovery by explaining what the system does and what remains for a human at each level.
- Boundary for automated recovery. Explain how confidence in the diagnosis determines whether a failure should receive Level 3 automated recovery or remain at Level 2 for a human decision.
- Executable incident runbooks. Explain why an outdated prose runbook fails as standard work and how an executable runbook divides work between automation and human judgment.
- Runbook ownership and improvement. Describe who maintains a service's runbook and how incident remediation keeps it improving.
- Poka-yoke pipeline constraints. Explain how automated deployment constraints prevent recurring mistakes, using the missing migration rollback check as an example.
- Uneven demand and its consequences. Explain how mura, muri, and muda relate to a service’s changing request rate: uneven demand can push the system beyond capacity at peaks and leave provisioned resources idle at troughs.
- Uneven demand and production failures. Explain why a system sized for average load can fail under uneven demand, and how the same pattern creates overburden at peaks and wasted capacity at troughs.
- Leveled batch processing. Describe how heijunka levels a batch workload by separating acceptance from processing.
- Muri and nonlinear degradation. Explain muri as demand exceeding a production system’s capacity, even briefly, and describe why a surge can cause cascading timeouts when little capacity remains.
- Headroom for critical services. Justify leaving headroom in critical services rather than treating high steady-state utilization as efficiency. State the section’s 60–80% utilization target and what the remaining capacity protects against.
- Production waste feedback loops. Explain why production waste needs different signals from development waste and how those signals should reach the teams that can eliminate it.
- Rollback as upstream signal. Explain why a rolled-back deployment is more than an operational cost and what kind of improvement its signal should trigger.
- Production Kaizen discipline. Explain how production Kaizen applies small, measured changes to operational outcomes and connects gemba, andon, standard work, and the categories of mura, muri, and muda.
- Incident bottleneck cycles. Trace how the fintech team used incident-phase data to select a first change, measured its effect, and then addressed the new largest phase.
- Systemic post-incident reviews. Explain why an incident should trigger a review of systemic conditions rather than individual blame, and describe the concrete system changes a useful review should produce.
- Hidden incident waste. Describe how post-incident reviews expose operational waste that dashboards may miss and how removing its systemic causes compounds over successive incidents.
- Tracked incident improvements. Distinguish how a kaizen card commits a team to a measurable incident improvement from how an A3 communicates a change that crosses team boundaries.
- Direct production observation. Describe how to establish a baseline at the gemba by directly observing production and recording unexpected findings.
- Incident response and standard work. Explain how to assess recent incidents for alert quality, diagnosis time, containment, and andon level, then check whether operational safeguards are captured in standard work.
- One measured kaizen cycle. Apply the audit findings to choose one high-impact improvement, specify its Lean tool, measure success, update standard work, and decide what to do after reviewing the result.
What it builds on
- Gemba and Kaizen in software development (chapter 2) · The idea of gemba as the place to observe work directly.
- Lean metrics for developers (chapter 9) · Development flow metrics such as lead time and cycle time.
- What Kaizen actually means (chapter 10) · Introduces kaizen as continuous improvement.
- Designing for intervention: Enabling the software Andon (chapter 4) · Designing software so it can be intervened in when something goes wrong.
- By the people who do the work (chapter 10) · Improvements are made by the people who do the work.
- CI/CD: Flow enabler or disruptor? (chapter 6) · Changes move through a CI/CD pipeline toward production.
- The eight wastes in software development (chapter 2) · Introduces waste in software development.
- Waiting (chapter 2) · Waiting as a category of waste.
Section by section
Introduction
A deployment scenario shows why Lean operations must look beyond successful delivery and green dashboards to how the system actually runs.
- Deployment success versus production health: Explain why a successful deployment and green dashboards did not mean the search feature was running well: requests became much slower, but the alert watched errors rather than latency.
Why it matters: A green deployment can conceal a serious problem for users if the team is not looking at how the system performs in production.
Key terms: Lean operations, p99 latency, error rate
12.1 Shifting from development to operations mindset
This section shifts the measure of a finished feature from passing tests and deploying successfully to serving users reliably in production over time.
- Development and operations questions: Distinguish a test-backed answer to whether code works from the observed, ongoing question of whether the system serves users. Explain why a feature that works in staging but degrades production is not complete.
Why it matters: It keeps a passing test or deployment from being mistaken for a successful user outcome. - Behavior under production load: Explain the shift from checking a function’s result to considering how the system behaves when many users call it concurrently and resources are strained.
Why it matters: Correct behavior in isolation may not hold up when real users share limited resources. - Continuous production outcomes: Describe why a green CI pipeline and staging are checks rather than the outcome, and why developers must observe user experience in production over time.
Why it matters: It directs developers’ attention to the place and timescale where users actually receive value.
Key terms: development, operations, defective inventory, behavior under load, unit tests, database connection pool, green CI pipeline, production, gemba, value stream
12.1.1 Development velocity versus operational stability
This section argues that development speed must be balanced with production stability and shows how Lean thinking shifts from the development workflow to the running system.
- Flow With Operational Quality: Explain why development velocity alone can become overproduction and why a team must consider delivery flow and operational stability together.
Why it matters: A fast delivery process is not delivering value if its changes repeatedly degrade the service. - Four Operational Stability Signals: Describe the four signals the section uses to assess operational stability and what each measures.
Why it matters: These signals make the production consequences of deployments visible alongside delivery speed. - Operational Lean Toolkit Shifts: Describe how gemba, standard work, jidoka, and kaizen change focus when applied after deployment.
Why it matters: The same improvement principles still apply after deployment, but the team must observe and improve different things. - Distributional Production Behavior: Distinguish a binary test result from the range of behaviors a running system shows under real conditions.
Why it matters: A system can pass tests yet still deliver a poor experience to some users or under particular loads and failures.
Key terms: development velocity, operational stability, overproduction, flow with quality, change failure rate, mean time to recovery, availability, latency distribution, p95, p99
12.2 Gemba in production
This section shows how to observe a running production system directly to find problems that dashboards and alerts can miss.
- Production gemba versus dashboards: Explain why the running system, rather than a dashboard or alert channel, is the gemba in operations. Describe how summarized metrics can hide an outlier such as a slow request path.
Why it matters: Looking beyond summaries helps you find problems that apparently healthy metrics conceal. - Raw production log observation: Describe why the section recommends watching raw production logs in real time rather than relying only on filtered dashboard views or alerts.
Why it matters: Raw logs can expose harmful patterns before an existing alert identifies them. - Single-request production tracing: Describe how to follow one real request through services, queues, database calls, and cache lookups, measuring time at each hop to locate hidden delays or a bottleneck.
Why it matters: Following a real request turns a vague report of slowness into a specific place to investigate. - Support tickets as defect signals: Explain why even tickets closed as unreproducible or resolved by retrying can signal production defects that monitoring misses, using the blank-PDF example.
Why it matters: Taking seemingly minor tickets seriously can reveal reliability problems invisible to monitoring.
Key terms: gemba, running system, dashboard, p50 latency, p99, production logs, retry storms, connection pool churn, single request, end-to-end
12.2.1 The silent degradation pattern
The section explains how production changes can silently degrade user experience, why observing production reveals failures dashboards miss, and how mistake-proofing can prevent their recurrence.
- Silent degradation signature: Explain how a change can worsen user experience without triggering tests or production alerts, using the section’s examples of work moved into a synchronous request path or a cache lookup replaced by a database query.
Why it matters: A green dashboard does not necessarily mean users are having a good experience. - Production observation and its limit: Describe how looking directly at production logs revealed the misplaced resize operation, and explain why reverting that change did not prevent the same category of mistake from recurring.
Why it matters: Finding a production problem is valuable, but fixing that instance alone leaves room for it to happen again. - Poka-yoke for recurring mistakes: Distinguish detecting an accidental production defect from preventing it with poka-yoke, and describe the proposed CI constraint for moving async work into a synchronous request handler.
Why it matters: A constraint can protect future deployments even when nobody notices the same mistake in review or on a dashboard.
Key terms: silent degradation, error rates, gemba, dashboards, request thread, worker thread, poka-yoke, mistake proofing, structural vulnerabilities, CI check
12.3 Andon for production systems
The section explains how production alerts can act as andon signals by pointing responders toward causes, providing diagnostic context, and matching notification urgency to impact.
- Cause-focused production alerts: Explain why operational alerts should point to a failing resource or shared dependency rather than only to errors in a consuming service.
Why it matters: A cause-focused alert shortens the search from a visible failure to the problem behind it. - Diagnostic context in alerts: Describe how including why an alert fired and what to check first makes it more actionable than a bare symptom notification.
Why it matters: Context helps the responder begin a useful investigation instead of first decoding a vague notification. - Urgency-based alert tiers: Distinguish when a production condition warrants a page from when a lower-urgency notification is appropriate, and explain the risk of paging for everything.
Why it matters: Preserving the meaning of a page helps ensure that serious production problems get attention.
Key terms: operational alerting, resource, consumer, shared dependency, symptom, causal context, runbook, actionable, tier alerts by urgency, page
12.3.1 The cost of not stopping
This section explains why production andon must turn alerts into prompt action, why hesitation is costly, and how teams can use internal reliability expectations to make delays visible.
- The signal-to-stop gap: Explain why alerts alone are only half of production andon and what it means to stop the line when a signal fires.
Why it matters: An alert protects users only if the team can act on it promptly. - The cost of delayed recovery: Explain how a slow response can consume a tight availability budget and cause harm beyond the minutes of downtime.
Why it matters: A short hesitation can have consequences disproportionate to its duration. - Internal service level expectations: Distinguish an SLE from a customer SLA and describe how a team uses SLE breaches to improve reliability.
Why it matters: An internal standard gives a team a way to detect and own reliability problems before a contract forces the issue.
Key terms: andon, signal, stop, MTTR, canary rollout, 99.99% availability, four nines, error budget, Service Level Agreement (SLA), Service Level Expectation (SLE)
12.3.2 Pulling the cord
Pulling the andon cord in production means using a cause-aware signal to choose a prepared, targeted response rather than simply stopping a system that is serving customers.
- Costs of the wrong cord: Explain why pulling the andon cord in production differs from stopping a factory line, and why choosing the wrong intervention can worsen an incident.
Why it matters: A fast response helps only if it targets the source of the problem. - Cause-aware response selection: Describe how a cause-aware alert helps an engineer choose the right cord, using the analytics batch-job example.
Why it matters: Naming the cause turns an alert into guidance for a targeted, rapid response. - Predefined production stopping options: Explain what a team must define and build before an incident so it can pull the appropriate cord for each failure mode.
Why it matters: Prepared controls let a team contain a failure quickly without improvising or unnecessarily stopping customer service.
Key terms: andon cord, rollback, circuit breaker, cause-aware alerts, analytics batch job, currency exchange API, one-click action, andon cords, failure mode, degrees of running
12.3.3 Three levels of andon
This section distinguishes three levels of production andon by who detects, stops, and recovers from a problem, and explains when automated recovery is safe.
- Three levels of andon: Distinguish signal-only, automatic containment, and automatic recovery by explaining what the system does and what remains for a human at each level.
Why it matters: The levels clarify whether an alert still leaves users waiting for a person to stop the damage. - Boundary for automated recovery: Explain how confidence in the diagnosis determines whether a failure should receive Level 3 automated recovery or remain at Level 2 for a human decision.
Why it matters: Automation can speed recovery, but an uncertain diagnosis can make automatic remediation harmful. - Deployment rollback as Level 3: Describe how the deployment example detects an elevated error rate, rolls back automatically, and informs a human afterward.
Why it matters: The example makes the difference between being paged to recover a system and being notified of an automatic recovery concrete.
Key terms: andon, signal, stop, recover, blast radius, Level 2, Level 3, confidence in the diagnosis, auto-remediating, automatic rollback
12.4 Standard work for operations and incident response
This section shows how executable runbooks and automated pipeline constraints turn operational experience into standard work that improves after incidents and prevents repeat mistakes.
- Production feedback and standard work: Explain why service teams should feed production waste back into planning, and name the three forms of operational standard work described here.
Why it matters: Production problems become useful signals when the team feeds them back into its work. - Executable incident runbooks: Explain why an outdated prose runbook fails as standard work and how an executable runbook divides work between automation and human judgment.
Why it matters: An executable runbook can guide an on-call engineer through the current system rather than a process that no longer exists. - Runbook ownership and improvement: Describe who maintains a service's runbook and how incident remediation keeps it improving.
Why it matters: Updating the runbook during remediation turns each newly discovered gap into guidance for the next incident. - Poka-yoke pipeline constraints: Explain how automated deployment constraints prevent recurring mistakes, using the missing migration rollback check as an example.
Why it matters: A check built into the pipeline prevents a repeatable production mistake without depending on someone remembering a warning under pressure.
Key terms: production waste, standard work, runbooks, incident response procedures, pipeline constraints, executable runbook, diagnostic steps, human judgment, service-owning team, incident remediation
12.5 Mura, Muri, Muda
This section explains how uneven production demand creates both overload during peaks and wasted capacity during lulls, and why those risks can be easy to miss.
- Uneven demand and its consequences: Explain how mura, muri, and muda relate to a service’s changing request rate: uneven demand can push the system beyond capacity at peaks and leave provisioned resources idle at troughs.
Why it matters: Looking at demand’s shape can reveal a shared cause of production failures and wasted capacity. - Hidden production capacity risks: Describe why uneven demand and overburden may be less obvious than waste in production metrics, including how a seemingly healthy steady-state reading can conceal insufficient headroom for a surge.
Why it matters: A healthy-looking average or steady-state metric may not show whether a service can withstand its next peak.
Key terms: mura, muri, muda, overburden, time series data, steady state metrics, headroom
12.5.1 Mura: The unevenness that causes outages
This section explains how uneven demand causes production incidents and how workload leveling can prevent peaks from overwhelming a system without reducing total work.
- Uneven demand and production failures: Explain why a system sized for average load can fail under uneven demand, and how the same pattern creates overburden at peaks and wasted capacity at troughs.
Why it matters: Recognizing the shape of demand helps explain outages that total volume or average utilization cannot. - Leveled batch processing: Describe how heijunka levels a batch workload by separating acceptance from processing.
Why it matters: Separating intake from processing can absorb an arrival spike without requiring capacity for that instant’s peak. - Leveling traffic that cannot wait: Distinguish leveling options for traffic that needs a response from options that spread scheduled batch work.
Why it matters: The appropriate way to smooth demand depends on whether work can wait or needs an immediate response.
Key terms: mura, peak-to-trough ratio, muri, muda, heijunka, leveling, decouple acceptance from processing, batch workloads, rate limiter, geographic load distribution
12.5.2 Muri: The overburden that breaks things
This section explains how production systems become overburdened when fluctuating demand meets insufficient capacity, and why headroom and steadier demand reduce outage risk.
- Muri and nonlinear degradation: Explain muri as demand exceeding a production system’s capacity, even briefly, and describe why a surge can cause cascading timeouts when little capacity remains.
Why it matters: A service that looks efficient under normal traffic can fail sharply during a surge. - Headroom for critical services: Justify leaving headroom in critical services rather than treating high steady-state utilization as efficiency. State the section’s 60–80% utilization target and what the remaining capacity protects against.
Why it matters: Spare capacity is protection against predictable surges, not necessarily wasted capacity. - Mura and muri together: Distinguish mura’s demand surges from muri’s overburden, and explain how demand leveling and headroom work together to reduce production risk.
Why it matters: Reducing demand spikes and preserving capacity margin address two connected sources of outage risk.
Key terms: muri, overburden, capacity, cascading timeouts, headroom, 60–80% utilization, critical services, mura, leveled demand
12.5.3 Muda: Capturing operational waste
This section shows how to detect waste in production and feed its signals back into development so teams can eliminate the waste at its source.
- Production waste feedback loops: Explain why production waste needs different signals from development waste and how those signals should reach the teams that can eliminate it.
Why it matters: Production signals become useful when they lead to changes that remove waste, rather than remaining isolated operational metrics. - Waiting and overprocessing signals: Describe how queue delays and unused API response fields reveal operational waste, and how each can become a concrete development improvement target.
Why it matters: Specific production costs give teams a stronger improvement target than a vague tech-debt item. - Rollback as upstream signal: Explain why a rolled-back deployment is more than an operational cost and what kind of improvement its signal should trigger.
Why it matters: Treating a rollback as feedback helps prevent the same kind of failure from recurring.
Key terms: TIMWOODS, operational waste, feedback loops, development value stream, waiting, overprocessing, queue, API response, rolled-back deployment, defect
12.6 Production Kaizen
This section shows how production teams use repeated, measured Kaizen cycles to improve operational outcomes by addressing the current bottleneck with an appropriate Lean tool.
- Production Kaizen discipline: Explain how production Kaizen applies small, measured changes to operational outcomes and connects gemba, andon, standard work, and the categories of mura, muri, and muda.
Why it matters: The cycle gives teams a way to improve production without assuming one tool or solution fits every problem. - Incident bottleneck cycles: Trace how the fintech team used incident-phase data to select a first change, measured its effect, and then addressed the new largest phase.
Why it matters: Re-measuring after a change prevents a team from continuing to optimize yesterday’s bottleneck. - Problem matched operational changes: Explain why the countermeasure changes with the observed problem, including why reproducible infrastructure matters when environment drift causes debugging waste.
Why it matters: Matching the change to the measured problem avoids applying a familiar fix to the wrong source of waste.
Key terms: production kaizen, gemba, andon, standard work, mura, muri, MTTR, diagnosis, remediation, andon Level 3
12.6.1 Post-incident reviews as kaizen triggers
This section shows how post-incident reviews turn production failures into concrete, tracked system improvements.
- Systemic post-incident reviews: Explain why an incident should trigger a review of systemic conditions rather than individual blame, and describe the concrete system changes a useful review should produce.
Why it matters: A review helps prevent recurrence only when it changes the system, not when it assigns blame. - Hidden incident waste: Describe how post-incident reviews expose operational waste that dashboards may miss and how removing its systemic causes compounds over successive incidents.
Why it matters: The time lost during recovery points to fixable conditions that ordinary dashboards may not show. - Tracked incident improvements: Distinguish how a kaizen card commits a team to a measurable incident improvement from how an A3 communicates a change that crosses team boundaries.
Why it matters: These formats keep a review finding from ending as an unowned observation.
Key terms: kaizen trigger, post-incident review, poka-yoke, executable runbook, andon, muda, standard work, production kaizen, kaizen card, baseline measurement
12.7 Exercise: Audit your production system through the Lean operations lens
This exercise guides a production audit that turns direct observations and operational evidence into one measured kaizen cycle.
- Direct production observation: Describe how to establish a baseline at the gemba by directly observing production and recording unexpected findings.
Why it matters: Unexpected observations give the rest of the audit evidence to work from. - Incident response and standard work: Explain how to assess recent incidents for alert quality, diagnosis time, containment, and andon level, then check whether operational safeguards are captured in standard work.
Why it matters: This review makes the gap between an alert and an effective, repeatable response visible. - Uneven load and overburden: Describe how to use hourly service data to identify unevenness, its likely source, and whether peak load overburdens a constrained resource.
Why it matters: Average load can conceal peaks that strain the system. - Production waste feedback: Explain how to check whether a persistent production waste signal reaches the development team as actionable work.
Why it matters: A visible production signal can only drive improvement if it reaches the people planning the work. - Service level expectation check: State which three targets to draft for an SLE, or how to assess an existing SLE against recent actual results.
Why it matters: Explicit targets make it possible to spot where operational results fall shortest. - One measured kaizen cycle: Apply the audit findings to choose one high-impact improvement, specify its Lean tool, measure success, update standard work, and decide what to do after reviewing the result.
Why it matters: Choosing and measuring one change turns a broad audit into an improvement the team can evaluate.
Key terms: gemba, production system, andon, cord, executable runbook, standard work, mura, muri, peak-to-trough ratio, operational waste
12.8 Summary
Where this is used later
- Respect for people as engineering practice (chapter 13) · Introduces andon for production systems.
- Respect in process: Building the conditions for honesty (chapter 13) · The andon cord as a way to call attention to a problem.
- Building a culture of continuous learning (chapter 15) · Treating post-incident reviews as opportunities for improvement.
Concepts explained in this chapter
- continuous improvementA feedback loop is a process in which information about outcomes is returned to influence subsequent decisions or actions.
- poka-yokePoka-yoke is a mistake-proofing technique that uses a physical or logical barrier to prevent an error from occurring.
- standard workA single prescribed method applied across teams regardless of differences in their work contexts.
- AndonA visual management system that signals abnormal conditions so work can be stopped or corrected.
- muraUnevenness or variability in workload or process conditions that disrupts smooth production flow.
- muriMuri is overburden that occurs when demand exceeds a system’s capacity, leaving insufficient margin to absorb variation.
- SLEAn internal expectation that states the level of service performance a team expects its system to deliver.
- GembaThe actual place where work occurs and value is created, viewed in Lean management as the location for direct observation.
- wasteWork that creates no customer value and can be eliminated without harming delivery or its outcomes.
- constraintA condition or limitation that restricts how work can proceed within a delivery system.
- executable runbookAn operational procedure whose diagnostic steps are implemented as code that can run automatically and present results for human decisions.
- runbookA runbook is a documented set of operational procedures for diagnosing, mitigating, or recovering from known system conditions.
- postincident analysisA post-incident review is a structured examination of an operational incident and the conditions that allowed it to occur.
- Andon cordA cord that a worker pulls to signal an abnormality and prompt immediate attention or correction.
- queue depthThe number of work items waiting in a queue for downstream processing.
- value streamA value stream is the complete sequence of activities and handoffs through which work produces an outcome for a customer or user.
- kaizen cardA record of a proposed process improvement that specifies its baseline, change, owner, and target outcome.
- headroomUnused system capacity reserved to absorb changes or variation in demand without degrading service.
- change failure rateThe proportion of software changes that cause a failure requiring remediation, rollback, or another corrective response.
- jidokaA Lean production approach that builds quality into processes by stopping when abnormalities occur and preventing defects from proceeding.
- mean time to resolutionThe average time required to restore a system or service after an incident.
- bugA fault in software that can cause incorrect, unreliable, or unintended behavior.
- over-processingLean waste caused by doing more work or adding more complexity than is required to deliver the desired outcome.
- process variationFluctuation in a process’s measured outcomes over time or across operating conditions.
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.
