Sattvam AI/Lean
741 substrates · 2,536 aliases · 47,138 mined phrases · v1.2.0

rule 150

KeyNameDetailAliases
MAP_MUST_HAVE_CUSTOMER Map must start from customer requirements hasCustomer == 0 error convention
Mapping begins with the customer requirements; no customer node is present.
map must start from customer requirements
MAP_MUST_HAVE_SUPPLIER Map must show at least one supplier supplierCount == 0 error convention
The door-to-door map must include delivery of at least one main raw material.
map must show at least one supplier
MAP_MUST_HAVE_INFORMATION_FLOW Material and information flow are two sides of the same coin informationFlowCount == 0 error convention
Information flow is missing. In lean manufacturing it is treated with as much importance as material flow — you must map both.
material and information flow are two sides of the same coin
MAP_MUST_HAVE_TIMELINE Map must carry a lead-time timeline hasTimeline == 0 error convention
Draw a timeline under the process boxes and inventory triangles to compile production lead time.
map must carry a lead-time timeline
EVERY_PROCESS_NEEDS_A_DATA_BOX Every process box needs a data box processesWithoutDataBox > 0 error convention
A data box is drawn under each process box. Processes are missing their data.
every process box needs a data box
EVERY_PROCESS_MUST_BE_LABELLED All processes must be labelled unlabelledProcessCount > 0 error convention
One process box equals an area of flow, and all processes should be labelled.
all processes must be labelled
INVENTORY_NEEDS_COUNT_AND_TIME Inventory triangles need count and time inventoryMissingQuantityOrDays > 0 error convention
Count and time should both be noted below every inventory triangle.
inventory triangles need count and time
FIFO_NEEDS_MAX_QUANTITY FIFO lanes need a maximum quantity fifoWithoutMaxQuantity > 0 error convention
A FIFO lane limits quantity — the maximum quantity must be indicated.
fifo lanes need a maximum quantity
SAFETY_STOCK_MUST_BE_TYPED Safety versus buffer stock must be labelled untypedBufferCount > 0 error convention
"Buffer" or "Safety Stock" must be noted on the closed-sided store icon.
safety versus buffer stock must be labelled
TRUCK_NEEDS_FREQUENCY Truck shipments need a frequency truckWithoutFrequency > 0 warn convention
Note the frequency of shipments on every truck icon.
truck shipments need a frequency
TIMELINE_MUST_MATCH_DATA_BOXES The timeline must agree with the data boxes timelineCycleMismatchCount > 0 error convention
The lower rung of the timeline does not match the cycle times in the data boxes above it. The same figure is drawn twice on a value stream map, and the two disagree, so one of them is wrong. Re-time the process and redraw the ladder from what the stopwatch says.
the timeline must agree with the data boxes
PROCESSING_TIME_MUST_SUM_THE_DATA_BOXES Processing time must be the sum of the data boxes timelineProcessingTimeError > 0.02 error convention
The value-adding time quoted at the foot of the map is not the sum of the cycle times in the data boxes. That total is the number the whole map argues about — the fraction of lead time spent adding value — so it cannot be carried separately from the figures it comes from.
processing time must be the sum of the data boxes
MATERIAL_FLOWS_LEFT_TO_RIGHT Material flows left to right on the lower half materialFlowDirectionViolations > 0 error convention
Material flow is drawn left to right on the bottom half of the map, in processing order — not by plant layout.
material flows left to right on the lower half
INFORMATION_FLOWS_RIGHT_TO_LEFT Information flows right to left on the upper half informationFlowDirectionViolations > 0 error convention
Information flow is drawn right to left across the top half of the map.
information flows right to left on the upper half
ONE_PRODUCT_FAMILY_PER_MAP One product family per map productFamilyCount > 1 error discipline
Value stream mapping means walking one product family from door to door. Drawing all product flows on one map is too complicated.
one product family per map
TAKT_REQUIRED_ON_FUTURE_STATE Future state must state takt time isFutureState == 1 && hasTaktTime == 0 error design
On the future-state map takt times are noted in the data boxes. Question 1 has not been answered.
future state must state takt time
TAKT_MUST_USE_NET_AVAILABLE_TIME Takt must be computed on net available time taktUsesGrossTime == 1 error design
Subtract breaks, meetings and cleanup from shift length before dividing by customer demand.
takt must be computed on net available time
PACEMAKER_CYCLE_ABOVE_TAKT Pacemaker cannot cycle slower than takt pacemakerCycleTime > taktTime error design
The pacemaker cycles slower than takt and cannot meet customer demand within available time.
pacemaker cannot cycle slower than takt
PACEMAKER_CYCLE_FAR_BELOW_TAKT Large takt-to-cycle gap hides production problems hasPacemaker == 1 && taktTime > 0 && pacemakerCycleTime < taktTime * 0.6 warn improvement
Cycling much faster than takt compensates for production problems and removes the incentive to eliminate them. If you cycle faster than takt there should be a plan for closing the gap.
large takt-to-cycle gap hides production problems
CHANGEOVER_TIME_JUSTIFIES_FASTER_THAN_TAKT Cycling under takt is justified when changeovers must fit pacemakerCycleTime < taktTime && changeoverAllowance > 0.05 info improvement
Cycling below takt is intentional here: it leaves time in the shift for the required changeovers.
cycling under takt is justified when changeovers must fit
PREFER_FLOW_OVER_PULL Do not set up a pull system where continuous flow is possible pullBetweenFlowCapableProcesses > 0 warn design
Continuous flow gives the biggest reduction in waste and lead time. Do not set up a pull system if you can create continuous flow.
do not set up a pull system where continuous flow is possible
FLOW_CANDIDATES_HAVE_CLOSE_CYCLE_TIMES Adjacent processes with close cycle times should flow adjacentFlowCandidateCount > 0 && isFutureState == 1 warn improvement
Adjacent dedicated processes have cycle times close to each other and to takt — they can be placed in a continuous flow.
adjacent processes with close cycle times should flow
NO_INVENTORY_INSIDE_CONTINUOUS_FLOW No inventory triangles inside a continuous flow inventoryInsideFlowCount > 0 error design
Continuous flow means each item passes immediately to the next step, with at most one piece at automated processes.
no inventory triangles inside a continuous flow
MONUMENT_CANNOT_JOIN_FLOW Monument processes cannot be forced into a flow monumentInFlowCount > 0 warn design
Incorporating a fast, shared process into a continuous flow would slow it to takt and dedicate it to one family — a vastly underutilised machine. Control it with a supermarket pull instead.
monument processes cannot be forced into a flow
FRACTIONAL_MANNING_NEEDS_KAIZEN Fractional manning must be resolved by kaizen or overtime operatorsRequiredFraction > 0.05 && operatorsRequiredFraction < 0.5 warn improvement
Work content divided by takt leaves a fractional operator. Reduce work content by process kaizen to bring it under the takt ceiling, or plan overtime.
fractional manning must be resolved by kaizen or overtime
OPERATOR_OVER_TAKT No operator may be loaded above takt maxOperatorUtilisation > 1 error design
Distribute work elements so that each operator's work content is just below takt time.
no operator may be loaded above takt
FLOW_MERGES_LEAD_AND_DOWN_TIMES A coupled process must hold the availability its own load requires flowMembersBelowDerivedTarget > 0 warn design
Coupling processes merges their down times: with no stock at the boundary, the cell stops whenever any member of it stops. One or more coupled processes here do not hold the availability their own load and recovery require — not a general reliability standard, but the figure that this demand, this effective cycle and this mean time to recover imply for this boundary. Either raise availability to that figure, take work content out to create the margin, or put a FIFO lane at the boundary long enough to cover the recovery.
a coupled process must hold the availability its own load requires
PUSH_ARROWS_ON_FUTURE_STATE Future state should not rely on push isFutureState == 1 && pushLinkCount > 0 error design
Push means producing regardless of the downstream need. A lean future state links every process to its customer by continuous flow or pull.
future state should not rely on push
INDEPENDENT_SCHEDULE_UPSTREAM Do not independently schedule batch processes isFutureState == 1 && upstreamScheduledProcessCount > 0 error design
Resist scheduling batch processes independently — a schedule is only an estimate of what the next process will need. Link them to their downstream customer via pull.
do not independently schedule batch processes
SUPERMARKET_NEEDS_KANBAN A supermarket needs kanban as its only production instruction supermarketWithoutKanbanCount > 0 error convention
Withdrawals trigger kanban movement from the supermarket to the supplying process, where they are the only production instruction.
a supermarket needs kanban as its only production instruction
PULL_REQUIRES_NO_PRODUCTION_WITHOUT_KANBAN To qualify as pull, nothing moves without a kanban pullWithoutKanbanDiscipline == 1 error design
To qualify as pull, parts must not be produced or conveyed when there is no kanban, and quantity must match the kanban. "Go see" adjustments are not a true pull.
to qualify as pull, nothing moves without a kanban
CUSTOM_PARTS_NEED_FIFO_NOT_SUPERMARKET Custom or perishable parts need FIFO, not a supermarket productVariations > 100 && finishedGoodsStrategyIsSupermarket == 1 warn design
With very many configurations it is impractical to stock all variations. Use a FIFO lane between decoupled processes instead of a supermarket.
custom or perishable parts need fifo, not a supermarket
SIGNAL_KANBAN_WHEN_CHANGEOVER_DOMINATES Use a signal kanban when changeover forces a batch changeoverTime > containerQuantity * cycleTime info improvement
Replenishing bin-for-bin is impractical when a changeover costs more than a container of run time. Use a signal kanban at a trigger point to launch a predetermined batch.
use a signal kanban when changeover forces a batch
SUPERMARKET_LOCATED_AT_SUPPLYING_PROCESS Supermarkets belong to the supplying process supermarketMislocatedCount > 0 warn design
Supermarkets should be located near the supplying process so it keeps a visual sense of customer usage.
supermarkets belong to the supplying process
FIFO_FULL_STOPS_UPSTREAM A full FIFO lane must stop the upstream process fifoOverflowAllowed == 1 error design
If the FIFO lane gets full the supplying process must stop producing until the customer has used some inventory.
a full fifo lane must stop the upstream process
SEQUENCED_PULL_NEEDS_SHORT_LEAD_TIME Sequenced pull needs a short supplying lead time sequencedPullCount > 0 && supplyingLeadTimeSeconds > taktTime * 20 warn design
Sequenced pull works only if lead time in the supplying process is short enough for production to order.
sequenced pull needs a short supplying lead time
SAFETY_STOCK_IS_TEMPORARY Safety stock must be temporary and controlled safetyStockDays > 0 && safetyStockHasRootCausePlan == 0 warn discipline
Safety stock should be temporary — used only until the root cause is found and eliminated. There should be strict rules for using it.
safety stock must be temporary and controlled
EXACTLY_ONE_SCHEDULING_POINT Schedule exactly one point in the stream isFutureState == 1 && schedulePoints != 1 error design
Send the customer schedule to only one production process — the pacemaker. This single point regulates the entire value stream.
schedule exactly one point in the stream
NO_PULL_DOWNSTREAM_OF_PACEMAKER Everything downstream of the pacemaker must flow pullDownstreamOfPacemakerCount > 0 error design
All material transfers downstream of the pacemaker process need to occur as a flow — no supermarkets or pulls.
everything downstream of the pacemaker must flow
PACEMAKER_IS_MOST_DOWNSTREAM_FLOW Nothing downstream of the pacemaker should still be forming the product isFutureState == 1 && hasPacemaker == 1 && pacemakerIsMostDownstreamFlow == 0 && (productVariations < 50 || transformingProcessesDownstreamOfPacemaker > 1) warn design
The pacemaker is where the customer's order rate enters the stream, so it belongs at the last point that gives the product its form. Processes downstream of it should flow to its pace without a schedule of their own — and here one or more operations downstream are still transforming the product, which leaves that stretch of the stream taking instructions from somewhere other than the pace. A control point downstream is not this defect: an inspection confirms the form rather than conferring it, and it can flow FIFO on the pacemaker's pace. High product variety is a reason to move the pacemaker upstream of a build-to-order area — one step upstream, not to the head of the stream.
nothing downstream of the pacemaker should still be forming the product
CUSTOM_PRODUCTS_SCHEDULE_UPSTREAM Custom products schedule further upstream productVariations > 100 && pacemakerIndex <= 2 info improvement
With custom products and job shops the scheduling point often needs to be further upstream, where product variation arises, with FIFO flow downstream of it.
custom products schedule further upstream
MRP_SHOULD_NOT_SCHEDULE_SHOP_FLOOR Strip MRP of shop-floor scheduling mrpSchedulesShopFloor == 1 && isFutureState == 1 warn discipline
Get rid of those elements of MRP that try to schedule different areas of the plant. Let downstream withdrawals determine upstream production.
strip mrp of shop-floor scheduling
GO_SEE_IS_NOT_PULL "Go see" scheduling is not pull goSeeSchedulingCount > 0 && isFutureState == 1 warn discipline
Adjusting schedules by checking inventory levels is not a true pull. Incorporate it honestly on the current state, then design it out.
"go see" scheduling is not pull
ORDER_TO_DELIVERY_ONLY_COUNTS_DOWNSTREAM Order-to-delivery covers only pacemaker-downstream processes hasPacemaker == 1 info improvement
Your order-to-delivery lead time involves only those processes from the pacemaker downstream to delivery.
order-to-delivery covers only pacemaker-downstream processes
DIRECT_TO_SHIPPING_NEEDS_RELIABILITY Building directly to shipping needs reliability or safety stock finishedGoodsStrategyIsDirect == 1 && pacemakerUptime < 0.95 && safetyStockDays == 0 warn design
Building directly to shipping requires either a reliable short-lead-time order-to-delivery stream, or more safety stock.
building directly to shipping needs reliability or safety stock
FUTURE_STATE_NEEDS_LEVELLING Multi-product future state must level the mix isFutureState == 1 && productVariations > 1 && hasLevelling == 0 error design
With multiple products, lack of levelling means you are still batching your builds. Level the mix at the pacemaker.
multi-product future state must level the mix
SINGLE_PRODUCT_STILL_LEVELS_VOLUME Even a single product must level volume isFutureState == 1 && productVariations == 1 && hasPacedWithdrawal == 0 warn improvement
Even if you produce only one product you still need to level the production volume.
even a single product must level volume
PITCH_REQUIRED_ON_FUTURE_STATE Future state must declare a pitch isFutureState == 1 && hasPitch == 0 error design
Question 7 is unanswered: state the consistent increment of work released and taken away at the pacemaker.
future state must declare a pitch
PITCH_MUST_EQUAL_TAKT_TIMES_PACK Pitch must be consistent with takt and pack size pitchConsistencyError > 0.02 error design
Pitch is takt time multiplied up to a finished-goods transfer quantity: pitch = takt × pack size.
pitch must be consistent with takt and pack size
TAKT_LONGER_THAN_A_SHIFT A takt longer than a shift is a planning figure, not a pace taktTime > availableWorkTimePerShift warn improvement
Takt here is longer than a whole shift, so it cannot be used to pace work at the station. Treat it as the capacity check it is, and manage the stream by the schedule and the queue in front of the constraint.
a takt longer than a shift is a planning figure, not a pace
PITCH_WITHIN_MANAGEMENT_WINDOW Pitch should sit between 5 and 60 minutes hasPitch == 1 && (pitch < 300 || pitch > 3600) warn improvement
Release only a small consistent amount of production instruction — usually between 5 and 60 minutes worth — at the pacemaker.
pitch should sit between 5 and 60 minutes
NO_TAKT_IMAGE_WHEN_BATCH_RELEASED Releasing a shift of kanban at once destroys takt image kanbanReleasedPerBatch > 1 && isFutureState == 1 error design
Returning a whole batch of kanban to the cell provides no takt image. Bring one kanban at a time at the pitch increment.
releasing a shift of kanban at once destroys takt image
LEVELLING_NEEDS_LOW_CHANGEOVER Levelling the mix requires near-zero changeover at the pacemaker hasLevelling == 1 && pacemakerChangeoverTime > taktTime warn improvement
To allow production to takt and mix levelling, the pacemaker should incur little or no changeover time and change over very frequently.
levelling the mix requires near-zero changeover at the pacemaker
LEVELLING_NEEDS_ALL_VARIANTS_AT_LINE Levelling requires all variants at the line with failsafes hasLevelling == 1 && allVariantsAtLine == 0 warn improvement
Frequent changeovers require keeping all fixtures and component varieties near the operator's fingertips — and failsafe devices to prevent the wrong ones being assembled.
levelling requires all variants at the line with failsafes
MIX_SEQUENCE_MUST_ALTERNATE Levelled sequence must alternate, not group maxConsecutiveSameVariant > 3 && hasLevelling == 1 error design
Leveling means alternating repeatedly between smaller batches, not producing all of one type then all of another.
levelled sequence must alternate, not group
EPE_REQUIRED_UPSTREAM Upstream fabrication must declare EPE or batch size upstreamProcessWithoutEpeCount > 0 warn improvement
Note either the batch sizes or EPE in the data boxes of fabrication processes upstream of the pacemaker.
upstream fabrication must declare epe or batch size
EPE_TARGET_EVERY_DAY Initial EPE goal is every part every day maxEpeDays > 1 warn improvement
An initial goal at many plants is to make at least every part every day for high-running part numbers.
initial epe goal is every part every day
CHANGEOVER_BUDGET_TEN_PERCENT Changeover time should stay near 10% of available time changeoverAllowance > 0.15 warn improvement
A typical target is approximately 10% of available time used for changeovers. Reduce changeover time or improve uptime to run smaller batches.
changeover time should stay near 10% of available time
BATCH_SIZE_MUST_FIT_CHANGEOVER_CAPACITY Batch size must be feasible given changeover capacity requiredChangeoversPerDay > changeoversAvailablePerDay error design
The declared batch size requires more changeovers per day than the available time allows.
batch size must be feasible given changeover capacity
CAPACITY_MUST_COVER_DEMAND Process capacity must cover demand minProcessCapacityRatio < 1 error design
Available work time divided by cycle time multiplied by uptime is below the demand this process must serve.
process capacity must cover demand
LEAD_TIME_MUST_EXCEED_PROCESSING_TIME Lead time must be at least processing time productionLeadTimeSeconds < processingTimeSeconds error design
Production lead time cannot be shorter than the sum of value-adding times.
lead time must be at least processing time
INVENTORY_DAYS_MUST_RECONCILE Inventory days must reconcile with quantity and demand inventoryDaysReconciliationError > 0.05 error design
Lead time for each inventory triangle is inventory quantity divided by the daily customer requirement.
inventory days must reconcile with quantity and demand
LEAD_TIME_MUST_EQUAL_SUM_OF_SEGMENTS Total lead time must equal the sum of its segments leadTimeSumError > 0.05 error design
Total production lead time is the sum of the lead times through each process and each inventory triangle.
total lead time must equal the sum of its segments
MULTIPLE_FLOWS_USE_LONGEST_PATH With merging flows use the longest time path mergingFlowCount > 0 && usesLongestPath == 0 error discipline
For maps with multiple upstream flows, use the longest time path to compute total lead time.
with merging flows use the longest time path
INVENTORY_TURNS_MUST_RECONCILE Inventory turns must reconcile with lead time inventoryTurnsReconciliationError > 0.1 error design
A shorter production lead time increases inventory turns; the two figures must be consistent.
inventory turns must reconcile with lead time
VALUE_ADDED_RATIO_SHOCK Compare value-added time to lead time explicitly valueAddedRatio < 0.01 info improvement
Comparing value-added time to total lead time should give you quite a shock — this is the core insight the map exists to deliver.
compare value-added time to lead time explicitly
SUPERMARKET_SIZED_FOR_REPLENISHMENT Supermarkets must cover replenishment plus a hedge supermarketDays < replenishmentDays warn design
Size the supermarket to cover the replenishment delay, with a modest extra allowance for supplying-process problems.
supermarkets must cover replenishment plus a hedge
COMMITMENT_NEEDS_OBSERVED_FACTS A design resting on assumptions is not a commitment claimsImplementationReady == 1 && assumedFactCount > 0 error discipline
This map calls itself ready to implement while facts it depends on were assumed rather than observed. Walk the floor and establish them, or call the map a hypothesis.
a design resting on assumptions is not a commitment
COMMITMENT_NEEDS_TEAM_VALIDATION The value-stream team has to have agreed it claimsImplementationReady == 1 && teamValidationComplete == 0 error discipline
A future state becomes a commitment when the functions that have to deliver it have agreed it. Record the sign-offs before implementing against this map.
the value-stream team has to have agreed it
PLANT_CALENDAR_MUST_RECONCILE Monthly and annual working days must agree hasPlantCalendar == 1 && calendarReconciled == 0 error convention
The working days a month and the working days a year on this map do not multiply out. Every rate derived from them — takt, pitch, the annual plan, the benefit case — inherits the difference.
monthly and annual working days must agree
FLOW_DESIGN_MUST_NOT_REST_ON_UNKNOWNS A flow decision needs the inputs it was made from flowDesignProvisional == 1 warn validation
Where flow starts and stops rests in part on inputs nobody supplied, so those boundaries are drawn the safe way and marked provisional. State changeover frequency, the families and SKUs on each shared resource, and demand by family: the answer may allow a tighter link than the one drawn here, and until it arrives this stretch of the design is a proposal rather than a plan.
a flow decision needs the inputs it was made from
IDEAL_STATE_CARRIES_NO_DATE The ideal state is a direction, not a schedule idealStateDated == 1 warn design
The ideal state has been given a date. It is the condition to steer by once every enabling condition has landed; dating it turns a direction into a promise nobody made.
the ideal state is a direction, not a schedule
EVERY_BUFFER_NEEDS_A_STATED_CAUSE A buffer must say why it is there unjustifiedBufferCount > 0 warn design
A buffer left on the future state without a stated cause and a condition that would remove it becomes permanent by default. Name what each one is absorbing.
a buffer must say why it is there
EVENT_IS_NOT_THE_IMPLEMENTATION A kaizen event is shorter than the change it starts planItemsEventEqualsImplementation > 0 error discipline
A plan item gives its kaizen event the same duration as the change it lands. The event runs three to five days; standard work, training and holding the result take longer, and reporting one number for both understates the programme.
a kaizen event is shorter than the change it starts
DEFECT_NOT_BLAMED_ON_ITS_DETECTOR The station that found a defect did not make it defectFamiliesBlamingTheirDetector > 0 error design
A defect family is attributed to the station that detected it. A countermeasure aimed there can only inspect harder; find the operation that creates the defect and prevent it at source.
the station that found a defect did not make it
FUTURE_STATE_MUST_IMPROVE_LEAD_TIME Future state must beat the current state isFutureState == 1 && futureLeadTime >= currentLeadTime error design
A future state that does not shorten production lead time has not eliminated any source of waste.
future state must beat the current state
FUTURE_STATE_NEEDS_KAIZEN_BURSTS Future state must name the process improvements it depends on isFutureState == 1 && kaizenBurstCount == 0 error design
Question 8 is unanswered: mark the equipment and procedural improvements the design depends on with kaizen lightning bursts.
future state must name the process improvements it depends on
NEEDS_VALUE_STREAM_MANAGER One person must own the whole stream hasValueStreamManager == 0 error discipline
One person needs lead responsibility for understanding and improving the product family's value stream, reporting to the top person on site.
one person must own the whole stream
DO_NOT_SPLIT_THE_MAP Do not split the mapping task between managers mapperCount > 1 && mapStitchedFromSegments == 1 error discipline
Do not split the mapping task among area managers and stitch their segments together. Map the whole value stream yourself.
do not split the mapping task between managers
DATA_MUST_BE_WALKED_NOT_FILED Current-state data must be collected by walking the flow dataFromFileSystemOnly == 1 warn discipline
Always collect current-state information while walking the actual flows yourself. Numbers in a file rarely reflect current reality.
current-state data must be collected by walking the flow
WALK_UPSTREAM_FROM_SHIPPING Begin at shipping and work upstream walkedDownstream == 1 info discipline
Begin at the shipping end and work upstream, so you start with the processes linked most directly to the customer.
begin at shipping and work upstream
CURRENT_STATE_WITHOUT_FUTURE_STATE_IS_MUDA A current state without a future state is waste hasCurrentState == 1 && hasFutureState == 0 error discipline
A current-state map and the effort to create it are pure muda unless you use it to create and implement a future-state map.
a current state without a future state is waste
THERE_MUST_ALWAYS_BE_A_FUTURE_STATE There must always be a future-state map futureStateAchieved == 1 && nextFutureStateDrawn == 0 warn discipline
As your future state becomes reality, a new future-state map should be drawn. There must always be a future-state map.
there must always be a future-state map
PLAN_NEEDS_LOOPS_AND_DEADLINES The plan needs loops, measurable goals and named reviewers hasValueStreamPlan == 1 && (planHasLoops == 0 || planHasReviewers == 0 || planHasDeadlines == 0) error discipline
The yearly value stream plan must state exactly what will be done by when, with measurable goals and clear checkpoints with real deadlines and named reviewers.
the plan needs loops, measurable goals and named reviewers
FUTURE_STATE_NEEDS_A_PLAN A future state without a plan is only a drawing isFutureState == 1 && hasValueStreamPlan == 0 error discipline
A future-state map with no value stream plan behind it changes nothing. Split the future state into loops and commit each one to a named owner with a deadline, or the drawing will hang on the wall while the stream stays as it is.
a future state without a plan is only a drawing
START_AT_PACEMAKER_LOOP Start implementation in the pacemaker loop firstLoopIsPacemaker == 0 && loopCount > 1 info discipline
One effective strategy is to begin implementation in the downstream pacemaker loop and steadily transition upstream.
start implementation in the pacemaker loop
LOOP_SEQUENCE_FLOW_PULL_LEVEL_KAIZEN Within a loop: flow, then pull, then levelling, then kaizen loopSequenceViolations > 0 warn discipline
Improvements to a loop follow a pattern: develop continuous flow at takt, establish pull, introduce levelling, then practise kaizen continuously.
within a loop: flow, then pull, then levelling, then kaizen
DO_NOT_GET_STUCK_IN_PROCESS_IMPROVEMENT Let flow improvements drive process improvements processImprovementsBlockingFlow == 1 warn discipline
When in doubt, move forward on flow improvements and let them drive the supporting process improvements. Do not get stuck in process improvement.
let flow improvements drive process improvements
CREATE_PULL_FOR_IMPROVEMENT Create a pull for the improvement, do not push a team kaizenBurstCount > 0 info improvement
Kick off improvement projects by creating a pull: state that in 30 days the batch size will be reduced, rather than pushing a team to reduce setup time.
create a pull for the improvement, do not push a team
MEASURES_MUST_NOT_FIGHT_FLOW Performance measures must not be counter-productive to flow utilisationBasedMeasures == 1 warn discipline
Measures emphasising equipment utilisation or overhead absorption have a negative impact on flow. Measure lead time, space, effort, defects and missed deliveries instead.
performance measures must not be counter-productive to flow
SUPPORT_MUST_RESPOND_WITHIN_TAKT Support functions must respond within takt supportResponseTime > taktTime warn discipline
If your support organisation cannot respond to operator problems within takt time, the organisation is not ready for production to operate at takt.
support functions must respond within takt
OVERPRODUCTION_MUST_BE_ATTACKED A future state must attack overproduction isFutureState == 1 && overproductionCountermeasureCount == 0 error design
Constant efforts to eliminate overproduction are what create great flow. This future state contains no countermeasure against it.
a future state must attack overproduction
MANNING_BELOW_MINIMUM Manning is below the minimum the schedule requires operatorCount > 0 && minimumOperators > 0 && operatorCount < minimumOperators error design
Total work content divided by takt requires more operators than the map staffs. No assignment of the work to this few people can meet the schedule — the shortfall is in the arithmetic, not in the balance.
manning is below the minimum the schedule requires
EFFECTIVE_CYCLE_BELOW_AVERAGE_OPERATOR_TIME Effective cycle time cannot be below the average operator time cellEffectiveBelowAverage > 0 error convention
A cell cycles faster than the work content assigned to each of its operators, which cannot happen: the effective cycle time is the largest of the operator times, so it never falls below their mean. Either the cell needs more operators or its work content is overstated.
effective cycle time cannot be below the average operator time
BALANCE_DELAY_EXCESSIVE Balance delay is high enough to rebalance before adding people balanceableCellCount > 0 && balanceDelay > 0.2 warn improvement
A fifth or more of a cell's paid operator time is standing idle because the work is unevenly assigned. Redistribute work elements towards the average operator time before adding operators or equipment — the capacity is already bought.
balance delay is high enough to rebalance before adding people
STATION_OVER_TAKT_NEEDS_PARALLEL A single task longer than takt needs parallel stations stationsOverTaktNeedingParallel > 0 error design
A station whose work is one indivisible task longer than takt sets the pace of the whole line on its own, and no rebalancing can change that. Run the station in parallel so alternate units pass through each copy.
a single task longer than takt needs parallel stations
PARALLEL_STATIONS_MUST_DIVIDE_THE_WORK Parallel stations must be whole and sufficient parallelStationArithmeticError > 0 error convention
Parallel stations come in whole copies, and enough of them to bring the station under takt: k copies of a task of length t deliver a unit every t/k, so k must be at least the ratio of the two.
parallel stations must be whole and sufficient
OPERATORS_AT_LEAST_STATIONS A line has at least as many operators as stations stationCount > 0 && producingOperatorCount > 0 && stationCount > producingOperatorCount warn convention
The map has more producing stations than operators to staff them. A station may be worked by two people, but not by none.
a line has at least as many operators as stations
WORK_ELEMENTS_TOO_COARSE_TO_BALANCE Work elements are too coarse to balance against workElementCount > 0 && minimumOperators > 1 && workElementCount < minimumOperators * 2 info improvement
There are fewer work elements than operators can be balanced across. Break the tasks down further — the balance can only ever be as even as the largest element allows.
work elements are too coarse to balance against
PRODUCT_FAMILY_SIMILARITY_TOO_LOW The variants on this map share too little work to be one family similarityIndex > 0 && similarityIndex < 0.3 warn discipline
These variants share less than a third of their work content, so balancing one line for all of them wastes most of it. Either map them separately or confirm they really pass through the same processes.
the variants on this map share too little work to be one family
STREAM_YIELD_LOSES_MORE_THAN_A_TWENTIETH Yield across the stream loses more than one part in twenty statedScrapRateCount > 1 && streamFirstTimeThrough < 0.95 warn improvement
More than one part in twenty fails somewhere across the stream, and every one of them was paid for at each process it passed. Attack the losing process at its own station rather than sorting at the end — a defect caught where it is made costs one process, a defect found at inspection costs all of them.
yield across the stream loses more than one part in twenty
CAPACITY_IGNORES_EFFECTIVENESS_LOSSES Capacity looks adequate on uptime but not on effectiveness isFutureState == 0 && (statedPerformanceFactorCount > 0 || statedScrapRateCount > 0) && minProcessCapacityRatio >= 1 && minEffectiveCapacityRatio < 0.98 warn improvement
On uptime alone this stream covers its demand; once the stated speed and quality losses are applied it does not. Capacity has to be read on good parts out, not running time — the difference is being paid in overtime or in a shortfall someone absorbs, and it will not appear in any single data box on this map.
capacity looks adequate on uptime but not on effectiveness
FUTURE_CAPACITY_SHORT_WITHOUT_COUNTERMEASURE Future state is short on effective capacity with nothing named to close it isFutureState == 1 && (statedPerformanceFactorCount > 0 || statedScrapRateCount > 0) && minEffectiveCapacityRatio < 0.98 && capacityCountermeasureCount == 0 error design
A process in this future state cannot cover demand once its own stated speed and quality losses are applied, and nothing on the map says what closes the gap. A future state is a commitment to run this way, so the shortfall has to be answered where it is drawn: move work content off the short process, add the station, or recover the effectiveness losses and show the figure you are recovering to. Left unnamed it becomes overtime discovered in the third week.
future state is short on effective capacity with nothing named to close it
COUPLED_PROCESS_STOPS_TOO_OFTEN_TO_COUPLE A process inside a cell stops too often for any boundary to hold flowMembersBelowSensibleAvailability > 0 error design
A process drawn inside a continuous-flow cell is available less than half the time. Its load may be light enough that the capacity arithmetic clears it, but that arithmetic is answering the wrong question: with no stock between the processes, everything after it stops for the whole of every repair. Take it out of the cell behind a FIFO lane, or raise its availability before the boundary is designed at all.
a process inside a cell stops too often for any boundary to hold
COUPLING_MULTIPLIES_DOWNTIME Cell availability is the product of its members, not their average isFutureState == 1 && flowRangesBelowCombinedRequirement > 0 error design
A cell on this map cannot hold its pace even though every process in it passes on its own. Coupling multiplies availability rather than averaging it — with no stock between them, a stoppage anywhere stops everything, so three processes at 90% run as one at 73%. Either raise the members above what the cell as a whole requires, or split the cell at its weakest boundary and let a FIFO lane absorb the stoppage.
cell availability is the product of its members, not their average
PACEMAKER_MUST_NOT_BE_A_CONTROL_POINT Production is scheduled to a station that only confirms the product isFutureState == 1 && pacemakerIsControlPoint == 1 error design
The scheduling point sits on a station that verifies or moves the product rather than one that gives it its form. Everything that actually transforms the product is upstream of it, so those processes will each need a schedule of their own and the stream ends up with several paces instead of one. Put the pacemaker at the last process that confers form, and let the checks and the packing flow FIFO on its pace.
production is scheduled to a station that only confirms the product
PACEMAKER_CHOSEN_WITHOUT_ALTERNATIVES Pacemaker chosen without saying what it was chosen over isFutureState == 1 && pacemakerDecisionContested == 1 && pacemakerAlternativeCount == 0 warn validation
The pacemaker was close to being placed elsewhere, yet the map shows only the winner. When the margin is thin the runner-up matters: the team knows things the arithmetic does not, and this is the decision they are best placed to overturn. Publish the candidates, the criteria they were scored against, and the margin between the first two.
pacemaker chosen without saying what it was chosen over
MONUMENT_ASSERTED_WITHOUT_EVIDENCE A process is called a monument without evidence for it isFutureState == 1 && monumentsClaimedWithoutEvidence > 0 warn validation
A process is treated as a monument without anything on the map establishing it as one. The label is doing real work here — it excuses the batch and the inventory on both sides — so it needs grounds: a minimum load the equipment cannot go below, a physical or thermal constraint, or another family with a claim on the same machine. A long changeover on its own is an improvement opportunity, not a monument.
a process is called a monument without evidence for it
BATCH_INTERVAL_EXCEEDS_ITS_BUFFER A batch process runs less often than the buffer after it covers isFutureState == 1 && batchIntervalUncovered > 0 error design
A batch process runs on an interval longer than the stock placed after it can cover. The buffer has to hold the demand between loads *and* the pieces the next process would consume while a failure mid-load was being recovered; sized for the interval alone it empties the first time the load is late. Either raise the buffer to cover interval plus recovery, or run the process more often on a smaller load.
a batch process runs less often than the buffer after it covers
KAIZEN_WITHOUT_A_TARGET_CONDITION Improvement work published without a target condition isFutureState == 1 && kaizenBurstCount > 0 && planItemsWithoutTargetCondition > 0 warn design
Improvement work on this map names the process and the theme but not the condition it is meant to create. Without a target condition there is no point at which the work is finished, and the boundary that depends on it stays unsecured while the item is reported as in progress. State where the measure stands today, where it has to reach for the design to hold, and how anyone would see it got there.
improvement work published without a target condition
FLOW_COUPLED_WITHOUT_STATED_REASONING Processes coupled into flow with no assessment behind it isFutureState == 1 && coupledBoundaryCount > 0 && coupledBoundariesUnexplained > 0 warn validation
Processes have been coupled into continuous flow without the map saying what made that possible. Coupling merges the downtime, changeovers and yield losses of both into a single system, so the assessment behind it is the part the team needs: which factors were tested, which one was binding, and what has to stay true for the coupling to hold.
processes coupled into flow with no assessment behind it
TRAVEL_DISTANCE_WITH_ISOLATED_ISLANDS Material travels a long way between isolated islands travelDistancePerProcess > 20 && isolatedIslandCount >= 2 warn improvement
Parts travel a long way between processes that are pushing to each other. Distance is a symptom of the layout, not of the work: bringing the steps into flow order typically removes most of it without changing a single cycle time.
material travels a long way between isolated islands
PER_PIECE_RATE_FLATTERS_A_BATCH_PROCESS A batch process looks like spare capacity but is not batchesFlatteredByPerPieceRate > 0 info improvement
A process on this map transforms a whole charge at once, and its equivalent rate per piece sits under takt — which makes it look like spare capacity. It is not: it produces nothing for a whole batch cycle and then a batch at once. The equivalent rate is a batch cycle divided by the pieces the batch yields, and it describes no moment of the operation, so read the batch figures beside it before drawing any conclusion about headroom here.
a batch process looks like spare capacity but is not
BATCH_PROCESS_TYPED_FROM_ITS_NAME A process is treated as a batch on the strength of its name batchTypedByNameOnly > 0 warn validation
A process here has been treated as a batch operation because of what it is called, with no batch size, working volume or residence time recorded anywhere on the box. That may well be right, and nothing downstream of it can be sized until it is confirmed: the charge decides the buffer, the interval and whether the process can be coupled at all.
a process is treated as a batch on the strength of its name
BATCH_PROCESS_WITHOUT_ITS_PHYSICS A batch process is drawn without the figures that govern it batchProcessesWithoutBatchPhysics > 0 warn validation
A batch process on this map is missing figures its own arithmetic needs — batch size, working volume, residence time, cleaning time or yield. Capacity, the interval it forces downstream and the buffer that covers it all follow from those, so until they are recorded the design around this process rests on a per-piece average rather than on the operation.
a batch process is drawn without the figures that govern it
BATCH_PROCESS_COUPLED_INTO_CONTINUOUS_FLOW A batch process has been coupled into a continuous-flow cell isFutureState == 1 && batchProcessesCoupledIntoFlow > 0 error design
A process that transforms a whole charge has been placed inside a continuous-flow cell. There is nothing for the next operation to pick up until the charge is finished, so the cell stands idle for a batch cycle and then receives a batch at once — which is not flow, whatever the layout looks like. A moving-conveyor process can join a cell because a piece can be set down and one picked up within a takt; a vessel cannot. Decouple it with a FIFO lane or a hold tank and pace the cell from somewhere else.
a batch process has been coupled into a continuous-flow cell
SUSPECTED_BATCH_PROCESS_COUPLED_INTO_FLOW A cell contains a process that may transform a whole charge isFutureState == 1 && suspectedBatchProcessesCoupledIntoFlow > 0 warn validation
A continuous-flow cell here contains a process whose name suggests it transforms a whole charge, and nothing on the box settles the question. If it does, the cell will stand idle for a batch cycle and then receive a batch at once, so the coupling fails rather than underperforms. Establish whether pieces pass through one at a time — a moving conveyor through an oven does and belongs in the cell; a vessel does not.
a cell contains a process that may transform a whole charge
EPE_NORMALISED_RATHER_THAN_DERIVED Every-part-every-day has been written down rather than reached isFutureState == 1 && campaignEpeNormalisedToDaily > 0 error design
A data box on this map claims an every-part-every-day interval that the equipment cannot hold. Cycling it through the grade families that share it, with the clean-down each transition costs, takes longer than the interval claimed. Every part every day is the right goal and it applies to process industries too, but it is reached by cutting the clean-down, not by writing the target into the box: state the interval the equipment can hold today, and the reduction that would close the gap.
every-part-every-day has been written down rather than reached
CAMPAIGN_INTERVAL_NOT_FEASIBLE The stated interval is shorter than a full campaign takes isFutureState == 1 && campaignIntervalInfeasibleCount > 0 error design
The interval stated for a shared piece of equipment is shorter than the time it takes to run one campaign of every grade that uses it. The interval is the sum of the processing time for each grade at its batch size, plus the clean-down between them, over the working time available — so a shorter figure is not a stretch target, it is arithmetic that does not close, and any supermarket sized from it will run dry.
the stated interval is shorter than a full campaign takes
CLEAN_DOWN_BETWEEN_GRADES_UNACCOUNTED Cleaning between grades is not recorded isProcessIndustryStream == 1 && batchProcessTypeCount > 0 && cleanDownUnaccountedCount > 0 warn validation
A batch process here has no cleaning time recorded. For a vessel or a mill the clean-down is the changeover, and it is sequence-dependent: running light to dark needs a flush, running dark to light needs the vessel stripped. Without it the cost of a grade change is unknown, so the campaign length, the sequence and the interval are all unfounded.
cleaning between grades is not recorded
BATCH_CAPACITY_SHORT_ON_ITS_OWN_PHYSICS A batch process cannot cover demand once its physics are applied batchPhysicsCapacityShort > 0 error design
Once the charge, the residence time, the yield and the availability of a batch process here are put together, it does not cover the demand placed on it. This is not a boundary problem and no buffer solves it: the equipment cannot make the volume, so either the batch has to grow, the cycle has to shorten, or the requirement has to be met somewhere else.
a batch process cannot cover demand once its physics are applied
BUFFER_HOLDS_LESS_THAN_THE_CHARGE_THAT_FILLS_IT A buffer holds less than one charge of the process that refills it buffersSmallerThanOneCharge > 0 error design
A buffer on this map holds fewer pieces than the process filling it delivers in one charge. That process discharges a whole batch or nothing, so the first replenishment overflows the location and the pull signal in front of it asks for a fraction of a batch that cannot be run. Size the location to a whole number of charges, or cut the charge until the size you want is a multiple of it.
a buffer holds less than one charge of the process that refills it
BATCH_HELD_FOR_RELEASE_WITHOUT_THE_HOLD_STATED A batch waits for laboratory release and the wait is not recorded batchesWithLabHoldUnquantified > 0 warn validation
A batch process on this map is released by laboratory test, and how long the test takes is not recorded. That wait is lead time and it is stock: the charge is made, it is in the building, and nobody may ship it. Until the hold is stated the lead time is understated by however long it runs, and any supermarket fed by this process is short by the quantity sitting under test.
a batch waits for laboratory release and the wait is not recorded
BATCH_RELEASE_POLICY_NOT_ESTABLISHED How a batch becomes shippable stock is not stated isProcessIndustryStream == 1 && batchesWithoutReleasePolicy > 0 warn validation
A batch process here does not say how its output becomes shippable stock. If it releases on a parameter read off the vessel, the charge is available at discharge; if it releases on a laboratory certificate, it is available whenever the laboratory finishes. Those are different streams with different lead times and different buffers, and the map currently describes neither.
how a batch becomes shippable stock is not stated
PROCESS_TYPES_NOT_ESTABLISHED_ON_A_PROCESS_STREAM Process types are assumed on a stream that is mostly batch isProcessIndustryStream == 1 && processTypeUnclassifiedCount > 1 warn validation
Most of the transformations on this stream are charges rather than pieces, and the process types have been read off the process names rather than stated. Which arithmetic governs each operation — per piece, per batch or per unit of rate — decides the capacity, the boundaries and every buffer size on the map, so it is the first thing to confirm on the floor rather than a detail to settle later.
process types are assumed on a stream that is mostly batch
CELL_CANNOT_MAKE_TAKT_AS_DESIGNED A proposed cell cannot make the volume as drawn cellsThatCannotMakeTakt > 0 error design
A cell on this map is drawn with more operator work content than its operators can perform inside the takt time, and adding the operator the remainder rule would add does not close the gap. No rebalancing fixes this: the work content itself exceeds the time available. Either work comes out of the cell or the cell does not make the volume.
a proposed cell cannot make the volume as drawn
CELL_STAFFED_AGAINST_ITS_OWN_WORK_CONTENT A cell's operator count does not follow from its work content cellsStaffedAgainstTheRule > 0 error design
A cell on this map is staffed at a number that does not follow from its work content. Operators are total operator work content divided by takt time, and the remainder decides whether to add one: below 0.3 do not, between 0.3 and 0.5 do not yet, above 0.5 add one and keep working to remove the need. Where the count is higher than that, the usual reason is that machine time has been charged to the operator — an operator who has loaded a machine and started it is free while it cycles, and staffing for the wait builds the waiting in.
a cell's operator count does not follow from its work content
MIXED_CELL_REDUCED_TO_ONE_CATEGORY A composite cell has lost the operations inside it mixedCellsWithoutInternalSemantics > 0 error design
A cell on this map contains operations of more than one kind but is presented as a single category, or does not record what it contains at all. A cell that machines, washes, inspects and packs is a mixed production cell, and each operation has to keep its own type: a defect found in the cell is traced back to the operation that made it, and a cell reduced to one label cannot be traced through.
a composite cell has lost the operations inside it
FIFO_LANE_SHORTER_THAN_THE_RECOVERY_IT_COVERS A FIFO lane is too short to cover one stoppage upstream fifoLanesUnderOneRecovery > 0 error design
A FIFO lane on this map holds less than one mean recovery of the process feeding it. That is the one thing a lane is for: when the process upstream stops, the lane is what keeps the process downstream running until it comes back. Sized below the recovery it empties first, and the boundary is decoupled on the drawing and coupled in the building.
a fifo lane is too short to cover one stoppage upstream
FIFO_LANE_CANNOT_BOTH_PROTECT_AND_TURN_OVER No lane quantity satisfies both the recovery and the consumption fifoLanesInfeasible > 0 error design
At a boundary on this map, covering one recovery of the feeding process needs more pieces than the process downstream consumes in a whole replenishment interval. No lane maximum satisfies both — large enough to protect the boundary is larger than the boundary turns over. Either the recovery comes down or this boundary needs a supermarket rather than a lane.
no lane quantity satisfies both the recovery and the consumption
EVERY_PART_EVERY_INTERVAL_NOT_SUPPORTED_BY_SETUP_CAPACITY A claimed interval the changeover time cannot deliver epeIntervalsUnsupportedByChangeover > 0 error design
A process on this map claims to run every part more often than its changeover time allows. The time left for changeovers is the available time less the time to run the requirement, and that divided by the changeover time is how many changeovers fit in a day. Where the claimed interval needs more changeovers than fit, the interval is a target rather than a plan, and it needs the setup reduction beside it that would make it true.
a claimed interval the changeover time cannot deliver
PROCESS_CANNOT_COVER_DEMAND_AFTER_ITS_LOSSES Effective capacity below demand capacityShortfallCount > 0 error design
A process on this map cannot make the daily volume once its own losses are taken out. A cycle time inside takt is not capacity: capacity is the available time divided by the cycle time, times uptime, less the time spent changing over. No buffer fixes a shortfall here — a buffer only delays the day the shortfall becomes visible, and it is refilled by the process that cannot fill it.
effective capacity below demand
MACHINE_CYCLE_TOO_CLOSE_TO_TAKT_FOR_A_CELL A machine in a cell cycles above 80% of takt cellsWithMachineOverTakt > 0 warn improvement
A machine inside a proposed cell has an effective cycle time above 80% of takt, counting its own cycle, the load and unload it cannot cycle during, and its changeover amortised over the run. Operators will come back round to it before it has finished and wait — which is the waste the cell was built to remove, reintroduced by the equipment. Either that machine gets faster or the cell needs a buffer at it.
a machine in a cell cycles above 80% of takt
CELL_DESIGN_PROVISIONAL_ON_UNOBSERVED_FACTS A cell is designed on facts nobody has observed yet cellsProvisional > 0 warn validation
A cell on this map is designed without an observed walking time, because the physical layout does not exist yet. That is the right way round — walking is left out while the cell is on paper, precisely because the layout is unknown — but it means the cycle time shown is the paper figure. Lay the cell out, walk it, and time it before this design becomes an instruction. In the worked example in the book the walk came to six seconds on 88 seconds of content, and it was enough to change the staffing conversation.
a cell is designed on facts nobody has observed yet
BOUNDARY_EXPOSED_BEYOND_WHAT_IT_HOLDS A stoppage reaches past the buffer meant to absorb it boundariesExposedBeyondRecovery > 0 warn improvement
At a boundary on this map, a mean stoppage upstream costs more pieces than the buffer downstream absorbs, so part of every stoppage reaches the next process. Whether that matters depends on the spare capacity available to make it back: with enough, the exposure is real and short. The figures are on the map so the choice between a longer buffer and a faster repair can be argued rather than assumed.
a stoppage reaches past the buffer meant to absorb it
RECOVERY_NOT_MEASURED_AT_A_DECOUPLED_BOUNDARY Buffers sized without a recorded recovery fifoLanesWithoutRecoveryEvidence > 0 warn validation
A FIFO lane on this map is sized without a recorded mean time to recover at the process feeding it. Its quantity is therefore a fraction of a day's demand rather than a derivation — a policy, not a design, and nothing about the boundary would change it. Uptime says how often a process stops; only the recovery says how long for, and only the second sizes a lane.
buffers sized without a recorded recovery
CAPACITY_NEVER_CONFIRMED_AGAINST_DEMONSTRATED_OUTPUT The capacity chain has not been checked against the floor capacityUndemonstratedCount > 2 warn validation
The capacity figures on this map are derived from the data boxes and have not been checked against what the processes actually produced. Nominal capacity, effective capacity and every buffer sized from them are arithmetic on recorded cycle times and uptimes — all internally consistent, and all untested. A week of counted output at the tightest processes would price every assumption above it at once.
the capacity chain has not been checked against the floor
SHARED_RESOURCE_WITH_UNQUANTIFIED_OTHER_DEMAND A shared machine whose other work is not quantified epeSharedResourceUnquantified > 0 warn validation
A process on this map is recorded as shared with other product families, but how much of its time those families take is not. The interval at which this stream can withdraw from it depends on everything the machine has to make, not only on this part, so the interval shown is the shortest it could be rather than the one it will be. What is needed is the demand by family on that resource.
a shared machine whose other work is not quantified
ROLLED_CA_LOSES_A_FIFTH Information loops back on more than one item in five statedCompleteAccurateCount > 1 && rolledCompleteAccurate < 0.8 warn improvement
More than one item in five has to go back for missing or wrong information somewhere on the stream. That loop-back is lead time nobody's cycle time shows. Fix the incomplete hand-off at the process that creates it — a downstream checker is judgment inspection by another name.
information loops back on more than one item in five
WALK_EATS_THE_CYCLE Walking is a quarter of the operator cycle statedWalkCount > 0 && maxWalkShareOfCycle > 0.25 warn improvement
The operator spends more than a quarter of the cycle walking. That is a layout number, not a work-content number: a U-cell or a shorter pitch between machines gives the time back without touching the job.
walking is a quarter of the operator cycle
CYCLE_TIME_ITS_ELEMENTS_CANNOT_ACCOUNT_FOR A cycle time its own work elements cannot account for stationsWithUnaccountedCycle > 0 error discipline
At one or more stations the machine's running time and the operator's walking together account for less than a tenth of the cycle time recorded on the box. Work content is measured element by element; a station total that its own elements cannot reach was estimated rather than timed, and the usual cause is a figure written in minutes into a field that reads seconds. Every other number on this map has been derived from it.
a cycle time its own work elements cannot account for
CELL_WITHOUT_STANDARD_WIP A multi-station cell has no standard WIP cellsWithoutStandardWip > 0 warn discipline
A cell with several stations and no stated standard WIP will fill with whatever the operators feel safe holding. One-piece flow is a WIP rule, not a layout drawing.
a multi-station cell has no standard wip
CHANGEOVER_LOAD_EATS_THE_SHIFT Changeovers consume a fifth of the shift maxChangeoverLoadRatio > 0.2 warn improvement
This process spends more than a fifth of the shift changing over. Separate internal from external setup and convert what you can — the EPE and the supermarket both shrink with the changeover, not with a larger batch.
changeovers consume a fifth of the shift
SCRAP_WITHOUT_SOURCE_INSPECTION Scrap is stated and no poka-yoke is statedScrapRateCount > 0 && totalPokaYokeCount == 0 && streamFirstTimeThrough < 0.99 warn improvement
The stream loses parts and names no source-inspection device. Sorting at the end is judgment inspection: it finds the defect after the cost is paid. A poka-yoke at the process that makes the defect is the only inspection that can reach zero.
scrap is stated and no poka-yoke is
SETUP_NOT_SEPARATED The whole setup still stops the machine statedSetupSplitCount > 0 && maxInternalSetupShare > 0.95 && maxInternalSetupSeconds > 600 warn improvement
Every minute of this setup is internal: nothing has been moved off-line. That is SMED's preliminary stage, and stages 1 and 2 — separate internal from external, then convert — routinely take half the stopped time out before anybody buys a clamp.
the whole setup still stops the machine
INTERNAL_SETUP_ABOVE_SINGLE_MINUTES Internal setup is longer than ten minutes statedSetupSplitCount > 0 && maxInternalSetupSeconds > 600 info improvement
Internal setup runs past ten minutes, so the changeover is outside the single-minute range SMED aims at. Functional clamps, an intermediate jig and standard die heights are the three that usually get it there, in that order.
internal setup is longer than ten minutes
CHANGEOVER_COUNTS_EXTERNAL_WORK The changeover figure includes work that does not stop the machine changeoverOverstatedCount > 0 warn convention
The stated changeover is longer than the internal setup, which means it counts staging or preparation the machine is not waiting for. Batch size, EPE and capacity all follow the internal figure; using the total overstates the loss and hides the work that is already external.
the changeover figure includes work that does not stop the machine
OPERATOR_WAITS_ON_THE_MACHINE The operator stands and watches an automatic cycle operatorWaitsOnMachineCount > 0 warn improvement
A machine here runs longer unattended than its operator takes to load and unload it, and the operator is tied to one machine anyway. That is the case Shingo answers with multi-process handling: give the operator the next process to walk to, and auto-eject so the part comes off without a hand.
the operator stands and watches an automatic cycle
WAITING_SPREAD_ACROSS_THE_CELL Idle time is spread thinly instead of concentrated evenlyDistributedWaitingCount > 2 warn improvement
Three or more operations sit comfortably below takt, each carrying a little waiting. Rother and Harris are blunt about this: spread evenly, the waste is permanent and invisible. Load all but one operator to nearly a full takt and leave the slack on one, where it can be seen and removed.
idle time is spread thinly instead of concentrated
UNSTABLE_DEMAND_WITHOUT_BUFFER Demand varies and nothing absorbs the variation demandUnstable && !hasFinishedGoodsBuffer && safetyStockDays == 0 warn improvement
Demand is not stable, the stream builds straight to shipping, and no buffer is named. Something absorbs that variation — overtime, expediting, or a late shipment. Tapping and Shuker's answer is an explicit buffer resource, sized and available immediately, rather than an implicit one paid for in expediting.
demand varies and nothing absorbs the variation