Why Continuous Improvement Needs Better Data

0:00Real quick, does one of these sound like you, because if you say yes to anyone, there's something you can do right now. So here we go. Gaining weight, no matter how disciplined you are, craving something sweet after every meal. Feeling hungry again an hour after you eat. These are all signs your body isn't producing enough GLP1. The hormone that suppresses hunger, slows down digestion and supports weight loss. But fortunately, you can boost your natural GLP1 production. And one of the easiest ways to do that is with Bioma GLP1 booster. With every serving, you get science-backed and third-party tested ingredients. All working together to help your body produce more of this weight loss hormone on its own. Simply take two tiny Bioma GLP1 booster capsules each morning before breakfast. This way you can finally quiet the food noise, feel full with less food, and enjoy smoother weight management when following a healthy lifestyle. So again, if you said yes to anyone, here's what to do right now. Head to Bioma.Health slash GLP1 and use code podcast for 15% off your first order. That's Bioma.Health slash GLP1 code podcast.

1:03Real quick, if any of these sound familiar, there's something you can do right now. Craving something sweet after every meal, hungry again an hour after you eat. Weight won't budge no matter how disciplined you are. These are all signs that your body isn't producing enough GLP1. The hormone that keeps you full and supports weight loss. The good news? Bioma GLP1 booster helps you increase its natural production. So you can quiet the food noise and enjoy smoother weight management when following a healthy lifestyle. Head to Bioma.Health slash GLP1 and use code podcast to get 15% off. A chis and event can feel like real progress when you pull people off the line, gather them around a flip chart, mark problems on a process map, and build an action list before the day ends. But a few weeks later, the same loss shows up on another shift. Maybe the team reduced the change of a delay, clear the material rack, change the handoff, or add it to checklist. The local fix looked sensible at the time, but could it hold up under a different product mix, a different crew or different production sequence? Nobody could tell. That's where continuous improvement work loses momentum. Not because people don't care, they usually care a great deal,

2:05but because the workshop drifts away from daily production facts. The evidence lives in separate systems. Your MES records, what that order did, your ERP holds the plan and customer commitment, machine signals log stops, speed, alarms, and cycles, and operators know what actually shifted during the shift often before any system picks it up. When those sources stay disconnected, the chis and event becomes a one-time burst of attention instead of a learning loop. So let's walk through a recurring production problem, because this is where the gap becomes easy to see, a familiar factory problem. Picture a production line that keeps missing planned output. Nothing dramatic happens. No single machine crash stops the plan for a day. Instead, the line slips a little during changeovers, waits for material, then loses time after restart, because the first units need adjustment or inspection. Late order start to build, change over time seems to rise, and output looks unstable from one shift to the next. At the daily meeting, someone brings yesterday's spreadsheet. It shows total output, scrap, downtime, and maybe an OEE number, overall equipment effectiveness. The supervisor adds what they remember from the shift,

3:07maintenance adds a note about a recurring sensor alarm, and the planner points out that a priority order moved into the schedule late in the day. Everyone sees part of the problem, but nobody sees the whole production story. The operators often know more than the report captures. A certain toolset arrives late from cleaning. One product family takes longer to stabilize after a changeover, and a material role from one supplier behaves differently even when the material code looks the same. That knowledge matters, yet it often lives in shift handovers, informal notes, and conversations near the line. Now, imagine an improvement team picks change over time as the problem. That choice sounds reasonable. The spreadsheet shows a rise in lost time, and the team can see people walking farther than they should to find tools and parts. They run a kaisen session, stage tools closer to the line, label locations, and add a simple setup checklist. The next few changes look better, so the team closes the action. But production doesn't run under laboratory conditions. A week later, a different crew runs a different sequence of products. The new tool staging helps, but the line still loses time, because the prior order leaves adhesive residue in a component,

4:09the first few units after restart fail inspection, and operators slow the machine to adjust settings. The average changeover time may even improve, but delivery performance does not. That's because the team improved one visible step without checking the operating context around it. The loss moved downstream from setup time into restart time, quality checks, and waiting for a disposition decision. Improvement work tends to target where the pain shows up, but the real constraint is usually somewhere else in the flow. You need to ask which product ran before the difficult changeover. Which product came next? Did the same material batch appear in the slow restart? Did the delay happen on every shift? Or mainly when a certain crew ran the line? Did the machine alarm occur before the quality issue or after it? A spreadsheet with one number per day can't answer that, and a workshop memory can't answer it reliably across weeks and shifts either. People remember the bad event, but they rarely remember every normal event that gives the bad event its meaning. This doesn't mean the daily meeting is useless. Quite the opposite. A short meeting near the work can catch problems early, and operator experience often points toward the right place to investigate,

5:10but experience needs away to connect with production evidence. The team needs to trace an event through the order, the process step, the machine state, the material, the quality result, and the shift. Otherwise, every discussion starts with a partial view and ends with an action that only works under one set of conditions. There's also a planning effect teams often miss. When changeovers run long, the planner may re-sequence orders creating more material moves, more cleaning work, or more complex product transitions later in the day. A local loss starts changing the plan, and the changed plan creates new local losses. Soon enough, people argue about whether production, planning, maintenance, or quality cause the problem. Usually, each group has evidence, but it's evidence from a different system in a different time boundary. This is why activity and learning aren't the same thing. You can hold workshops, fill action trackers, and close tasks, while learning very little about why the line behaves the way it does. Real learning means a team can test a change against operating facts, see whether it holds, and understand when it doesn't. Lean is a learning system. I watch Lean get reduced to a collection of tools all the time.

6:10A 5S event, a value stream map, a kyson board, a visual status meeting, those are useful, but they don't define the system. Those tools help, sure, but Lean itself is really a way of learning how work moves through a system, where work waits, where defects sneak in, and where one local decision ripples trouble somewhere downstream. That learning has to stay close to the work. Otherwise, the team starts improving the process they imagine instead of the process people actually run during a busy shift with late material, altered schedules, worn tools, and all the small exceptions that never fit neatly into a standard work document. Here's the thing about value stream mapping. Most teams treat it like a wall exercise. You draw it once, snap a photo, and don't touch it until the next improvement project comes around. But a value stream map should act as a shared view of flow, giving production, quality, maintenance, planning, and logistics a common way to talk about the path from demand to delivery. Where does material wait? When does information arrive too late? Which handoff causes rework? Where does the flow stop even though no one machine appears broken?

7:11That map doesn't need to capture every sensor tag or system field. It just needs to make the work visible enough so people can start asking better questions. A useful map can show that a long lead time isn't from cycle time, it's from a queue before inspection, a release rule in planning, or a quality hold that the production team only hears about after the next operation needs the batch. That shifts the conversation from which department owns this delay, to what condition creates this weight, and what information would let us prevent it. Kaisen fits right into that. Small practical improvement close to the work, where the people running the process can test an idea and learn from the result. You don't need a big program office for this, but you do need discipline. A team sees a condition, forms a hypothesis about why it happens, changes something within a safe and agreed boundary, and then checks the result against the condition they expected to improve. That's the PDCA cycle. Plan do check act. Plan means more than picking a target. The team defines the problem, the current condition, and the expected effect of a change. Say a line loses time after certain product transitions. The plan might state that pre-staging a specific cleaning kit should reduce the delay

8:15before stable production resumes. Do means trying that change in real work, not in a conference room or a slide deck, but on the line with the known product sequence under conditions the team records well enough to learn from. Check is where many improvement efforts go weak. The team needs to compare the expected result with what actually happened, including effects that might show up later in the process. Did the restart improve, did quality hold? Did the new method add work somewhere else? Did it work for the next crew, not just the one that designed it? Then comes act. If the evidence supports the change, the team builds it into standard work, training, planning rules, or maintenance routines. If not, they adapt or stop it. Stopping a weak countermeasure isn't failure. It's preventing a weak habit from becoming standard. PDCA gives lean its memory. Without that loop, improvement work becomes a set of good intentions attached to local observations. With it, each test adds to what the plant knows about its own process. Data supports that learning, but it doesn't replace GEMBA, the place where work happens. You still need to stand near the process, ask operators what they saw, hear why they bypassed a step and notice the gap between written work instructions and real work.

9:18A data record may show a 10-minute stop, but it won't always tell you that an operator paused because a part felt wrong. The normal material route was blocked, or a prior shift left the station in an unsafe state. The people at the line supply, meaning that systems can't infer on their own, at the same time, observation alone has limits. People see one shift, one event, one version of a problem. Connected operational data helps the team check whether that observation repeats across orders, machines, products, and time. So the strongest improvement loop combines both, GEMBA tells you where to look and what questions matter. Operational data lets you test those questions across the real pattern of production. Standard work carries the learning forward, so the next shift doesn't start from zero. That sounds straightforward, yet the loop often breaks right after the workshop ends, when the team returns to daily production, and the evidence needed for the check step sits scattered across systems, reports, and personal memory. Why improvement programs stall? Most improvement programs follow a familiar path. Someone spots a recurring loss, a manager sponsors a workshop,

10:18the team spends a few days mapping the work, and then an action tracker appears with owners and dates. For a short time, attention is high. People ask questions, move things around, test new routines, and report progress. Then normal production pressure returns, the next urgent order enters the plan, and the tracker slowly becomes another file, nobody opens, unless someone asks for a status update. The work didn't fail because the team lacked effort. It lost its place in the daily operating rhythm. A shift supervisor still has to decide what to run next, a planner still has to respond when an order slips, and maintenance still has to choose which fault deserves attention first. Those decisions happen every day, often under time pressure, while the improvement actions sit somewhere separate, owned by a project team, or reviewed only in a monthly meeting. That separation creates a problem. The kaisen action becomes an extra task instead of part of how the process runs. Think about a countermeasure that changes the setup routine. The team agrees on a new sequence, writes it into the action list, and tells the next crew. But if the shift meeting doesn't check whether that sequence was used, under which product conditions it worked,

11:18and where it broke down, the change has no operating feedback. People then fall back to the old method when the line gets busy, not because they reject improvement, but because they can't see a clear link between the new method and the condition they need to control. Many programs also collect measures at the wrong moments, a baseline before the workshop, maybe another measurement a few weeks after, but between those two points, the team has very little evidence about what happened during the change. That makes cause and effect hard to judge. Maybe output improved because the new routine reduced setup work, or maybe the production plan happened to contain an easier mix of orders. Perhaps maintenance replaced a worn component during the same period, or quality released material faster. A before and after comparison can start a useful conversation, but it can't carry the whole argument. Real quick, if any of these sound familiar, there's something you can do right now. Craving something sweet after every meal, hungry again an hour after you eat, weight won't budge, no matter how disciplined you are. These are all signs that your body isn't producing enough GLP1, the hormone that keeps you full and supports weight loss. The good news, Bioma GLP1 booster helps you increase its natural production,

12:22so you can quiet the food noise and enjoy smoother weight management when following a healthy lifestyle. Head to bioma.health slash GLP1 and use code podcast to get 15% off. Real quick does one of these sound like you, because if you say yes to anyone, there's something you can do right now. So here we go. Gaining weight, no matter how disciplined you are, craving something sweet after every meal. Feeling hungry again an hour after you eat. These are all signs your body isn't producing enough GLP1. The hormone that suppresses hunger, slows down digestion and supports weight loss, but fortunately you can boost your natural GLP1 production. And one of the easiest ways to do that is with Bioma GLP1 booster. With every serving, you get science-backed and third-party tested ingredients, all working together to help your body produce more of this weight loss hormone on its own. Simply take two tiny Bioma GLP1 booster capsules each morning before breakfast. This way you can finally quiet the food noise, feel full with less food and enjoy smoother weight management when following a healthy lifestyle.

13:22So again, if you said yes to anyone, here's what to do right now. Head to bioma.health slash GLP1 and use code podcast for 15% off your first order. That's bioma.health slash GLP1 code podcast. Real quick, if any of these sound familiar, there's something you can do right now. Craving something sweet after every meal, hungry again, an hour after you eat, weight won't budge, no matter how disciplined you are. These are all signs that your body isn't producing enough GLP1. The hormone that keeps you full and supports weight loss. The good news? Bioma GLP1 booster helps you increase its natural production. So you can quiet the food noise and enjoy smoother weight management when following a healthy lifestyle. Head to bioma.health slash GLP1 and use code podcast to get 15% off. Production doesn't pause while an improvement team runs an experiment. Conditions keep changing around it. When teams can't see whether a countermeasure holds, ownership fades. The operator who helped develop the change may move to another shift, the supervisor who backed it may deal with a larger problem.

14:23And the process engineer may inherit several open actions from prior events without time to revisit each one. Eventually the plant has a history of improvement projects but no clear memory of which actions worked, where they worked and under what conditions. Excel often fills that gap and I don't say that as a cheap joke about spreadsheets. Excel survives because it solves a real need. A planner can join a few exports quickly, an engineer can add a note beside a number, and a supervisor can correct something that doesn't look right before the morning meeting. Those are practical strengths, but the spreadsheet also becomes a private version of the process. One person knows which columns came from the MES, which number came from an email, and which adjustment came from local knowledge. When that person isn't there, the report may still open, but the reasoning behind it has gone missing. Teams then spend meeting time reconciling numbers instead of deciding what to test next. You might see an action marked complete because someone installed a rack, changed a work instruction, or added a reason code, but that only confirms the task finished. It doesn't confirm the production condition improved. Completion isn't learning. A better program keeps improvement work

15:25connected to the same routines that manage production. The action should appear when the related loss appears, the person responsible should see the result close enough to act, and the team should know what evidence would confirm the change holds or tell them to revise it. That requires more than a project tracker. It requires a reliable way to check, and that brings us to the weakest part of PDCA in many factories. Not the plan, and not the action, but the evidence between them. PDCA needs a reliable checkstep. Here's the thing about PDCA that most teams miss. The whole system only works when the checkstep can push back on the team's own assumptions. Without that, you're just running a process that feels productive, but never really teaches you anything. Let me break down what that actually looks like in practice. In the plan step, you need a problem statement that's testable, not just a complaint. Saying, changeovers are too slow, doesn't give your team anything to verify. It's a description of pain, not a hypothesis. A better plan describes three things clearly, where you are now, where you want to be, and why you think one specific change will close that gap. Here's a simple example.

16:25Say your team notices that certain changeovers run longer after a particular product family. They suspect it's because tools arrive late. The outgoing order doesn't trigger preparation early enough, so they form a clear hypothesis. If we prepare the toolset before the prior order finishes, the delay between the last good unit of one order and the first stable unit of the next should drop. That's a plan you can actually test. Now here's where teams often skip a crucial step. Before you change anything, you need to decide what would count as evidence, which changeovers are part of the test, what time window gives you a fair baseline, what result would support your idea, and what side effect would tell you it's not working. Without those decisions upfront, your checkstep turns into a meeting, where everyone picks the story that sounds most convincing. I've seen that happen more times than I can count, and it never leads to real learning. Now the do step, this part needs more care than most teams give it. Running a controlled production change doesn't mean turning your factory into a science experiment. You still have delivery commitments, safety rules, quality controls, and people trying to finish a shift. What it means is recording enough about the trial to separate the change from everything else around it.

17:27You note when the revised setup method started, you document the machine or line, the product sequence, the team running it, and any unusual event that happened during the trial. If maintenance adjusted something at the same time, that belongs in the record too. Otherwise, you might give credit to the wrong action. Countermeasures rarely arrive alone. They come with other changes attached, and you need to know which one actually mattered. Then you get to check, this is where the process stops being a good idea and becomes a learning system. You compare the actual operating result with the result you expected, using the same terms and boundaries you set in the plan step. Did the change reduce the delay? Did the delay just move somewhere else? Did the method only work for one specific product transition? Did it add extra work for the operator or create a quality issue after startup? Those questions need facts from real production, not just a positive impression after the first trial. Here's something most people overlook. A good check step respects variation. One clean run tells you very little. Align can behave well because material arrived on time. The tool was in good condition, or an experienced operator happened to be running that setup. You don't need a huge study for every small improvement,

18:28but you do need enough evidence to tell the difference between a repeatable effect and a lucky shift. This is where many teams jump too quickly from due to act. They try a new method, see an early improvement and write a new standard. Then later the method breaks under different conditions and people quietly stop using it because the standard no longer matches the real work. That damages trust. And rebuilding it takes a lot more effort than getting the check step right the first time. Act should follow evidence. When the result holds, you decide how to carry the change into normal work. That might mean updating standard work, changing a planning rule, revising a maintenance check or training the crews who will use the new method. When the evidence doesn't support your idea, act means something else. You adapt the counter measure, narrow where it applies, or remove it completely. A plant that can reverse a weak change quickly learns faster than one that preserves every completed action because nobody wants to reopen a closed project. The check step gives people permission to be wrong in a useful way. Without it, PDCA turns into an opinion loop, someone with more experience, more authority, or simply a stronger voice proposes a cause. The team acts on it.

19:29A few people agree it looks better than the next problem takes over. That can produce local improvements, but it doesn't build reliable knowledge. With a reliable check step, each counter measure leaves a record of the condition, the hypothesis, the trial, and the result. Over time, you can see which actions actually worked, which conditions change the outcome, and which all assumptions no longer hold. That's how continuous improvement becomes continuous. It's built on evidence, not momentum. But here's the trap. Use data is still too vague. A factory can collect millions of machine events and still lack the evidence needed to judge a simple counter measure. So before connecting systems or building reports, you need to define the data that makes a check step credible. Not every data point helps. I see this all the time. A team decides to check a counter measure with production data, and the first instinct is to collect more of it. More sensor tags, more reports, more fields from the MES, more exports from the ERP, then someone builds a giant table that nobody can explain without the person who created it. That doesn't solve your problem. It just gives you more noise. A useful data point connects to actual work.

20:30It tells you what happened, where it happened, when it happened, and under what production conditions it happened. Without those links, a number might look precise while telling you almost nothing about the improvement question you're trying to answer. Take downtime as an example. Your line might show 40 minutes of downtime in one shift. That's a starting point, but it doesn't tell you whether the stop occurred during an order, between orders, during a planned changeover, or while quality was waiting for a decision. The same number can mean very different things depending on when and why it happened. For improvement work, every measure needs enough context to support a decision. At a minimum, you should be able to tie an event to a time, a product or product family, a process step, a resource, and a shift or crew, where that context helps explain the work. You don't need every fact for every question, but you need the facts that could change your conclusion. Here's a scenario I see frequently. Imagine a scrap increase on a filling line, the daily report shows scrap rows during the afternoon shift. That gives you a place to start, but it doesn't prove the afternoon shift caused the loss. Maybe a new material batch entered the line near the shift change. Maybe the line restarted after cleaning. Maybe a change in machine speed happened earlier,

21:31and the rejected units only appeared later at inspection. If your data can't connect, scrap to the order of batch machine setting, process time, and inspection result, you'll fill the gaps with assumptions. People do that naturally. It's what happens when the record is incomplete. Context also matters for waiting time. Waiting rarely appears cleanly in a system because no one owns it as a machine state. A work order might finish one operation at 10 o'clock, then sit for two hours before the next operation begins. Was the resource busy? Was material unavailable? Did the order wait for inspection? Did the plan change? Or did someone simply fail to record the next transaction on time? You can't improve waiting by treating it as a blank space between two timestamps. That brings us to definitions. You need to greet definitions before you compare those timestamps. What counts as downtime? Does a planned tool change count? When does a change over start and end? Does scrap mean every rejected unit or only units that can't be reworked? When does rework become a separate operation, rather than a correction inside the original operation? These sound like small questions until two departments calculate the same loss differently. If production counts a unit as complete when it leaves the machine,

22:34while quality counts it as incomplete until inspection passes, both teams will defend their numbers. Neither team is necessarily wrong. They're using different definitions for different parts of the process. Improvement needs a shared definition for the question at hand. That doesn't mean forcing every system into one giant universal measure. Factories have different purposes for different records. Maintenance needs one view of a stop. Production needs another. Finance may use a different time boundary for reporting. The work is to make those differences explicit, then choose the definition that fits the decision. If you want to reduce loss production time, you need a clear rule for when productive time begins and ends. If you want to reduce quality loss after a restart, you need a clear rule for which units belong to that restart window. This is also where OE can create confusion. Overall, equipment effectiveness can be useful because it gives a common way to discuss availability, performance and quality. A falling OE number can tell you that something changed and deserves attention. But OE doesn't diagnose the cause. A lower OE result might come from longer stops, slower cycles, rejected units, or a mix of all three. It can also change because the target rate in the calculation

23:35no longer matches the product or operating condition. Treating OE as a root cause answer is like treating a warning light as a repair manual. It tells you where to look. It doesn't tell you what to change. The same applies to any headline measure. Total output, schedule adherence, scrap rate and lead time can all point toward a condition that needs work. They become useful for lean only when you can trace them back to the actual work and test a specific idea. So don't start with the data your systems happen to produce. Start with the production question you need to answer, then follow that question back through the facts required to answer it. That's the only way to build a checkstep that actually teaches you something.

24:35Head to bioma.health slash GLP1 and use code podcast to get 15% off. Real quick, does one of these sound like you, because if you say yes to anyone, there's something you can do right now. So here we go. Gaining weight, no matter how disciplined you are, craving something sweet after every meal, feeling hungry again an hour after you eat. These are all signs your body isn't producing enough GLP1. The hormone that suppresses hunger, slows down digestion, and supports weight loss. But fortunately, you can boost your natural GLP1 production. And one of the easiest ways to do that is with bioma GLP1 booster. With every serving, you get science backed and third party tested ingredients. All working together to help your body produce more of this weight loss hormone on its own. Simply take two tiny bioma GLP1 booster capsules each morning before breakfast. This way you can finally quiet the food noise, feel full with less food, and enjoy smoother weight management when following a healthy lifestyle. So again, if you said yes to anyone, here's what to do right now. Head to bioma.health slash GLP1 and use code podcast

25:38for 15% off your first order. That's bioma.health slash GLP1 code podcast. Real quick, if any of these sound familiar, there's something you can do right now. Craving something sweet after every meal, hungry again an hour after you eat. Weight won't budge, no matter how disciplined you are. These are all signs that your body isn't producing enough GLP1. The hormone that keeps you full and supports weight loss. The good news, bioma GLP1 booster helps you increase its natural production. So you can quiet the food noise and enjoy smoother weight management when following a healthy lifestyle. Head to bioma.health slash GLP1 and use code podcast to get 15% off. Start with the improvement question. So start with a real question from the work itself. Not a list of every field your systems can export. Say a team complains that change of us take too long, that still covers too much. A more useful question would be, why does change over time vary so much for the same product family on the same line? Now the team has something they can actually investigate. They aren't trying to explain every stop on the line.

26:40They want to understand the variation in one defined part of the process and that lets them decide what facts belong in the investigation. And just as important, what facts don't. Think about what can affect a change over. You need the production order because the sequence often matters more than the product alone. You need to know which product ran before and which one ran after. You need the line or machine, the tool set, the material involved, the recipe or settings where those apply, the shift, and the people carrying out the work. Time matters too, but not just one time stamp. The team may need the end of the prior run, the start of setup, the first unit after restart, and the point where stable output resumes. Those are different events. If the factory records only one broad change over complete time, it may hide the part of the delay the team really needs to improve. Then at the result, did the line start on time? Did it reach normal speed? Did the first output pass quality? Did the setup trigger an alarm, a manual adjustment, or a wait for material? That turns a vague complaint into a testable question. Suppose the team thinks tool staging causes the variation. They can test that idea against change over whether right tools were ready before the prior order ended, then compare those runs with similar transitions where preparation started late.

27:43The comparison only works if similar means something concrete. Same product family may not mean same package size, same machine, may not mean same tool condition, same shift may not mean the same staffing level. Lean teams already know this when they stand at the line. The data model needs to preserve enough of that context for the evidence to remain honest after the meeting ends. This also protects teams from collecting data just because it exists. A modern line can generate a huge number of signals. Temperature readings, motor currents, cycle counts, alarm codes, valve positions, controller states. Some of those signals may help explain a setup problem. Many won't. If nobody can explain how a sensor tag could change the improvement decision, don't start with it. That doesn't mean the tag has no use. It may matter later once the team sees a pattern that points toward machine condition or process stability, but collecting every available tag before the question is clear, usually creates delay, noise, and a false sense that the team has become more scientific because the data set grew. More rows don't create better reasoning. The level of detail should also match the decision. A production manager deciding whether a new setup standard holds across the week

28:44may need a shift level trend with clear drill down into exceptions. A process engineer trying to find why the first units fail after restart may need event level data, perhaps down to individual cycles or inspection results. Those are different questions. They need different timescales. Trying to force both into one report often produces something that looks complete but helps neither person. The manager gets too much detail to act quickly. The engineer gets averages that smooth out the event they need to examine, so ask who needs to decide what and when. If the decision happens during a shift handover, the evidence must arrive quickly enough for the next crew to use it. If the decision concerns a recurring pattern across product families, a daily or weekly view may fit perfectly well. Real-time data can help, but it isn't a badge of seriousness. A late but trusted record can beat a live number with no production context. Here's another benefit to starting with the question. It exposes missing links early. You may discover that the MES records the order and the machine state, but not the tool identity. Or the quality system records failed startup units, but nobody links them to the change over that came before. That's useful information. It tells you where the improvement loop loses sight of the process.

29:47Don't respond by launching a giant data program. Define the smallest missing fact that would let the team test its hypothesis. Perhaps that means adding a simple tool identifier to the setup record. Perhaps it means recording when stable production begins. Rather than treating restart as a single event, small changes to data capture can change the quality of the conversation. Once the question is clear, you can trace where each fact lives. Some sit in planning records, some come from production execution, others come directly from the equipment, or from the people who work with it. ERP knows the commercial and planning context. Once the team knows which facts it needs, ERP becomes part of the story. Your enterprise resource planning system holds the commercial and planning view of production. The part that lean teams often miss when they focus only on what happened at a machine. ERP knows the sales order, promise delivery date, planned quantity, bill of materials, routing and material demand. It can tell you what the business intended the factory to produce, in what broad sequence and for whom. That context changes the improvement question. Take a long change over on a line.

30:47From the lines point of view, it looks like lost time. From the ERP view, it may also affect the customer order due tomorrow. Consume capacity needed for a higher priority job, or force a planner to split a batch that normally runs as one lot. The physical delay stays the same. The consequence does not. Planning records also explain why a team may see different results from what looked like the same improvement. Suppose a Kaiser team cuts setup time for a certain product family. In the following month, delivery performance still slips. At first, that can look like the countermeasure failed. But the ERP plan may show that demand changed. The production mix shifted towards smaller lots, or a customer commitment forced more frequent product switches than the line normally sees. Without that planning context, the team judges the improvement against a moving target. ERP also carries the process design that production is supposed to follow. A routing may define which operations an order should visit, which work centers should perform them, and what materials the order should consume. That gives the improvement team a reference point when it asks whether the actual process followed the intended path. But planned data and actual data are different things. A routing can say an order should run on a certain resource.

31:50The schedule can say it should begin at eight. Material demand can say everything should be available before release. None of that proves the order actually ran there, started then, or had the right material at the line. Factories adapt all day. Planners' re-sequence work supervises move orders to another resource. Operators use and approved substitute material. A machine stops and the original plan becomes history before lunch. That isn't a failure of ERP. ERP manages intent and coordination. It gives the plan to common plan, but it doesn't automatically record the full detail of execution at the point where work happens. This distinction matters when a lean team investigates a loss. If the team treats ERP status as live operating truth, it may draw the wrong conclusion. An order can look released in ERP while it waits for material. It can look complete from a quantity point of view while quality still holds part of the batch. It can remain scheduled on one work center after production moved it somewhere else to keep the line running. The planner may know why that happened. The system may not show the full reason in a form the improvement team can use. Master data can create trouble here too. Product codes, routing, standard times, and resource assignments look administrative

32:50until a team tries to compare actual work with a baseline. If the routing says a change over should take one amount of time, but the tool requirement changed months ago without a matching update, the baseline already contains a problem. Then the team can spend days trying to explain a gap that began in master data. That's why continuous improvement needs a two-way connection with planning. Lean work shouldn't treat the schedule as an outside condition that no one can question. If repeated evidence shows a routing no longer matches the work, that's an improvement finding. If plan sequence rules create avoidable cleaning or setup losses, that belongs in the discussion too. A production loss can begin in a planning assumption. ERP helps the team connect shop floor conditions to order promises, material demand, capacity choices, and the process that people expected to run. It can show the consequence of a local issue beyond one machine or one shift. Still, ERP can only tell you part of the story. To see what the order actually did after release, you need to move closer to the work into the system that records production execution. MES knows what production executed. ERP tells you what the plant intended to do,

33:51but the manufacturing execution system, or MES, records the work as it move through production, which gives the improvement team a firmer place to test an assumption. An MES can capture that a work order reached a line that an operation started and finished, along with produced quantity, rejects, holds, material consumption, operator entries, and traceability links tying a unit or batch back to the process history. That record fills the space between the plan and the physical result, picture an order that ERP scheduled for line two. During the shift, the line develops a fault, so the supervisor moves the order to line three, the operator starts later than planned, pauses for a quality check, produces most of the required quantity, then puts the remaining units on hold because an inspection result needs review. The planning record alone can't tell that story, but the MES can show the actual route, times, quantities at each stage, and exactly where the order stopped moving. For lean work, that detail changes the kind of question a team can ask. Instead of saying, we seem to lose time after release, they can ask whether orders wait before a specific operation, whether a revised setup method reduces time

34:52from start to stable output, or whether rejects rise after certain production conditions. The MES gives events a production identity. A stop, a reject, or a delay, becomes more useful when you connect it to a work order, an operation, a resource, and a time range. That doesn't solve the cause on its own, but it gives the team a trace they can follow without relying on someone's memory from last Tuesday. Now here's where it gets interesting. This matters most when a countermeasure has to survive normal variation, say the team changes a setup instruction, and wants to know if the change works across all crews. They can use MES records to compare execution across shifts, product families, and orders that ran under the agreed method, but the comparison has to stay honest. The team needs to know which orders followed the new method when it began, and whether operators used it as intended, otherwise the report may compare two groups that only look similar from a distance. MES records aren't automatically clean, just because they come from a production system. Every factory has gaps. An operator may enter a transaction late because the line needed attention first, a reason code may mean one thing to day shift

35:55and something different to night shift, and a supervisor may use a workaround to keep work moving when the formal transaction sequence doesn't fit in unusual situation. Those work runs often carry useful information. They show where the digital process doesn't match the real process. If people routinely delay a transaction or choose a broad reason code because the available choices don't describe the work, the team shouldn't start by blaming data entry. Instead, they should ask what the workflow asks people to do and whether that request makes sense during production. Reason codes need the same treatment. A code like Equipment Issue may point to what maintenance, but it doesn't explain whether a sensor failed, a fixture needed adjustment, or an alarm, followed a material problem. The MES can give the event a place in the order history, but investigation still needs people who understand the process. That's actually a healthy split. The system records repeatable facts, and operators, engineers, quality staff, and maintenance teams interpret those facts against the conditions they know. When the interpretation reveals a gap, MES data can show whether that gap repeats elsewhere or belongs to one unusual run. Watch the timing, though. An MES might record the time a user confirms an operation,

36:57not the exact moment the physical process ended. That distinction can matter a lot when studying short delays, handoffs, or setup work. For some questions, transaction time gives enough evidence. For others, the team needs a closer view of equipment and process states. The decision should follow the improvement question, not a belief that every timestamp means the same thing. Used well, the MES becomes the factual record of execution that PDCA needs for its checkstep. It shows whether an action changed the work order path, operation duration, output, reject pattern, or holds data across real production runs. But it still sees the factory from the execution layer to understand the physical behavior inside a cycle, stop or restart, the team may need another source of evidence, the signals coming from the equipment itself. IoT and machine data explain the physical process. The MES can tell you when an operation started, when someone recorded a stop, and how many units passed or failed, but when the team needs to understand what happened inside that operation, they often need data from the machine. That data usually begins at the PLC, the programmable logic controller that runs the equipment.

37:59It may include cycle signals, machine states, alarm events, speed, temperature pressure, motor load, or a signal showing an interlock prevented the next step. Real quick, does one of these sound like you, because if you say yes to anyone, there's something you can do right now. So here we go. Gaining weight, no matter how disciplined you are, craving something sweet after every meal, feeling hungry again and hour after you eat. These are all signs your body isn't producing enough GLP one. The hormone that suppresses hunger, slows down digestion, and supports weight loss. But fortunately, you can boost your natural GLP one production. And one of the easiest ways to do that is with Bioma GLP one booster. With every serving, you get science back and third party tested ingredients. All working together to help your body produce more of this weight loss hormone on its own. Simply take two tiny Bioma GLP one booster capsules each morning before breakfast. This way you can finally quiet the food noise, feel full with less food, and enjoy smoother weight management when following a healthy lifestyle. So again, if you said yes to anyone,

39:00here's what to do right now. Head to Bioma.Health slash GLP one and use code podcast for 15% off your first order. That's Bioma.Health slash GLP one code podcast. Real quick, if any of these sound familiar, there's something you can do right now. Craving something sweet after every meal, hungry again an hour after you eat, weight won't budge, no matter how disciplined you are. These are all signs that your body isn't producing enough GLP one. The hormone that keeps you full and supports weight loss. The good news, Bioma GLP one booster helps you increase its natural production. So you can quiet the food noise and enjoy smoother weight management when following a healthy lifestyle. Head to Bioma.Health slash GLP one and use code podcast to get 15% off. Right now at Subway, try the 499 sub of the day. Get a different six inch sub every day for just 499 each, like meatball marinara on Mondays, tuna on Tuesdays, and the BMT on Saturdays. It's a different six inch sub every day, packed with protein and your choice of chopped veggies

40:00for just 499 each, or make it a meal with chips and a drink for just $2 more. But hurry, it's only for a limited time and only at Subway. At participating restaurants, prices higher in Washington, Alaska, and Hawaii and on third party delivery, add on taxes and fees for delivery additional. This is where industrial internet of things or IoT data becomes useful. It gives the improvement team a closer record of the physical process rather than only the transactions around it. Take a recurring restart delay. The MES may show that production resumed at a certain time and stable output arrived much later, but machine data can help separate that period into actual events. Perhaps the line cycled, but ran below target speed, perhaps an alarm repeated several times before an operator cleared it, or perhaps a temperature zone took longer to reach range after cleaning. Those are different conditions and they call for different countermeasures. A machine signal on its own still has limits. A motor current spike may look very precise, but without knowing the work order, product operation and machine condition, it's just a precise orphan. You might find a repeated alarm and assume it explains a quality problem, but then you join it to the production record

41:00and find that the alarm appears on many normal runs. Or you find that it only becomes a problem during a specific product transition after a tool change and before the first inspection result. Context turns the signal into evidence. So the team needs links between machine events and the production record. A stop should connect where possible, to the resource, work order, operation, product and time range. And a quality issue after a restart should connect back to the process state before it, not only to the final inspection record. That doesn't mean every machine event needs a perfect business label. Factories produce too much data for that and plenty of it won't matter to the question at hand. Instead, start with the physical signals that can help distinguish one explanation from another. If the team investigates unstable changeovers, it may need machine state changes, cycle timing, speed after restart, alarm history and time to reach stable running conditions. But it probably doesn't need every unused controller tag copied into a cloud platform just because the tag exists. That approach keeps the work focused. Machine data also needs careful handling because this sits inside the OT world.

42:00Operational technology. The control network exists to run equipment safely and predictably, not to support a last minute analytics experiment from the office. Collection should respect the production environment, use approved connections, keep traffic and access within known limits. And avoid changes that interfere with controller timing, safety functions, or the people trying to run the line. A factory can tolerate a report arriving later, but it can't tolerate a data project that creates an unstable control environment. This sounds obvious, but the pressure for real-time visibility can produce bad decisions. Not every improvement question needs second-by-second data. If a team studies a recurring loss across a week, a scheduled extract of machine states may give enough evidence. If they need to react during a shift, faster data may justify the added effort. The speed of the data should follow the speed of the decision. There's a human side to this too. Machine data can help people see recurring process conditions, but it can also become surveillance theatre if it's used mainly to judge individual operators from isolated events. That's not lean. If a cycle runs slowly, the useful question isn't, who caused the slow cycle?

43:01It's what condition slowed it? Was the material difficult to feed? Did the equipment need adjustment? Did the work instructionally room for interpretation? Did a quality concern force a careful manual check? People need to trust that data will improve the work, not simply create a new way to assign blame. When that trust exists, machine signals can strengthen the PDCA loop. The team can test whether a change reduced repeated alarms short and time-to-stable speed or removed a recurring stop pattern, and they can also see side effects that an end-of-shift total would hide. Still, equipment can only report what its sensors and controls can detect. It can't explain why an operator chose a work around why maintenance postponed a repair, or why a quality check felt wrong despite a normal machine state. That meaning still comes from the shop floor. The shop floor adds meaning. Machine data tells you a line stopped. The MES shows which order an operation was running. But neither system catches what people actually saw, heard or decided while the process was under pressure. That context still lives on the shop floor, and it often changes the direction of an investigation more than another week of data collection would. Picture a filler that pauses several times during a run.

44:03The records show repeated short stops and lower speed. An operator might tell you the real issue starts when a certain type of container enters the infeed, because it sits slightly differently in the guide rails and triggers a manual adjustment. That observation gives the data a direction. Maintenance notes matter for the same reason. A technician records that they adjusted a sensor bracket, cleaned a photo eye, or noticed wear on a guide. A quality inspector notes that defects appear at start-up but fade after the process warms up. During handover, one crew wants the next that a work around is in place because a normal step takes too long. None of those notes replace proper process records. They add the conditions that formal records often miss. Reason codes sit right in the middle of this. A code like material issue, machine fault, or quality hold helps sort a large number of events, but it shouldn't close the investigation. A broad code is usually the start of a conversation. If an operator selects material issue, the team still needs to ask what that meant in the moment. Was the material late? Was the label wrong? Did the material behave differently? Did the container arrive damaged? Or did an upstream change create a problem that only appeared at this station?

45:05The code points somewhere. People explain the path that means data capture needs to fit the way work happens. If recording an event takes too long, asks for details nobody can know at the time or forces an operator to leave a running process, the data becomes late, vague, or gets skipped. Then someone in an office calls it a data quality problem. Technically true, but not very helpful. A better approach asks a simpler question. What is the smallest human input that would help the next decision? Maybe an operator only needs to choose from a few clear stop categories and add a short note when a condition falls outside those categories. Perhaps a supervisor can confirm the calls later after speaking with maintenance or quality. The work should follow the event, not interrupt it. You also need a feedback loop back to the people who enter the data. Operators stop trusting a reason code process if every entry disappears into a report that nobody at the line ever sees again. They need to see that a repeated issue triggered a check that a note led to a discussion and that an agreed countermeasure changed something in the process. Trust grows through visible response. Think about the difference between asking someone

46:05to log a recurring jam and returning the next shift with a clear finding. We checked the last 10 events. They all followed the same product transition and the guide adjustment is now part of the setup check. That doesn't promise the problem has vanished. It shows that the entry became part of the learning loop. That's a much better reason to record the next event carefully. The shop floor also keeps improvement honest. Data attempts a team to talk only about what fits into a field a timestamp or a chart. But the people doing the work can point out the missing condition. They can say the stop was planned but recorded as unplanned. They can explain why a standard method wasn't safe or practical during a particular run. They can spot when a clean looking report conflicts with the actual process that challenges healthy. Continuous improvement needs structured facts but it also needs a way for people to correct the story. Those facts appear to tell. The best setup doesn't force operators to become full-time data clocks and it doesn't ask engineers to guess what happened from a distance. It gives each person a useful role. Operators and supervisors capture what the systems can't sense. Maintenance and quality at their view of equipment

47:06and product conditions. Engineers connect those observations to recurring patterns. Then the result returns to the work as a better standard, a better check, or a clearer question for the next cycle. But that only works if people can trust the shared record. When the ERP, MS, machine historian and local spreadsheet all describe the same shift in different ways. The team spends its time debating which number to believe instead of improving the process. When systems disagree. The trouble gets harder when each system tells a slightly different story about the same work. Your ERP might identify a machine by a planning work center code. The MES uses a production resource name. Maintenance refers to the asset number stamped on the machine while the historian collects signals under a controller tag created years ago by an integrator. Everyone means the same machine, yet the records don't join cleanly. That sounds like a technical nuisance until a lean team tries to investigate a repeated loss. Someone pulls downtime from the MES. Maintenance history from another system and order data from ERP. The team then spends half the meeting asking whether line 12, packet 12, asset 00481

48:06and the PLC tag PK underscore 12 all refer to the same physical resource. Sometimes they do, sometimes one name refers to the full line and another refers only to the filler inside it. A report can't solve that by making the labels look similar. The team needs to know what each label actually represents. Time creates the same kind of problem. ERP groups work around a planned shift boundary. MES records an operation when an operator confirms it. The historian logs a machine event at the moment it happens. Quality records a result after a sample reaches the lab. Those timestamps can all be correct. They just describe different moments. Consider a batch that completes on the line late in the afternoon. The MES records the produced quantity and closes the operation. ERP now sees the order as complete from a production posting point of view. But quality holds the batch because an inspection result hasn't cleared. Production thinks the order is done. Quality sees product that can't move. Planning sees a completed order that may still threaten a shipment. Nobody needs to be wrong for the factory to face a real problem. If a daily performance report counts that batch as good output while the delivery report counts it as unavailable, a continuous improvement team can easily start with the wrong condition.

49:09They may look for a line loss when the actual delay sits in the handoff between production completion and quality release. The same issue appears in downtime. A machine state changes to stop at the exact time a sensor detects no movement. The MES begins downtime only when an operator selects a reason code. A supervisor classifies the event after the shift. Once they know whether the stop belonged to a planned changeover or an equipment fault. Each record has a purpose. Problems begin when people compare them as though they measure the same thing. Spreadsheets often hide this disagreement because somebody quietly fixes it. They adjust a timestamp, rename a resource, remove an event that doesn't look right or add a manual note to explain a gap. The report then looks tidy enough for the morning meeting. But the reconciliation work hasn't disappeared. It's moved into one person's head that creates a fragile improvement process. If the person who understands the adjustments changes role, takes leave or simply runs out of time, the next report tells a different story without anyone noticing why. You can see the effect in meetings. One person says the line lost 40 minutes. Another says the machine only stopped for 25. A third points out that the lost time occurred

50:11during a planned product switch. So neither figure describes the question they actually need to answer. People then argue over the number. The better question is what each number means. This isn't a dashboard formatting problem. It's a factory model problem. A dashboard can present the information clearly, but it can't decide whether an order completion means production complete, quality released, packed or shipped. It can't infer whether a resource code refers to a whole line, one station, or a shared tool. And it can't safely guess whether two events from separate systems belong to the same production incident. Someone needs to define those links. That doesn't mean forcing every department to abandon its own terms. Production, maintenance, quality, and planning each need language that fits their work. The aim is to create enough shared reference points so people can connect records without pretending every record has the same purpose. For a specific improvement question, agree on the resource in scope, the order or batch in scope, the event boundaries, and the rule for deciding when output counts. Put those rules where the team can find them. Not only in the memory of the person who built the report, then challenge them when the process changes, because it will change.

51:12Equipment gets modified. Roots shift, new products arrive. An old machine might gain a new controller while keeping the same asset number. Exactly the sort of detail that can create a very confident and completely misleading trend line. Continuous improvement depends on shared facts. Shared facts don't appear just because systems connect. They appear when the factory agrees on what its records refer to and keeps that agreement current as work changes. The next step is building that shared factory language into the data itself. The data model behind continuous improvement. These are all signs that your body isn't producing enough GLP1. The hormone that keeps you full and supports weight loss. The good news? Bioma GLP1 booster helps you increase its natural production. So you can quiet the food noise and enjoy smoother weight management when following a healthy lifestyle. Head to bioma.health slash GLP1 and use code podcast to get 15% off.

52:14Ready for 10 days of Microsoft 365? Co-pilot, AI, Azure and the people shaping the future of work? This January, M365Con is back and we're going bigger. Join us for live sessions, real-world demos and practical knowledge from MVPs and industry experts worldwide. No generic slides, no endless buzzwords. We're tackling the real challenges. Co-pilot studio, AI agents, fabric, security, governance and automation. Whether you're an IT pro, developer or business leader, there are sessions designed for you. With 10 full days, you can explore multiple technologies and connect with a global community. Watch live and take practical insights back to your organization. January, 2027, 10 days. One Microsoft community. Registration is open now. Go to M365Con.net and secure your place today. That's M365Con.net. Join now at M365Con.net and we'll see you live in

53:18January.

54:18The model needs to state how those things relate. Is Liner 3 the full production line which asset performs the filling operation? Which one controls the label application? What does the schedule actually reserve? That level of detail lets the team ask a real question without rebuilding the context every single time. The same applies to products. A finished goods code may describe what ships to the customer, but a recipe, pack format, toolset and material batch all describe conditions that affect the work. For some improvement questions, the finished goods code gives enough detail. For others, it hides the difference that explains the loss. A good data model supports both levels without forcing people to guess which one they need. Relationships matter just as much as names. I've seen improvement work fail time and again because the records tell you several things happened, but they don't connect. You need to know which product followed which route. You need to know which operation ran on which resource. You may need to know which tool, recipe, material batch or maintenance condition applied during that operation. And you need to link the outcome back to those conditions. In practical terms, that means a reject record should not float alone in a quality table.

55:19It should link back to the order or batch, the operation, the resource and the relevant production window. A downtime event should connect to the resource and time period, then join to the order and operating state where the loss occurred. Those links let a team test to hypothesis with a lot less guesswork. Time leads the same attention. Factories often store plenty of timestamps, but they don't always distinguish what each one means. Plan start time, actual start time, machine event time, operator confirmation time. They all sit right next to each other, but they answer very different questions. A planner needs planned and actual start times to understand scheduled performance. A process engineer needs the exact machine event time to study a short stop. A lean team testing a revised work method needs to know when that method started, which runs fell inside the trial period and when the team changed it again. If the model treats all time stamps as one generic date and time field, the evidence gets slippery really fast. Definitions also need a home in the model. Down time, scrap, rework, good count and target rate should each have a clear rule tied to the question people need to answer. Take good count. Does it mean units leaving the machine?

56:20Units that passed inspection, units packed and ready for shipment, all of those measures can be useful, but they should not share one label and quietly mean different things in different reports. The same problem appears with target rate. A line may have one standard speed for a simple product and another for a difficult format. If the model ignores that difference, a performance loss appears even when the line ran exactly as the approved process required. Definitions need versioning too. A process doesn't freeze. New products arrive, tools change, engineering updates, recipes, maintenance replaces, major components. The model needs to preserve which version of the process, standard or target applied at the time of the event. Without that, people compare last month's production against today's rules and call the difference a trend. This is where master data ownership comes into the picture. Somebody needs responsibility for product structures, rooting relationships, resource hierarchies, approved rates, and the mappings that connect systems. That doesn't mean one central team has to know every detail of the factory. It means each type of data has a named owner, a change process, and a way to check the effect downstream.

57:20When a new tool enters production, who links it to the resources and product transitions it affects. When a work center splits into two physical stations, who updates the relationship used by planning, MES, maintenance, and reporting. If nobody owns those changes, the data model slowly drifts away from the work. Then every kiesin event starts with an argument about the facts on the ground. A useful data model doesn't need to describe every part of the plant on day one. It needs to describe the part of the process the team wants to improve, with enough identity, relationship, time, and definition to preserve the production story. Once that structure exists, PDCA can move beyond documents and action lists. The improvement cycle carries its own evidence from the problem statement through the trial and into the decision about what happens next. From PDCA documents to a data loop. Once the factory has enough shared context, the PDCA cycle can stop living in a document folder. The improvement record becomes part of the operating record connected to the work it intends to change. Start with plan. A team should link the issue to a measurable condition and a named part of the process. Not a broad statement like, improve performance on line three.

58:22The record needs to state where the condition appears, when it appears, and what the team expects to change. It might refer to a defined change over sequence on a named line for a certain product transition during a known production window. That gives the problem a location in the factory model. The plan record can then point to the baseline the team chose. Not a generic monthly average pulled from an old report, but the actual production runs, orders, events, and time range that describe the current condition. Anyone reviewing the work later can trace the claim back to the evidence used at the time, and that changes the quality of the discussion. A hypothesis belongs in the record too. The team should write what it thinks causes the loss, what countermeasure it intends to try, and what result would support or reject that idea. You don't need a huge document here. A short clear statement is often better because people can actually test it. Then comes due, and the countermeasure needs its own context. Record the scope, which resource, shift, product, family, work instruction, or order group did the team include? Who owns the trial? When does it start and when does it change? If the team applies the new method only to one set of conditions, say so plainly, scope protects the evidence.

59:23Without it, a later report may include runs that never use the countermeasure, or exclude runs where it did the team compares mixed populations and calls the result inconclusive when the real issue is that nobody captured where the trial applied. A data loop also records changes as they happen. If a supervisor adjusts the countermeasure after the first few runs, that's not a failure. It's part of PDCA, but the system needs to retain the first version, the revised version, and the date each version entered production. Otherwise, the check period becomes hard to interpret. Now consider check. The team should define a baseline and a control period before looking at the result. The baseline describes the condition before the trial. The control period captures comparable production after the trial began. Comparable doesn't mean identical. Factories rarely give you that luxury. It means the team uses agreed rules for which runs belong in each group and then checks the actual result against the expected result. The comparison can update automatically as MES events, quality outcomes, and approved machine data arrive, but automation should not quietly decide the conclusion. People still need to ask whether an unusual order mix a maintenance event, a missing record,

1:00:23or a process change affected the comparison. The report should expose those conditions, not bury them under one green number. A useful check view lets the team move from the measure to the affected runs, then back to the evidence and the notes attached to those runs. That makes review faster, without turning it into blind trust in a dashboard. If the result supports the hypothesis, act moves the change into normal work. The team may update standard work, revise a setup checklist, change a planning rule, or extend the method to another resource. Each decision needs a clear status and effective date. The factory should know whether the countermeasure remains a trial, became the approved method, applies only in a narrow context or has been withdrawn. Withdrawal deserves a record too, when evidence shows a countermeasure doesn't work, or creates an unwanted side effect, reversing it is a sound engineering decision. A closed action should not mean never discuss this again. It should mean the team can see the decision, the evidence behind it, and the condition under which it was taken. That history matters when the same loss returns months later. Instead of starting from a blank action tracker, the next team can find prior hypotheses,

1:01:23see what people tested, inspect the production conditions, and decide whether the old result still applies. Maybe the prior countermeasure failed because of a product format that no longer runs. Maybe it worked until a new tool changed the setup process. The improvement record remembers what the slide deck forgets. This does not require every kies in action to become a complex software project. A small loop can begin with a disciplined record, a few linked data points, and a routine that reviews them at the right time. But the record must stay attached to the process. When it does, PDCA becomes more than plan due to check act, written on a workshop board. It becomes a chain of evidence, a condition, a tested response, an observed result, and a decision that production can carry forward. Scenario reducing change over loss. Here's a scenario that most manufacturing teams have lived through. You've got a packaging line running several product formats and the schedule is tight. Every change over window matters. Changes over should be predictable, but some fly by while others blow the next order out of the water. The plant already ran kies and events on the problem. Teams mapped setup steps,

1:02:25moved tools closer to the line, and updated a checklist. For a while it felt like progress. Then missed schedule windows came back. The team came up with a better question. Instead of how do we reduce change over time? They started asking why the same line, changing between the same product families, performs so differently from one change over to the next. That shift in wording changes everything. On a walk through the line, the team spots a common delay. Operators start hunting for tools after the previous order finishes. Some tools are staged, some are laid from cleaning, and sometimes the setup instruction doesn't even say which version they need. So the team forms a hypothesis. If they identify, check and stage the next tool set before the current order ends. The gap between last good unit and stable output should shrink. They also expect fewer rushed adjustments on startup. That's the plan, but they don't roll it out everywhere at once. They start with a specific set of product transitions on one line, recording the date, the sequence, and who's responsible for staging. The paper checklist might still be there. That's not the issue. The difference is that the checklist now links to actual production evidence.

1:03:28The ERP record gives the planned sequence what came before and after planned quantity, and whether the planner changed the sequence near shift start, that's critical because a last minute sequence can kill the staging window even if the method is solid. MES adds the execution trail. When the prior order closed, when the next started, when accepted output came through, they can trace rejects, holes, and rework during restart, which lets them separate a short mechanical setup from a long recovery after the machine starts moving. Machine states add the physical detail. The line might idle, run a few cycles, stop on an alarm, restart, then crawl while operators adjust. If the team only measures time to first cycle, they might claim success while the factory is still losing output in that early ramp. Stable output is the condition that really matters. Operator observations rounded out. Maybe one crew says staging works when the tool cart returns on time, but falls apart when a tool needs an extra inspection. Another crew reports that the instruction lists the right tool family, but not the exact insert for a certain package size. Those notes don't replace the records, they explain patterns in them. After enough trials, don't just look at the average,

1:04:29it can look good while hiding a new problem. Break results down by product family, crew, tool type, and maintenance condition, where you have the data. Maybe the new routine helps standard tools, but not precision adjustments. Maybe it works on day shift because staging is someone's clear job, but night shift has a different handover. Or maybe long change over cluster after a tool comes back from maintenance. That points to tool readiness, not operator behavior. That's why context matters. Now take a result that looks like a win. Average change over time drops, and the team is ready to standardize. But quality records show increased rejects after restart for one product family. The line starts sooner, but it doesn't reach stable production sooner. A rushed setup might leave a guide rail or a ceiling parameter off. The first unit's run, then inspection catches the fault. If the team celebrates only the setup time drop, they've just shifted loss from availability to quality. That's not improvement. The check step needs both metrics. Change over time, time to stable speed, and units reworked or rejected after restart. Broken down by format, crew, and tool condition. Once they can answer those questions, they can tune the counter measure. Maybe keep staging and add a verification step for certain formats,

1:05:31or maybe staging only fixes part of the loss, and tool maintenance needs its own PDA cycle. Either way, the plant moves forward because they learned from production, not from a whiteboard session. And notice what happened here. They didn't need every machine tag in the plant or a massive data program. They needed a small connected record around one recurring loss. And a way to check whether the change improved flow without creating a new loss somewhere else. The next challenge is that even good data can mislead when you boil it down to a single average. Why averages mislead lean teams? Average is feel safe. They compress a messy process into one number. But when you treat an average as the whole story, it hides the exact condition that needs attention. Take the packaging line example. Average change over time drops after the staging routine starts. That sounds good, and it might be good. But imagine most changeovers are slightly faster while a few still take ages. Those long ones still break the schedule. If five changeovers finish on time and one takes twice as long, the average looks fine. But the planner still has a late order. The next line still waits for material, and the shift supervisor still spends an hour patching the schedule.

1:06:32The team needs to see the spread, not just the middle. Ask a different question. How often does a change over blow past the window you need to protect? That brings the operational consequence back into the review, and it helps you look for the conditions around the long events. Maybe they all happen after a specific product. Maybe after the tool comes back from maintenance. Maybe only when the order sequence changes late and prep starts after the prior run ends. The average won't show you that pattern. Shift variation creates the same risk. A line might show a stable average change over time across a month. But one crew consistently has longer recovery after restart. That doesn't automatically mean they need more training. It could be staffing, handover timing, tool access, product mix, maintenance support, or the sequence planning assigned to that shift. A number can point fingers too quickly. Treat variation is a question about process conditions. Which condition changes when the result changes? What accompanies the long change over and vanishes on the short ones? That's a better starting point than asking who had the worst number. OE can create the same false calm. One score combines availability, performance, and quality. It helps you spot that a line moved wrong, but it hides how the loss shifted inside the process.

1:07:34Say availability improves because setup time drops. At the same time, quality declines after startup and the line loses more units before stabilizing. The combined OE might barely change. A manager sees a flat trend. The crew sees a new quality issue. Both views are real because the headline number compress different losses into one. Separate the loss modes. Ask? Did the line stop too often? Run too slow or produce defects? Then ask when each loss occurred. A speed loss in the first 15 minutes after change over points to a different condition than a long unplanned stop midrun. Time sequence often tells you more than the daily total. Waiting between operations works the same way. Daily output might meet the plan, but individual orders sit for long periods between steps. The plant catches up by end of day, so the total looks fine. But WAP grows priorities shift and teams spend more time chasing orders through the factory. Flow suffers before the output report admits it. To answer that, follow an order through time. When did it finish one step? When did the next start? And what filled the gap? A resource constrained? Inspection weight, missing material, dispatching rule or late transaction

1:08:36each creates a different response. One daily number can't answer that, so when a measure moves, don't stop at the average. Check the distribution. Look at the long events, the short ones, the sequence, and the point where variation enters. Compare conditions that look similar on paper, but behave differently in production. The goal isn't a more complex report. It's to find the condition you can actually change. Improvement also needs to follow the flow of work across the factory, not just the score of one asset. Value stream mapping needs live data. Here's the problem. Most manufacturers don't talk about. Value stream mapping gives a lean team a common language for flow. It tracks material and information from the first customer signal through planning, production, inspection, and shipment, so people can see where work sits, loops back, or moves without adding customer value. That shared view helps, but it can go stale quickly. Picture a map on a wall showing a process that takes five days from release to shipment. The team marked queue times between operations, work in progress, inspection steps, and how planning information flows. When they built it, everyone agreed on the big picture. Then the production mix changes.

1:09:37A supplier delivery arrives late, or a planner resequences orders to protect the customer commitment. The map still describes the intended flow, but it can't tell the team how this week's orders actually moved. That's where operational data steps into backup the map. The map should stay simple enough for people from production, planning, quality, and logistics to discuss it together. You don't want to turn it into a technical model that only a data engineer can read. But behind each step, the team can connect live or regularly refreshed evidence from the systems that record the work. A queue on the map becomes a question with evidence behind it. How long do orders really wait between this machining operation and the next assembly step? Does the wait happen every day, or only when a certain product family runs? Does it grow after a quality hold, a material shortage, or a schedule change? The answer's sit in the order history, MES events, quality records, and planning updates. The map gives that question a place in the flow, and the data lets the team actually test it. Take work in progress. WIP, as it's often called. A static value stream map might show a typical number of units or batches waiting between two processes that can highlight a broad problem,

1:10:39but it doesn't tell you which orders are waiting, how long they've waited, or whether they're all waiting for the same reason. The operational record can fill in those blanks. A team might find that the queue looks normal overall, while a small set of orders repeatedly waits for inspection release. Or maybe the queue rises after one upstream resource runs a large batch, even though the next resource can't take that product until a tool becomes free. The count alone doesn't reveal which condition created the waiting. Flow needs time and context. Lead time works the same way. If a customer order takes longer than expected, the team should be able to trace its real path. When did planning release it? When did material become available? When did each operation actually start and finish? Did the order sit in a queue? Return for rework, wait for inspection, or lose priority after a schedule change? That trace connects an abstract lead time problem to decisions people can actually change. Say an order misses shipment. A quick review might blame the final production line because that's where the last visible delay occurred. But when you trace the order through the value stream, you may find the delay started much earlier. Perhaps planning released the order late because a component looked unavailable. Perhaps the component arrived,

1:11:39but the ERP status didn't update in time for the next planning run. Maybe production finished the order, then quality held it for a check that the team hadn't included in the original Flow map. The final line didn't create the whole delay. It inherited it. That's why the information flow in value stream mapping matters as much as the material flow. A production order can wait because material is missing, but it can also wait because a status change, inspection result, dispatch decision, or planning rule, didn't reach the person who needed it. When you connect the map to operating data, you can see both forms of waiting. Now, here's where restraint comes in. You don't need a live feed for every box and arrow on the map. The purpose isn't to build a busy digital wall that nobody uses. The purpose is to connect the points where the team needs to make an improvement decision with the records that show whether Flow actually improved. For one value stream that might mean daily QAGE, order lead time, rework loops, and schedule changes. For another, it might mean shift level flow through a constrained operation and the reason orders wait before it. The measures should follow the problem in that value stream, not every line needs the same view.

1:12:40The useful result is a map that stays human readable while the evidence behind it stays current. People can still stand together and ask where Flow breaks. But instead of relying on an old workshop snapshot, they can follow a real order through planning, release, operation, inspection, and shipment. That changes the conversation. A late order stops being a red number on a delivery report. It becomes a chain of events across functions with named handoffs and recorded conditions. Once you can trace that chain, continuous improvement moves beyond one line or one department because the decision often sits between IT and OT, planning and execution, or quality and production. Improvement across IT and OT. Now, here's where it gets interesting. Once improvement follows the path of a real order, the team crosses a boundary that many factories still treat as separate worlds. Operational technology, OT, runs the physical process. It includes the controls, machines, sensors, safety systems, and the people responsible for keeping production stable. OT teams work with equipment that can hurt people, damage product, or stop a plant when something changes carelessly.

1:13:42That changes the rules. An OT engineer can't treat a production line like a test server. A controller change needs discipline. Network access needs discipline. Even a new data connection requires someone to understand what it touches, when it runs, and how the line behaves if that connection fails. It has a different job. IT manages identity access, integration, data storage, enterprise reporting, and the rules around security. They need systems that people can support, audit, and extend, without building a new one-off connection every time somebody needs a report. Both groups protect the business. They just protect it from different forms of failure. Lean teams sit right between them because improvement questions often need both kinds of evidence. A team may want to know why a line loses flow after machine alarm. That question needs the operating facts from OT, but it may also need the work order, material status, quality result, and delivery consequence from enterprise systems. Nobody owns that question alone. If OT owns the whole answer, the team may see the machine condition, but miss the planning decision that created repeated product switches. If I'd owns the whole answer, the team may join data correctly, yet misunderstand what a machine state means

1:14:43during a real setup. The factory needs both views in the same conversation. Picture a recurring issue with a heat treatment process. Production sees batches waiting. Maintenance sees no active fault. The planner sees a resource that should have capacity. A lean team starts asking why the queue grows on certain days. An OT person may point out that the oven needs a controlled cooldown period after certain recipes. The MES record can show when that condition occurred. Planning may then find that the schedule repeatedly places incompatible recipes next to each other, creating waiting that looks like a capacity problem but begins as a sequencing rule. That is an improvement question that crosses IT and OT. The goal isn't to turn every Kaiser event into an integration project that would kill the pace of improvement very quickly. You don't need a steering committee and six months of architecture work every time a team sees a recurring delay. But you do need a repeatable path for getting approved facts into the hands of the people who need to act. Start with the question. Which event needs explanation? Which system records part of that event? Which person can explain the operating condition? What decision will change if the team finds an answer? Those questions keep the work practical.

1:15:45Shared ownership matters too. OT should help define what machine states, alarms and operating limits actually mean. It should help define access, data movement, identity, retention, and the support model. Lean leaders and production teams should define the loss of the work process, the review rhythm, and the countermeasure they want to test. No single team can fill in all those blanks. Data quality needs the same shared approach. If a tag changes after a machine upgrade, OT may spot it first. If the change breaks an integration or alter the report, IT may spot it next. If a supervisor sees that the report no longer matches the shift, production needs a simple way to raise that issue before people start making decisions from bad evidence. The response process matters as much as the data connection. You also need to avoid a common mistake. Sometimes IT asks for universal standards before connecting anything. Sometimes OT refuses any shared access because the first request arrived without enough understanding of the plant. Both reactions make sense when people have lived through poor projects. Still, neither response solves the production problem. A better approach starts with a bounded use case and clear controls.

1:16:45The team agrees which signals or records it needs, how often it needs them, who can access them, and what stays inside the operational network. Then it tests whether the information helps a real PDA cycle. That builds trust through work, not through slogans. As a Microsoft MVP, I spend a lot of time around Azure, Fabric, Power BI, and the wider Microsoft stack. Those tools can help connect the dots between IT and OT. But they don't decide what a stop means, which process condition deserves attention, or whether a countermeasure works safely on a live line. The factory has to model that meaning. Once those roles are clear, Microsoft technology can fit into the architecture as a practical data path, rather than another platform someone hopes will fix an unclear improvement process. A practical Microsoft data path. Here's the problem. Most manufacturers don't talk about. You've got the equipment. You've got MS. You've got ERP. And you've probably got a Azure somewhere in the mix. But getting data from the shop floor into something useful still feels like a plumbing project with no blueprint. And the worst part is nobody wants to admit their data model can't support the questions they're actually asking.

1:17:45So let's walk through what a practical data path looks like on Microsoft tools without pretending the platform owns the process. It doesn't. It supports it. Start close to the equipment. Machine and sensor data should leave the operational network through an approved edge layer. Something OT teams understand and can support. That layer collects selected PLC states, alarms, cycle events, and process values, then passes them forward without giving the cloud direct control over the line. Production stays in charge of production full stop. Pull execution facts from MES next. Operation times quantities holds rejects reason codes. That's the record of what actually happened versus what was planned. At ERP data for order demand, plant sequence routing, material status, and the planning changes that explain why a supposedly stable process keeps getting disrupted at the last minute. Quality records join when you need to know whether a change improved output but hurt product acceptance maintenance records join when equipment, condition or work history is part of the hypothesis. You don't need every source for every case but you need the sources that explain the condition you're reviewing. This is a chain of evidence, not a data collection contest.

1:18:46Collecting everything and hoping the answer appears is how you end up with a lake of data nobody trusts. Azure provides the services around that chain. Ingestion from approved sources, storage for event history, integration between systems, identity controls, monitoring, secure access patterns, the exact services depend on what you already have. I wouldn't start with a preferred product list. Start with the path, a fact needs to travel. A machine event enters through an edge gateway. An MES event arrives through an API, a database extract, or a message interface. ERP data comes through a managed connector or an agreed export. The point is to preserve source, event time, and the context needed to interpret each record later. If you lose those details during integration, the report may look clean while the improvement team loses the ability to ask where a number came from. Microsoft Fabric becomes useful once data from those sources needs a governed shared home for engineering work and analysis. It brings data preparation, storage, and analytical models closer together, which helps when multiple teams need to work from the same definitions instead of building separate copies of the same production logic.

1:19:48That does not mean Fabric magically resolves factory disagreement. A platform can store a resource hierarchy, but it can't tell you whether a resource name means a full line, a station, or a shared fixture, unless someone who knows the process defines it. It can calculate a change over duration, but it can't decide whether the endpoint should be first cycle, first accepted unit, or stable output. The factory supplies the meaning. The platform keeps that meaning usable across the data path. A typical setup builds a curated improvement model around the question at hand. It links the planned order from ERP to the executed operation in MES, then relates that operation to machine events during the same production window. Quality outcomes, maintenance notes, and operator observations sit alongside those facts when they apply. Now the team can move through the evidence without rebuilding the join every week. Power BI sits near the end of that path. It returns role-based views to the people who need to make decisions. A supervisor looks at open losses during a shift. A process engineer reviews trial results, a planner checks schedule effects, an improvement team compares runs before and after a countermeasure. Each group needs a different level of detail.

1:20:49One shared model supports those views when the definitions stay consistent. That consistency matters more than visual polish. A clean report with unclear logic just speeds up disagreement. A simpler view that lets a team trace a number back to the order, event, and decision behind it supports much better improvement work. Same principle applies to alerts and automation. A workflow can notify the right person when a condition crosses an agreed threshold or when a trial reaches a review point. But the trigger has to connect to a known response. If an alert arrives and nobody knows what to check who owns it or whether production can act safely, it becomes just another message people learn to ignore. Factories already have enough of those. Microsoft tools handle the platform work, secure data movement, storage, governed access, engineering workflows, analytical models reporting. Specialized manufacturing systems continue running execution, controls, quality maintenance, and scheduling where they belong. The Lean team still decides what lost to study. Production still decides whether a new method works in real conditions. OT still protects the equipment, IT still keeps the data path supportable. That division keeps the architecture honest.

1:21:50When these roles fit together, improvement work gains a record that reaches from the shop floor to planning without turning the factory into one giant reporting project. But a report, even one built on good data, can't run PDCA by itself. That still takes people, while dashboards don't create improvement. A dashboard can show a loss very clearly. It can show that change over time rose, that rejects increased after a restart or that orders waited too long between two operations. But it still can't tell a team what to try next, because a chart doesn't form a hypothesis, run a controlled test, or decide whether the result is safe enough to standardize. That distinction gets lost when a plant invests in reporting. The reporter arrives faster, the numbers look more consistent, and people understandably feel they've gained control. Then the same issue appears in the next shift meeting, except now everybody can see it in nicer colors. Visibility helps. It isn't improvement. Consider a line with frequent short stops. A dashboard may show the stop count rising on one resource during a certain product family, that gives the team a useful signal, but the next step still needs people close to the work. What condition changed?

1:22:51Does the stop happen at a certain speed? After a refill during a particular sequence? Or when a specific material lot enters the process? The team needs an explanation to contest, not another tile that turns red. A report becomes useful when it sits inside a decision path. Someone sees the condition. Someone owns the first check. The team knows which evidence to review when to run a trial and when to return to the result. Without that path, a dashboard becomes a record of problems everybody noticed and nobody carried through. I've seen this pattern often. The morning meeting reviews OEE, output, scrap and late orders. People discuss the losses, assign a few actions, and move on because production needs attention. A week later, the same numbers appear again. The actions may still sit in a tracker, but nobody can tell whether they applied to the right condition or changed the process at all. Fast and refresh does not fix that. There's also a people problem hiding inside many performance reports. When a dashboard mainly compares people or shifts through output figures, it pushes teams toward defensive behavior. Someone avoids recording a short stop. Another person chooses a broad reason code because a detailed one looks worse.

1:23:51A supervisor focuses on getting the number back into range before anyone understands the cause. The report then measures the response to the report. Lean should help people expose problems safely. That means a view needs enough context to support a conversation about process conditions, not just a rank order of who appears to perform best. For a supervisor, a useful view might show the current abnormal condition, the affected order, the state of the countermeasure, and who needs to respond. For an improvement engineer, the same underlying data may need comparable runs, trial scope, and evidence before and after a change. Those are different decisions. They should not get the same report. The design question is simple. When this number moves, what action should follow? If nobody can answer that, the measure belongs in a report archive, not in a daily meeting. And when the action does exist, the view should help the team follow through. It should show whether the issue remains open, whether a countermeasure is under trial, what conditions fall inside that trial, and when the team needs to check the result, that turns reporting into part of the work. There is a dry but useful reality check here. A colorful OEE report can't tighten a loose fixture. It can't clean a blocked sensor,

1:24:52change an unstable setup method, or resolve a material problem between two departments. People change the process. Data helps them spend less time arguing about where to look. It helps them test whether a change held across normal production conditions. It helps them notice side effects before a local fix becomes a wider problem. But the work still happens at the machine, in the shift hand over in planning and maintenance, and in the decisions that shape the next production run. So don't judge a dashboard by how much it displays, judge it by whether it helps the right person take a clear next step, then check the result against the condition they intended to change. That requires a working rhythm around the data. And that's where the real improvement lives, the daily improvement rhythm. A data loop doesn't do any good unless it fits the normal rhythm of the plant. If teams only look at evidence at the end of a kiesin project, they catch problems after conditions have shifted and the people closest to the work have moved onto the next fire. The routine has to match the pace of production. Not every question needs a deep dive, but every recurring loss needs a spot where somebody checks it, owns it, and decides what happens next. So start with the shift review, keep it short and close to the work.

1:25:53The goal isn't to explain every loss before the next break. It's to establish the current condition, what ran, what changed, which abnormal events happened, and whether an open countermeasure needs attention before the next crew takes over. A supervisor might sit down with the operator who saw a repeated stop pattern and check whether the current trial still applies to the next order. A maintenance issue might need a clear handoff or a quality hold requires a status check before it becomes a planning problem. The data should support that conversation with recent facts, while people add the context systems can't capture a loan. Keep it practical. The shift review should separate what needs immediate containment from what belongs in a longer improvement cycle. If a guard is damaged, follow the safety process. If a recurring setup delay shows up again, record it properly and carry it into the next review with evidence. Those are different response paths and mixing them creates noise. Next, you need a weekly review. This is where the team checks whether patterns from daily work repeat across shifts, product runs, and operating conditions. It's also where a countermeasure moves from intention into an evidence-based decision. A weekly review can ask a few simple but useful questions.

1:26:54Did the trial apply when we thought it did? Did the condition improve? Under comparable production? Did quality, delivery, or flow move in an unwanted direction? Are some shifts seeing different results? And can we explain the difference through the process rather than assumptions about people? The data model lets the team answer those questions without rebuilding the story each week. A process engineer can look at the relevant runs, a planner can explain the sequence change and maintenance can add equipment context while the supervisor confirms whether the method worked on the floor. That's PDCA in normal operations. The monthly review serves a different purpose. It should look for changes that need to become part of the system around the work, not just part of one team's memory. Standard work might need revision, a planning rule might keep causing avoidable disruption, or a maintenance pattern might point to a recurring condition short term fixes can't solve. Master data belongs in this discussion too. If the plant changes a routing, target rate, resource relationship, or approved setup method, the records that support improvement need to change with it. Otherwise, teams keep checking performance against a process definition

1:27:54that no longer matches production. The monthly review should also ask whether lessons from one area apply elsewhere. Not every countermeasure should spread plant-wide. A method that works on one line may depend on a tool, product range, or crew structure that doesn't exist on another line. Still, the factory shouldn't rediscover the same lesson in isolation. This rhythm works best when definitions stay consistent from the shop floor through plant management, even though each group sees a different level of detail. An operator needs the current condition and the agreed next step. A team leader needs open actions and recurring patterns and a plant manager needs to see whether repeated losses affect service, flow, quality, or cost. Same facts, different questions. That consistency prevents a familiar problem where the shift meeting discusses one number, the weekly lean meeting uses another, and management sees a third version after the month closes. Once that happens, people spend energy reconciling reports instead of fixing work. Data should show up where decisions get made. A production team shouldn't wait days for a report to learn a trial caused a new quality loss and a planner shouldn't discover at month end that repeated resequencing drove avoidable changeovers.

1:28:56An improvement team shouldn't need to request a fresh extract every time it wants to check an open countermeasure. The right cadence turns operational data into a working memory for the plant. It also creates discipline. A condition enters the shift review, moves into a weekly check when it repeats and reaches the monthly level when the standard planning rule or system definition needs to change. Not every issue travels that far, and that's fine. What matters is that the factory doesn't wait for a workshop to end before it starts learning again. Measures that drive better questions. Once you have that review rhythm, the next question is which measures deserve a spot in it. Factories can measure almost anything now, but that doesn't mean every number deserves a place in a shift review or a kaizen effort. A measure earns its place when it helps someone see a condition, make a decision, and check whether that decision changed the work. Start with safety and quality. If a proposed improvement shortens a setup but introduces a safety risk or raises defects, the time-save doesn't count as progress. Delivery, flow, cost, and resource use all matter, but they sit behind the conditions that protect people and product. That order keeps the conversation grounded

1:29:57when pressure builds. The next distinction is between outcome measures and process measures. An outcome measure tells you whether the factory achieved something people care about, orders, shipped on time, accepted output, lead time, or scrap. It tells you where to look, but it may not tell a team what it can change during the next shift. A process measure sits closer to the work. For a change over improvement effort, the outcome might be whether the next order starts on time and reaches acceptable output without excess loss. Process measures could include whether tools arrived before the prior order ended, whether the setup followed the method or how long the line spent in transition. Those measures give the team handles on the process. You need both. If a team tracks only setup steps, it gets good at completing a checklist while the delivery problem remains. But if it tracks only delivery, it sees the result after the chance to act is gone. A useful measure connects the two. Each measure should come with a few plain answers, who owns the decision it supports. What action follows when it changes, which system supplies the record? What does the measure mean exactly? And when will the team review it? Without those answers, measures pile up

1:30:58because someone once asked for them, the report gets longer, the meeting gets slower, and nobody wants to remove a number because it might be politically dangerous. That's how reporting turns into storage. Take a daily measure like downtime minutes. It sounds simple until a supervisor asks what action should follow. If the number includes planned cleaning, changeovers, waiting for material, equipment faults, and a line stopped because quality plays to hold, it has very little direction. You can still record total downtime, but the team needs categories that match different response paths. An equipment fault goes to maintenance, a missing material condition goes to planning all logistics, and a repeated setup delay enters a PDA cycle. The measure becomes useful when the team can move from the number to the kind of decision it needs. This also applies to OEE. OEE can help a team notice a change in availability, performance, or quality, but it should lead to a more specific question, not end the discussion. If OEE drops, ask which loss moved, where it appeared in the process, and whether the team has a response it can test. Otherwise, OEE becomes a score people defend. Leading signals can help, but they need some humility.

1:31:59A rising number of short stops may warn of a worsening machine condition, a growing cue before inspection may warn of rising lead time, and a missed pre-stage check may warn of a long change over. Those signals point to risk, but they don't predict every outcome. Teams often damage trust when they treat a leading signal like a promise. It should trigger a check, not replace judgment, and help people act earlier while they understand that production contains variation, exceptions, and conditions no single measure can capture. Use measures to ask better questions, not to pretend uncertainty disappeared. Good improvement programs need another discipline. Retire measures when they stop driving a real decision. A metric might help during a trial, but lose its purpose once the method becomes normal work, while another stays on a management report long after the process changed. Keeping it forever doesn't make the plant more controlled, it just makes attention harder to find. When a team removes a measure, it should be able to explain why. Maybe the decision moved into standard work, a different measure now gives a clear signal, or the source data no longer represents the process after a change. That's not losing information,

1:33:00it's keeping the improvement loop focused on work people can actually influence. And once measures shape real decisions, the quality of the underlying data stops being an IT concern and becomes part of how the plant runs. Data quality is part of standard work. Here's how it really works. Once a measure drives a real decision, the team has to trust the event behind it. That means data quality becomes part of normal factory work, not some cleanup project IT checks once a quarter. Think about a downtime record for a second. A line stops and someone has to pick a reason close enough that the next review can follow the right path. Choosing other keeps the screen moving, but it tells the next team almost nothing. Reason codes need to match how work actually happens. If operators can't find the right code quickly, the list is too long, the wording is unclear, or the system asks for detail nobody can know at that moment. So don't blame the operator. Study the reporting step like any other work step, ask what the person saw and what information was available, then make the choice practical. A useful reason code structure starts broad for rapid entry and allows more detail after the immediate issue passes. An operator records an equipment stop

1:34:01and maintenance later classifies the failure mode when evidence supports it. That preserves the first fact without forcing a guest during a busy recovery. The same thinking applies to timestamps. A late transaction doesn't mean somebody ignored the process. The operator might need to secure the machine, contain a quality issue, help with a change over, and only get to the mess entry after production settles. If the improvement team uses the entry time as the event time, the analysis places the loss in the wrong order. The system should capture what it can automatically and make clear what each time means. Machine signals bring their own data quality problems. A sensor can drift, a communication link can drop records, and a PLC tag can change after an upgrade while the reporting layer still expects the old meaning. The value keeps arriving, which makes the problem harder to spot. It looks like data, but it doesn't describe the process anymore. That's why checks need to run as part of the operating routine. Compare expected cycle patterns with recorded events, flag impossible sequences like accepted quantity without a related operation, check if a stopped machine reports production at the same time and review gaps after maintenance or control changes.

1:35:01These checks don't need to create a blame exercise. A data defect is a process defect. Something in the method, system interface, or definition let the record drift away from the work. The team needs to find that cause, correct it, and prevent it from returning. Picture an engineer reviewing a trial and noticing that the MES claims a line-rangering a period when everyone knows it was down. That person needs a simple path to raise the issue, attach the evidence, and get a response from the team responsible for the source or integration. If the only option is an informal message to someone in IT, the defect sits there, the next report reuses it, and people slowly stop trusting the whole model. Feedback has to travel both ways. When a data owner changes a reason code list, interface, resource name, or calculation rule, affected users need to know what changed and when. And when production sees a mismatch, the data owner needs enough detail to reproduce it. That creates a working loop between the people recording events and the people who prepare the data for review. Ownership should be clear, but it doesn't need to be bureaucratic. Production can own the practical meaning of a shift event, maintenance can own fault coding and equipment structure,

1:36:01quality can own acceptance and hold status, IT and data teams can own pipelines and technical checks, and improvement leaders make sure the records support the real problem. Each owner needs a response path. Standard work should include the data touchpoints that matter. When does a crew confirm an order start? Who records a quality hold? How does a supervisor correct an entry error without destroying the audit trail? And what happens when an automated signal disagrees with the floor process? Those questions belong in the work method. You don't need perfect data before you start improvement. Waiting for perfect data means waiting forever. But you do need enough discipline to know where the data is weak, detect when it changes, and avoid treating a doubtful record as hard evidence. That is a much more useful standard. When teams treat data defects with the same seriousness as process defects, the improvement loop gets stronger over time. If they don't, every PDCA review eventually returns to the same old problem. They don't know if they're looking at the process or just a record of what the systems happen to capture, start small without building another silo. You don't need to solve the entire data problem before you improve anything.

1:37:02That approach creates a large program, a long backlog, and too many meetings about the future model. Instead, pick one loss that repeats, choose something that affects a real production decision, has a team that can own the response, and draws on data you can reach without unsafe connections or bypassing trusted systems. A recurring change over delay, cue before inspection, or repeat quality hold works well because the plant already feels the consequence. The use case needs an accountable team. That means a supervisor, engineer, planner, quality lead, or maintenance lead can say this condition belongs to us, and we'll decide what to test when the evidence points somewhere. If nobody owns the decision, data work becomes a reporting exercise with no path back into the process. Keep the first data model small too. You may only need a work order, operation, resource, product family, time range, loss event, and the outcome that tells you if the condition improved. Add quality results or machine state only when it helps answer the question. The model should support a decision, not a committee's wish list. That restraint matters. A large enterprise model becomes a way to postpone the work. People debate hierarchies, integrations, and edge cases while the same loss continues.

1:38:03Those discussions have their place, but the first loop needs to prove that connected evidence changes how a team works. Start with the minimum shared language. For example, if the team studies change overs, agree on what marks the start and end before anyone builds a report, which product transitions count, and whether the result includes first acceptable output, stable running, or both. Then connect the records that can support those definitions. This may involve a scheduled MES extract, a controlled feed from machine data, and order context from ERP, plus a simple way for the team to attach an observation to a specific event. The technical design should be supportable, but it doesn't need to imitate a full enterprise platform on day one. Prove the work loop first. The work loop needs to answer, can the team identify the condition from shared evidence, record a countermeasure with clear scope, review production after the change, and decide whether to keep, adapt, or reverse the method. If those answers stay vague, adding more data won't fix the problem. A good first use case creates patterns you can reuse. The same naming rules support the next loss, the same source ownership approach helps another line,

1:39:04and the same way of recording a trial and its outcome becomes a normal part of improvement work rather than a custom process each time. Reuse the pattern not necessarily the report, different areas need different evidence, maintenance driven problems need fault history and operating conditions, flow problems need order movement and QAGE, quality problems, need inspection results, material lots, and process settings. Fourcing all of them into one early report creates confusion. What should grow is the shared foundation, common identities where they matter, traceable sources, clear definitions, and a known root from condition to action. That gives you an architecture that actually scales because each new case adds to a working method instead of leaving behind another isolated dashboard. Watch for pilot perigotry. That's when a team builds a useful view, demos it a few times, then carries on exactly as before. The dashboard survives because people like it, but the improvement routine disappears because no meeting changed, no owner accepted a new response, and no standard work captured the lesson. The report becomes a museum piece. Avoid that by setting the operating routine before building too much.

1:40:05Decide where the team will review the evidence, who can start a trial, and how a result becomes a work instruction, planning rule, or closed action with a recorded reason. Those decisions turn data into part of the job. Small doesn't mean casual. It means narrow enough that people can see the full path from a repeating loss to a tested response and back to the production record. Once that path works, you have more than a pilot. You have a pattern the next improvement team can use, digital twins and knowledge graphs. Once the first improvement loops are working, some questions start crossing more of the factory. A change of a delay might tie back to a tool, a maintenance record, an approved recipe, a product rule, and several orders waiting behind it. Simple tables can handle some of that, but eventually the production story gets lost between the joins. A digital twin helps when you need a model of the things in the factory and the states those things move through. Think of a line, a machine, a tool, a batch, or a work order, as an entity with an identity, properties, and a history. The point isn't to build a virtual factory for its own sake. For continuous improvement, a twin gives the team a way to ask about an entity in context.

1:41:07This machine ran this operation. This operation used this recipe. This batch came from this material lot. This work order moved through this resource during a particular shift. That context can include current state, but it can also include history. A machine might currently report available while its recent record shows repeated short stops after a maintenance intervention. A tool may sit in the staging area, but the system can also show whether it passed inspection and whether it fits the product plan next. Those are different kinds of facts. And the improvement question needs both. The knowledge graph goes further into the relationships. It describes how product, process, resource, people, documents, skills, constraints, and decisions connect. Instead of treating each source as a separate list, the graph lets you follow the links between the things that affect one another. That matters when the question begins in one system and the explanation sits somewhere else. Picture a machine fault during a scheduled production run. The first question may sound simple. Can we move the work? But a useful answer needs more than the machine state, which orders now face risk, which other machines can run that product, which tool and recipe do they need? Are qualified people available? Does the alternative resource carry a quality restriction?

1:42:08Or is it already committed to another order? A graph can hold those relationships in a form that people and applications can query. Now let's be clear about what this isn't. It's not a replacement for me as ERP, maintenance, or quality systems. Those systems still record and control the work they own. The twin or graph provides a shared context layer across them, especially when a team needs to reason about dependencies that no single system describes fully. That distinction keeps the architecture practical. An MES may know that an operation stopped. A maintenance system may know the acid work history. ERP may know the due date and planned route. A knowledge graph can connect the stopped operation to the resource, the affected order, the qualified alternatives, and the constraints that rule out some alternatives. Now the improvement team can ask a better question. Not just why did this machine stop? It can ask, which process condition created the largest flow risk and which countermeasure can we test without breaking another rule? That is a much closer fit for real factory decisions. The same approach helps with recurring lean problems that sound local but aren't. A quality defect may appear at final inspection, yet the cause could relate to a material lot,

1:43:10a tool condition, a process setting, and a certain route through the plant. A normal report can show correlations. The relationship model helps the team trace the path it needs to inspect. Still, I would be careful here. Digital twin and knowledge graph projects can become very large, very quickly. People start modeling every asset, every document, every signal, and every possible relationship because a complete virtual plant sounds impressive in a steering meeting. Production rarely needs that on day one. Build the context that supports a real improvement decision. If the problem concerns change over loss, model the line, the product transition, the tool set, the setup method, the people involved, the relevant machine states, and the quality condition after restart. Leave the rest until a real question demands it. This also means the model needs ownership. Someone must decide what a resource relationship means when a line changes. Someone must update approved alternatives when a product qualification changes. Someone must manage the links between work instructions and the operation where they apply. A graph filled with old relationships can mislead a team just as easily as a spreadsheet filled with old numbers. The useful test is simple. Can this model help people understand a condition

1:44:11they couldn't explain from isolated records? Can it show the constraints around an action before the team tests that action? And can people trace its answers back to the systems and process rules behind them? If not, it may be an interesting model, but it isn't yet part of continuous improvement. When the answer is yes, the factory has something more than connected data. It has context that can carry lessons across shifts, systems, and changing production conditions. Industrial AI in the improvement loop. Once a factory can connect an improvement question to reliable context, industrial AI becomes more useful. Not because AI replaces lean thinking, but because it can help a team find patterns that would take too long to spot by hand. Keep the order straight, first define the loss, then connect the records around it, then apply AI to a specific question. Otherwise, you just automate confusion. Think about recurring short stops on a filling line. The MES may record the stop category. Machine data may record alarms, speed, and timing. Operators may add short notes at shift handover while maintenance records describe work completed on the asset. A person can inspect all that information, but not every day and not across every combination of conditions.

1:45:12AI can group similar event sequences and help the engineer find clusters worth checking. Maybe a set of stops tends to appear after a certain cleaning cycle. Maybe another group follows a specific material change. That isn't a root cause. It's a lead. The team still needs to go to the work, inspect the machine, speak to operators, and test a hypothesis. AI can narrow the search. It cannot confirm that a sensor is dirty, a guide rail sits out of position, or a work method changed during a busy shift. Physical causes still need physical evidence. Document search is another practical use. Many plants have work instructions. Past A3 reports maintenance notes, quality alerts, supplier documents, and old corrective actions spread across folders and systems. The information may exist, but finding the right record during an active problem can take longer than the team has. Generative AI can help search that body of approved content in plain language. An engineer might ask, show past countermeasures related to startup defects for this product family and this line. The system can retrieve relevant documents, point to previous trials, and bring back known constraints. It can help the team avoid repeating

1:46:13an experiment that failed last year for a documented reason, but the source matters. A useful answer needs to cite the procedure, action record, or maintenance note it drew from. If the system produces a confident paragraph without a trace back to approved records, the team has no reason to trust it. In manufacturing, a plausible answer can be more dangerous than an obvious gap, especially when somebody acts on it. AI can also support anomaly triage. It can compare current event patterns with prior runs and flag production that behaves differently from a known range. Perhaps cycle time begins to drift, perhaps quality loss follows an unusual pattern after a recipe change. Perhaps one sequence of operations creates more weighting than comparable sequences. That can help a team decide where to look first. Prediction fits into the loop too, but prediction needs careful language. A model may estimate that a production order faces a higher risk of delay based on current QA, resource state, material status, and similar past conditions. It can estimate risk, it cannot know the future with certainty. And a risk score isn't a production decision. The planer still needs to decide whether to re-sequence an order, add capacity,

1:47:13wait for an inspection result, or leave the plan unchanged. Each option carries constraints that a prediction model may not capture fully, such as a customer promise, a qualification rule, a tool conflict, or the need to protect another product. Prediction tells you where pressure may build. It doesn't resolve the trade off. Optimization handles a different type of question. It evaluates possible actions against defined constraints, such as resource capacity, sequence rules, due dates, materials, tools, and qualified labor. If a line stops or an order moves late, optimization can compare feasible alternatives and rank them against an agreed objective. That work differs from text generation. A generative AI tool can explain a schedule option in plain language. It may help a planner ask better questions or retrieve the rule that limits a resource. But it should not invent a production schedule based on a conversational prompt and then send it into execution. The schedule needs formal constraints, controlled inputs, and a way to validate the result. Human review stays in the loop throughout. A production engineer needs to judge whether a detected pattern makes process sense.

1:48:14A planner needs to approve a proposed schedule change. OT teams need to protect operating limits. Quality needs to confirm that no recommendation bypasses a control that protects the product. AI should support those decisions, not quietly take them over. This also means recommendations need a record. What data did the system use? Which conditions triggered the suggestion? Which source documents shaped its answer? Who reviewed it? And what action did the team take? If an improvement trial changes the process, the factory needs to know why. The best use of industrial AI in continuous improvement is often modest. It helps teams find related evidence, sort large event histories, spot unusual conditions, and retrieve what the factory already learned, but forgot. That is enough to change the pace of a PDCA loop. But AI only earns a role when its output stays tied to traceable facts, clear process limits, and people who understand the consequences on the floor. Limits, trade-offs, and failure modes. Before you plug in another source or add another model, start with a simple question. How often does the decision actually happen and what changes based on it? A monthly review of recurring scrap works

1:49:14fine with data prepped overnight, but a line supervisor responding to a stop needs facts in minutes, not hours. Real-time data isn't automatically better data. I've seen teams ask for second-by-second signals just because the tech can collect them. But if the decision happens once a week, that volume adds cost, noise, and support work without moving the needle on what actually matters. Use the speed the work needs, not the speed a demo can show. The same logic applies to integration effort. Connecting an ERP order to an MS operation might need work on identities, time rules, access, error handling, and source ownership. If you bring machine events into that question, you add an edge connection or t approval and checks to prove the data still means what the team thinks it means, that work pays off when the loss repeats and the decision effects production often. For a rare issue with a simple manual check, it probably won't. Here's where many data programs lose their way. They treat every data gap as a technical defect that needs a permanent interface, even when a structured manual review would answer the question safely and cheaply. Automation should remove repeatable friction, not become a hobby for architecture teams. Be honest about the trade off. More connected data also creates false precision.

1:50:16A report might show change over duration down to the second, which looks convincing, but the result can mislead if the system can't distinguish a normal cleaning step from waiting for a missing tool, or if the product transition changed halfway through the period. Precise timestamps don't create a precise explanation. Weekmaster data causes similar problems. If a resource hierarchy no longer matches the shop floor, analysis ends up grouping events under the wrong line. If product families change, but the old grouping stays in the model, a comparison looks like process variation when the products simply aren't comparable. The data path needs change control because the factory keeps changing. Then there's the tension between local freedom and plant-wide standards. A production team needs room to adapt an improvement method to a machine, product or crew structure that only exists in its area. If every decision waits for corporate approval, improvement slows down, and people go back to their own spreadsheets, but complete local freedom creates a different problem. Every line invents different names for the same loss, different start and end points for the same event, and different rules for checking a countermeasure. At that point, the plant can't compare learning across areas.

1:51:18You need standards where the work has to connect. Common identities, event definitions, access rules, and evidence records should travel across the plant. The details of a local setup method can stay local until a team has proof another area can use it. That balance lets people improve close to the work, without turning the whole factory into disconnected islands. Security and privacy need the same practical approach. Production data can reveal more than machine state. It may include operator names, shift assignments, customer details, recipes, quality records, or maintenance notes. Not everybody who can see a dashboard should see all of that context. Access should follow the decision people need to make. Cybersecurity matters too, because an improvement data path can cross the boundary between operational networks and enterprise systems. That path needs controlled connections, clear identities, logging and separation between data collection and machine control. A reporting project should never create a route into a controller nobody intended to expose. OT teams are right to ask hard questions here. There are failure modes on the human side as well. If data arrives late, teams may abandon it and return to memory. If a report contradicts the floor

1:52:18and nobody fixes the cause, trust falls fast. If managers use improvement data, mainly to judge individuals, people adapt the records before they adapt the process. You can't govern your way out of that. The system needs a clear route for challenge and correction. When an operator, engineer, or planner sees a number that doesn't fit the work, they need to raise it, trace it to the source and get a response. That's part of a credible improvement loop. So keep the ambition tied to the decision, collect enough context to test the countermeasure, protect the line, protect the people in the data, and don't confuse a larger architecture with a better learning process, a practical starting sequence. So where do you start if your improvement work still lives mainly in workshops, action trackers and people's memory? Don't begin with a platform program, begin with one repeating loss that already affects a real production decision that gives the worker boundary and gives the team a reason to care when the data says something different from what they expected. Choose a loss that returns often enough to study. It might be a change over that keeps missing its planned window, a recurring queue before inspection, or a quality hold that disrupts the same product flow every week.

1:53:21Pick something people already feel. You also need a team that can act. A data project without a production owner becomes another report waiting for someone else to do something. The supervisor, engineer, planner, quality lead and maintenance contact don't all need to attend every discussion, but somebody needs authority to test account a measure and decide what changes afterward. Then map the current PDCA routine as it really works today. Ask where the issue first appears. Who notices it? What happens in the next shift meeting? Where does the action go? When does anybody check whether it worked? You may find that the plant has a plan step and a do step while check happens only when somebody remembers to ask. That's a useful finding. Next, list the measures and facts the team already uses. Include the spreadsheet, the MS record, the machine event, the quality entry, the planning note, and the shift handover comment. Don't judge the sources yet. You're trying to understand how the team currently builds its explanation of the loss. People often discover that each source answers a different part of the same question. After that, define the missing context. If the team studies change over delay, it may need to connect the actual start and end of the setup with the product transition, the resource, the order sequence, and the first accepted output.

1:54:23If it studies a queue, it may need release time, operation status, inspection hold, material state, and how long each unit waited. Keep the question narrow enough to test. Before anyone builds a dashboard, agree on the terms. What counts as the start of the event? What counts as the end? Which source owns the event time? How will the team separate a normal condition from an abnormal one? These sound like small questions until two reports give different answers in a review. Definitions come before calculation. Then connect the smallest useful set of inputs that may include ERP order context, MES execution data, selected machine events, quality results, and a short human observation. It doesn't mean you need full plant connectivity, every sensor tag, or a large enterprise data model approved by every department. You need enough evidence to check the hypothesis. Build the first view around the decision, not around the available data. The team should be able to find the event, see the relevant condition, record the countermeasure, and compare the result with a defined baseline. If the view can't support those steps, it may still be interesting, but it doesn't support PDCA. That sequence keeps technology in its proper place.

1:55:23Run the countermeasure in normal production conditions where possible. Record its scope. Note which products, shifts, resources, and operating rules applied. Then review the result against comparable runs, not against a vague memory of how the line usually behaves. A good trial leaves a trace. If the evidence supports the change, turn it into standard work, a planning rule, a maintenance task, or another controlled update to the process. If it doesn't, record why the team stopped or changed direction. That record matters because the next team may face the same condition later. Failure that teaches something isn't wasted work. Once the first loop works, reuse the method. Carry forward the naming rules, source links, ownership model, review routine, and way of recording evidence. The next use case will need different facts, but it shouldn't need to invent a whole new way to learn from them. That's how the architecture grows through work people already need to do. Avoid the temptation to announce a factory-wide improvement data program after the first success. Let the pattern earn its place. Expand when another team has a repeating question and accountable owner and a clear decision that connected evidence can improve. Otherwise, you risk scaling the reporting

1:56:24before you've scaled the learning. Improvement must remember. A Kaisern event can create real focus when people step away from daily pressure, study a problem together, and walk away with good ideas. But here's the catch. If that event loses contact with operating evidence after the workshop ends, the factory forgets what it learned. PDA gets much stronger when the problem, the trial, the result, and the next decision stay tied to the actual order, process, resource, time, and quality condition. When that happens, improvement doesn't depend on who showed up to the session or which spreadsheet survived in a shared folder. The whole plant can learn across shifts, better data doesn't mean collecting everything. It means shared definitions, traceable records, and enough context for people to honestly test a change. It means the operator observation, the MES event, the machine signal, the quality outcome, and the planning consequence can all form one explanation when the problem needs them to. Without that, every workshop starts the same way. People arguing about the facts. If you're working through this in your own plant, I'd like to hear how you connect Lean, Kaiser, and PDCA with MS, ERP, and Shopflow data.

1:57:27Let's compare notes on LinkedIn.