rule 150
| Key | Name | Detail | Aliases |
|---|---|---|---|
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 |