2026-11-17
The Hidden Production Cost of the Wrong Product Mix

Show notes
A product mix that looks profitable on paper can quietly drive up production cost on the shop floor. This episode of M365 FM looks at the hidden costs of running the wrong product mix and how better data makes them visible. Hosted by Mirko Peters. Become a supporter of this podcast: https://www.spreaker.com/podcast/m365-fm-microsoft-365-azure-cloud-power-platform-ai--6704921/support.
Host: Mirko Peters
Guests
Transcript
Read the full transcript
Speaker 1: I've watched production plans fit neatly inside weekly machine hours, then fall apart before the first shift even ends. That sounds like a contradiction, because the capacity report shows open time on every major work center, while the factory is drowning in late orders, overtime, expedites, and people negotiating priorities at the morning meeting. Here's the real problem. Total available hours don't describe the work you plan to run at all. They don't tell you which route each product follows, which jobs need a specific order, who is qualified to run them, whether the right fixture exists, or whether material actually shows up when the schedule needs it. Capacity is a screen, not a promise. If you want to know whether a product mix is feasible, test the actual orders against the actual rules of the factory before you release the work, not after the queue starts growing. Let's leave the aggregate report for a moment and step into one hypothetical factory week, a factory with capacity on paper. Picture a plant that produces two broad types of product. One family runs in high volume with stable parts, large batches, and a rhythm the team knows well. The other family has more variants. Customers ask for different materials, finishes, inspection steps, and smaller batch sizes. Both families share equipment at a few points in the process. Now imagine the planner opening the weekly capacity report on Friday afternoon. The main work center's showroom. The machining area isn't full. Assembly still has hours. The report tells a reassuring story, at least at first. Then sales presents a request from a customer for more of the high-variant family. The order looks attractive commercially. and the capacity report appears to support it, so the demand gets accepted and the work lands in the next production week. Nobody acted carelessly here, sales used the information available, the planner used the planning model in the system, and the report did what reports do. Added up planned load and compared it with calendar hours. On paper, the plant can take the order, then the production supervisor sees the released work and pauses. The high-volume products can run through a broad set of standard operations, but the high-variant products can't. They need a particular finishing cell that also handles existing orders with early due dates. Several of the new variants require a specific fixture, and there are fewer fixtures than machines that could technically process the part. One machine may look available, but the process isn't. The supervisor also knows that the specialist who sets up that cell only works the day shift. A night shift team can operate the equipment once the job is stable, but they can't take every new variant from one setup state to the next. That knowledge may sit in a shift plan, a skill matrix, or in the head of the person who has kept that cell running for years. It almost never appears in the green capacity bar. Now consider two possible weeks. In the first week, the plant produces mostly standard high-volume work. The total planned hours fill a large part of the plant, but the order spread across machines and shifts fairly evenly. Material arrives on time, the shared finishing cell sees a manageable sequence, and the plant feels busy but actually runs. In the second week, the total number of planned hours stays almost the same. and revenue might even look better, but demand shifts towards smaller batches and more variants with tight due dates. The shared sale now sees more setups, the fixture becomes a constraint, and inspection gets a burst of work from the same family at the same time. The capacity report can show a similar total in both weeks, yet the factory experiences two completely different loads. This is the point where teams get pulled into the usual loop. Production asks why sales accepted more work, sales asks why the plant showed capacity, and the planner spends the week moving orders, checking who can run which machine, calling suppliers, and trying to protect the orders that already carried a customer promise. Then someone creates a second spreadsheet. That spreadsheet may contain the facts the formal planning process missed, fixture locations, setup notes, operator limits, exceptions by product code, and a list of jobs nobody should release together. It can help for a while because the people using it understand the plant. Still, the factory shouldn't need a private rescue system every Monday morning. The planning mistake isn't that someone looked at capacity. You do need capacity data. The mistake comes when a total number turns into a delivery commitment without testing whether this particular mix of orders can move through this particular factory during this particular week. Think about what the planner is actually trying to answer. Not, do we have enough hours somewhere in the plant? The real question is whether these orders, with their routes, due dates, materials, people, tools and operating rules, can flow through the plant without breaking commitments you already made. That question needs more than an aggregate total. It needs the production context behind the hours. The aggregate capacity trap. Here's the problem most manufacturers don't talk about. Aggregate capacity reports. A total hours report still works as a rough screen. If demand needs way more hours than the plant calendar shows, you caught a problem early. But that's all it is, a rough screen. The real trouble starts when that first screen becomes a production promise. Total hours blend together work that places very different demands on different parts of the factory at different times under different operating rules. Think of it like this. A planning system holds an average time for a product family. That average works for rough capacity checks, but the orders within that family don't behave like the average. One variant spends most of its time in machining. Another moves through machining quickly but needs more time in test. A third needs an extra inspection step because of a customer or material rule. When you average those paths into one load number, The total looks sensible, while a small group of resources carries more work than it can complete. Averages are calm, but production weeks rarely are. In practical terms, this applies to the calendar too. A work center may show 40 available hours, but those hours aren't equal. Some sit on a shift without the person approved to perform a setup, some sit after a maintenance window, and some sit in fragments too short to run a batch economically. Others overlap with cleaning, inspection, or a material delivery that hasn't cleared quality yet. The report counts time, but the factory has to use time. That sounds obvious, but it disappears when capacity gets reduced to a percentage. A work center at 80% load looks comfortable, but if the remaining 20% falls on the wrong days, comes in short gaps, or needs a skill and a tool that aren't available together, it doesn't protect the schedule. Usable capacity means time that a specific order can actually consume. That includes the machine and the conditions around it. The job must be allowed to run there. The right setup must fit inside the available slot. The required inputs must exist when the work starts. and the next step must not create a blockage that turns finished parts into waiting inventory. A plan can fill nearly all available hours and still run well when its work spreads in a way the factory can absorb. The root demand lands on the right resources, the order sequence limits avoidable disruption, and the work reaches shared operations at a manageable pace. A lower-loaded plan can fail when its mix concentrates demand in one narrow area. That's why a partly-loaded plan can create more pressure than a fuller one. The plant may have idle people or machines in several places while one constrained process works late every day. Those idle hours don't help if they can't perform the work that blocks shipment. You can't ship capacity from an idle machine to a busy one. This is also why broad capacity reports can create the wrong conversation. Someone sees a green bar and asks production to explain why delivery risk still exists. Production then has to translate real operating rules into an argument against a number that looks neat and official. That's not a fair fight for the supervisor. Here's the real challenge. The green bar rarely changes a fixture, doesn't qualify an operator, and doesn't turn a restricted alternate route into an approved process. It just tells you that a sum of planned hours stays below a sum of calendar hours. Useful? Yes. Complete? No. I'd treat aggregate capacity as an early warning tool, not as proof that a plan will run. It helps you decide where to look next. It can tell you that a demand scenario deserves attention, or that the factory needs a closer check before sales commits to a date. Then the planning question has to become more precise. Instead of asking whether the plant has enough capacity in total, ask whether the factory can turn this exact set of orders into completed products on the required dates, while following the rules it must follow. That brings us to a distinction that clears up a lot of confusion. Capacity is a limit at a resource. Feasibility is the result you get when the whole system tries to run. Capacity is a resource limit. Feasibility is a system result. Let's put clear names on two ideas that planning teams often blend together. Capacity is the time a resource can provide in a defined period. A machine may have scheduled hours, an assembly line may have staffed hours, and a test station may have a calendar with open slots. That's capacity, and it matters because no plan can consume more time than a resource can provide. Feasibility asks a different question. Can this exact set of orders complete through the factory, on time, under the operating rules that apply? That result depends on capacity, but capacity alone can't produce the answer. Think of a production order as a chain of events rather than a block of hours. It needs to start at the right operation, it needs material, it needs a resource that can perform the work, and then it needs to move to the next operation at a time when that next step can accept it. One resource may have time available, while the order still can't move, because manufacturing doesn't run as one large pool of interchangeable hours. It runs through linked resources, each with its own calendar, rules, limits, and place in the order flow. A job released early can wait, a job released late can interrupt another job. and a job move to an alternate resource may create a new issue further downstream. The result emerges from the system. I think this is where the phrase available capacity starts to cause trouble. It sounds like an answer, but it's really one input. You might know that machining has time next week, but that doesn't tell you whether the work can arrive at machining on time, whether the required setup can happen, or whether a downstream operation can finish the order before the promised date. A feasible plan needs all of those events to fit together. Now here's where it gets interesting. Product mix changes the fit. It changes where demand lands, when it lands, and how the factory must process it. Two demand plans can contain the same amount of work in broad terms, yet put very different pressure on the factory because their orders use different routes and arrive at shared resources in a different sequence. Picture a plant with a forming process, a machining area, and final test. One group of products spends little time in forming but needs long testing. Another group spends more time in forming and moves quickly through test. If demand shifts from the first group, To the second, the total planned labor and machine hours may barely move, but the factory changes. Forming can become the limit on shipment even while test has unused time. Then a commercial team sees spare test capacity and wonders why more orders can't ship. The answer isn't in test. It sits earlier in the flow. That's why an individual resource can look healthy while the plan fails as a whole. Feasibility comes from the relationship between resources, order routes, and time. It isn't a status field you can calculate by adding up the hours from a few work centers. There's also a timing issue that broad planning often loses. Capacity appears in periods such as a week or a month, but orders don't experience the factory that way. They need a sequence of finite slots. An order that needs four hours at one process and two hours at the next may fit inside the weekly totals, but still miss its date if those slots occur in the wrong order. Time has direction in a factory. That's why finite scheduling matters. Finite means the planning logic respects the actual amount of work a resource can perform at a given time. It doesn't place five jobs into the same hour because the weekly total still looks acceptable. Instead, it places work into a sequence and tests the consequences. The rules need to resemble real operations. They don't need to model every small detail on day one, but they do need to cover the rules that change a decision. If a resource can only run one order at a time, the model needs that rule. If an operation must finish before the next one begins, the model needs that too. If certain jobs cannot run in certain windows, pretending otherwise only produces a neat but unusable plan. A finite plan won't remove trade-offs. It exposes them earlier. Maybe the factory can accept the new demand, but another order moves later. Maybe the date holds, but production needs a different sequence. Maybe the order can't fit without extra capacity, a change in scope, or a commercial conversation before the customer receives a promise. Those are planning decisions, and they should happen before release, while people still have choices. So capacity tells you what one resource might provide. Feasibility tells you whether the connected factory can complete the work. To see why that difference becomes so large, let's follow one product through the plant. Product mix means more than product volume. Here's the problem most manufacturers don't talk about. When people say product mix, they usually mean a simple sales split. How many units of A, B, and C do we expect to sell? That view has its purpose for demand planning, revenue forecasts, and broad supply plans, but it won't tell production what the week will actually feel like on the floor. For production, mix means the real combination of work arriving at the factory. Product families matter, sure, but so do variants, batch sizes, and due dates. Two plans with the same unit count can land completely different burdens on the people, equipment, and process steps that turn those units into shipments. Take two orders that look almost identical in a commercial system. Same base product code, same family, similar raw material. One might run in a standard batch with a known process. The other needs a special grade of material, a different surface finish, a customer-specific test, and a smaller lot size. Commercially, they're close relatives, but operationally, they behave like different products. The first order flows through familiar work with little interruption. The second triggers extra preparation, different work instructions, more checks, and more handoffs. It also consumes machine time in a different pattern, and that's often where the schedule starts to bend. Batch size changes the answer too. A large batch spreads setup effort across many units, while a small batch eats nearly the same preparation time but produces far fewer parts. When the mix shifts toward short runs, the factory doesn't just produce a different number of units. It spends more of its week switching from one condition to another. That change can sit completely outside a normal volume forecast. Imagine demand stays flat at 10,000 units. One week, Most of those units come from a handful of standard products with stable batches. The next week, customers order the same total across many more variants, each in smaller quantities with tighter delivery windows. A volume chart barely moves, but the production burden changes a lot. That's why product mix needs a definition that matches the actual work. It includes which products the factory must run, but also which variants, which lot sizes, which required dates, and which process conditions come with them. Leave those details out, and you're not looking at a production mix anymore. You're looking at a sales total, And sales totals don't run machines. There's another split that creates friction between functions. Finance and sales tend to look at revenue mix. They want to know what customers buy, what each product earns, and which family supports the commercial plan. That view is fair, but production needs an operational mix. The operational view asks different questions. You want to know which work centers receive the demand, which steps need extra time, which products interrupt stable flow, which orders must run close together because of dates, materials, or process rules, and where a product creates work that the sales order never makes obvious. A product with modest revenue can consume a large share of scarce process time. Another product may produce strong revenue and still fit easily because it runs through a stable route with predictable batches. Neither view is wrong, but trouble starts when one view tries to answer the other team's question. I've seen this happen in planning discussions where someone says, wait, we only added a small amount of demand and they may be right in units or revenue. But if that demand lands in a narrow product family with special conditions, The added work can reshape the entire production week. The unit count isn't the unit of difficulty. Think of mix as the fingerprint of demand on your factory. It tells you where the work goes, how it must be processed, and when it needs to move. Without that fingerprint, capacity planning stays too broad to expose the pressure points that matter. Once you start looking at mix this way, the next question becomes much more practical. How does each product actually travel through the plant? Routing variation creates uneven load. A routing tells the planning system how a product moves through production. At least that's the intent. It names the operations, their sequence, the work centers involved, and usually a standard time for each step. But products in the same family often don't share the same route all the way through. Take a factory producing machine components. Most parts start in the same cutting area and pass through the same wash process, but after that, one group moves directly to inspection, another needs a special coating step, and a third needs a second machining operation before moving on. They share the start, then split. That split changes the load pattern. If demand moves toward the coated parts, the cutting area may still look fine because its work stays spread across several machines. The coating process receives the extra demand all at once and it may only have a small number of approved resources. The plan can look balanced at the plant level while one operation carries too much work. This happens because a broad capacity model often treats routing as a standard path. It groups products by family, applies an average cycle time, and spreads the result across a work center. That approach can work for a rough long-term view, but it becomes risky when planners need to decide whether actual orders can run next week. Orders don't run on averages. Each order carries its own routing conditions. A variant may require a different machine because of its size, another may need a process approval that limits where it can run, and one alternate route may exist in engineering data, but only for a specific material grade, or only after a certain quality check. That alternate route isn't spare capacity until those conditions are true. I see this a lot, where a planning system marks several machines as capable of an operation. Technically the list may be correct, yet one machine lacks the right program, another needs a specific tool, and a third can run the part only with an operator who isn't available on that shift. So, the routing says three options, but production may have one. The same issue appears when a product moves through a shared resource for only one short operation. A planner focuses on the total time the product consumes across the whole plant, but that short operation can still decide whether the order ships. Imagine an order that needs many hours across several broad machining resources, followed by a brief precision grinding step. The machining work spreads well, but grinding doesn't. If several high-demand variants all need that same final step, the grinding queue grows even though most of the factory still has room. A short root step can control a long delivery promise. That's why Routing variation needs to sit at the level of product, process, and resource. You need to know which specific operation and order requires, which resources can perform it, and what conditions turn an apparent option into a real option. Think of it like a road network. Two vehicles leave from the same warehouse and travel most of the way on wide roads. Near the destination, one must cross a narrow bridge. If too many loads require that bridge, open roads elsewhere don't remove the delay. The bridge is part of the route. A reliable planning view needs those route relationships in usable form. The product must link to its process steps, each process step must link to approved resources, and those resource links need the rules that matter, not just a broad capability label entered years ago and never questioned. That sounds like data work, because it is, but it isn't data work for its own sake. It lets the planner ask a much better question. If we accept these orders, which exact operations receive the demand, and where does the route stop being flexible? Sometimes the answer shows a genuine problem, like a narrow process carrying more demand than it can handle before the due dates, other times, It exposes a root option that production can use safely, provided the right conditions are met. Both outcomes beat discovering the constraint after work has already started. The rooting also needs to reflect change. Engineering may approve a new machine, remove an old tool, alter an inspection requirement, or change a process sequence. If that change reaches the shop floor but not the planning logic, the plan starts from an old version of the factory. People then compensate manually, usually under time pressure. You don't need a perfect model of every movement before you improve mix planning. Start with the root differences that repeatedly create late work, schedule changes, or arguments about where an order can run. Those are usually the points where the formal routing and the operating reality have drifted apart. Once those links exist, you can stop looking at the plant as one average load and follow the work toward the resource that actually limits flow. The bottleneck moves with the mix. Start tracing the actual routes through your plant and a different question comes up. Right now, which resource is really controlling how fast finished orders get out the door? That resource is your bottleneck for the current mix. Not necessarily the biggest machine, the most expensive equipment, or the work center with the lowest OEE. It's the part of the flow that limits how many completed orders you can ship right now. And here's the thing. That bottleneck can move. Picture a plant that makes two families of components. Family 1 needs long precision machining but breezes through surface treatment while Family 2 machines quickly but then spends forever in surface treatment. If the demand plan shifts toward Family 1, precision machining becomes the limiter. When Family 2 dominates the order book, surface treatment takes that role instead. Same factory, different constraint. This catches people off guard because a lot of factories talk about the bottleneck like it has a permanent address. and sometimes it does. A highly specialized process with no alternative will stay constrained across most demand scenarios. But most constraints don't behave that way. They depend on the orders, their routes, their required dates, and how the schedule sequences the work. A resource that had open time last month can become the pressure point next week when a customer mix changes. That's why last month's report can mislead you. Historical OEE data still helps. It tells you whether a resource loses time to breakdowns, slow cycles, small stops, quality losses, or poor availability. Useful facts for improving that resource. But high OEE doesn't tell you whether the resource limits the current mix, and low OEE doesn't automatically make it the resource that decides customer delivery. OEE describes how a resource performed, while mix feasibility asks whether the entire set of planned orders can flow. Those questions connect, but they don't replace each other. A machine can run strong OEE all week and still create late orders if the schedule feeds it work in the wrong sequence, or if too many orders needed before the same due date cluster. At the same time, a machine with modest OEE might not threaten shipment because the plant has enough buffer time around it and the work can go elsewhere. So I'd avoid treating one shop floor metric as your production plan. The better approach starts with the demand you actually expect. Take the planned orders, apply their real routes and due dates, then load each resource across time. You're not looking for the resource with the most dramatic percentage. You're looking for the point where work starts waiting, dates start slipping, and extra effort elsewhere can no longer increase finished output. That resource deserves a different kind of attention. For example, if a constrained inspection station blocks release of finished goods, adding capacity upstream may only build more work in process. If a constrained machining cell limits all downstream flow, overtime in packaging won't recover a date. The factory needs to focus on the current constraint. because that's where a change can affect the whole plan. This also changes how you discuss available capacity with sales. Instead of telling sales the plant has spare hours in broad terms, you can describe the actual decision. You might have room for more demand from one family because it uses resources with time available, while another family may create a delivery risk because it consumes the constrained operation during the exact days when committed work needs it. That's a far more honest conversation. It also gives commercial teams options. They can ask for a different delivery date, propose a variant that follows another approved path, or protect an existing commitment rather than accept a new order that looks profitable but forces several older orders into delay. No one likes that conversation late on Thursday afternoon after production has already built half the wrong queue. The bottleneck isn't a label you attach to a machine once a quarter. It's a current condition in the relationship between demand and the factory's ability to process that demand. A serious feasibility check tests each product mix against that condition before the plan becomes a set of shop floor emergencies. And even that isn't enough if the plan assumes every order can start without cost, because the moment the mix changes, the factory often has to change state too. Setup time is capacity. You cannot schedule twice. When the product mix changes, the factory doesn't just run different orders. It has to move between different operating conditions, and that movement consumes real production time. A changeover can mean changing a cutting tool, fitting a fixture, loading a machine program, cleaning a line, changing a recipe, checking first-off parts, or waiting for quality approval before normal production can begin. The exact work differs by plant, but the planning problem stays the same. While the resource changes state, it can't produce either the previous product or the next one. That time belongs in the plan. Many planning standards include a setup allowance, which is better than ignoring it, but a fixed average setup time often breaks down when product mix becomes more varied. The reason is simple. Setup time depends on where the resource starts and where it needs to go next. Moving from product A to product B may take 20 minutes, but moving from product B back to product A might need a full clean, material purge, tool change, and first piece inspection. In some processes, the order sequence changes the setup effort far more than the runtime changes. The sequence carries capacity with it. Picture a shared production cell scheduled for several short orders. The total runtime might fit inside the shift with room to spare, yet if the sequence jumps between material grades, finishes, or process recipes, the team can spend most of that spare time getting ready to run rather than running. Nothing has gone wrong with the calculation, it simply counted the wrong work. This is why a plan based only on unit rates can look healthy right up to the point when production tries to execute it. Standard runtimes tell you how long a part takes once the process is stable, but they often say much less about the work needed to get the process into that stable state. For high-volume repeat work, that gap may stay small because the line stays in one condition for a long time and setup effort spreads across a large batch. With more variants and smaller lots, the gap grows much larger. Each order brings its own entry cost into the schedule. A factory can lose a surprising amount of usable time without any machine failure. That doesn't mean every planner should batch all similar orders into large campaigns. Campaign production can reduce changeovers and is sometimes exactly the right operating choice. If similar products run together, the factory can protect scarce time on a constrained resource and reduce the risk that the day disappears into preparation. But campaigns create another trade-off. They can delay an urgent order that needs a different setup, push production ahead of demand, creating inventory and tying up material, or produce a schedule that looks efficient at the sell while customers wait longer for the products they actually ordered. So the question isn't just how do we minimize setup time? The real question is which sequence gives us the best feasible result for this mix, these due dates, and these operating rules? Sometimes that means grouping work into campaigns. Sometimes it means accepting an extra changeover to protect a delivery commitment. And sometimes it means telling sales that a late order will disrupt more committed work than its apparent margin can justify. That's a business choice, not just a shop floor choice. A proper feasibility check needs to represent setup as work with a time and sequence. It needs to know that a resource starts the week in a particular state, test what changes when one product follows another, and account for the real activities around the change, including cleaning, tool preparation, approval, and any warm-up or trial pieces production requires. You don't need to capture every tiny setup detail at first. Start where setup patterns repeatedly change delivery outcomes. Maybe one coating line drives the issue, maybe a molding machine where color changes consume the shift, or a test bench that needs a different configuration for each customer variant. Use the facts that alter the decision. This also changes the meaning of spare capacity. A report might show four open hours on a machine, but those four hours may not fit a new order if the order needs a 90-minute changeover before it can run, and another changeover before committed work resumes. The time exists on paper, the usable slot does not. That's why setup time is capacity. You cannot schedule twice. Once you spend it changing the factory from one condition to another, it's gone. No dashboard can put those hours back. And setup isn't the only thing that turns a capable machine into an unavailable process. Many factories track the next limits somewhere else, often in notes, maintenance files, or the spreadsheet that only one experienced planner fully trusts. Tools, fixtures, and molds limit the mix. Here's a distinction that changes how you think about product mix planning in any plant that relies on fixtures, molds, gauges, dyes, jigs, or product-specific tooling. Just because a machine is free doesn't mean the process is free. Those physical items decide whether that machine can actually run a particular order, and they often go unmentioned in capacity reports. Say you have two machining centers that can both handle the same part family. The capacity report shows two resources with open time, and engineering probably lists both as approved for that work. But the part needs a specific fixture. and the plant owns exactly one in usable condition, so those machines can't run the job in parallel. One sits idle while the other processes the batch, and if the fixture needs checking, cleaning, repair, or calibration between runs, the available window shrinks again. And if that fixture is already mounted on another machine for a committed order, moving it creates a disruption that no capacity report can capture. The fixture controls the work, not the machine calendar. Molds create the same issue. A molding press may show open hours, but each product needs a specific mold that could be in maintenance. waiting for inspection at its tool life limit, or running on another press. A planner who sees spare press time might think there's an alternate path, but production sees a missing mold and knows that path doesn't exist. That alternate machine only becomes a real option when the tooling travels with it. That's where routing data gets too optimistic. A routing may link a product operation to several work centers because all of them can perform the work in theory. But a real production route also needs the right tool, the right fixture, the current tool status, and sometimes a setup that can't move without cost or risk. Capability and availability aren't the same thing. A resource can be capable of an operation, but unavailable for this order at this time. And that matters when you test a mix against reality. A mix with many products competing for the same fixture creates a queue, even if the machine pool appears to have plenty of room. Consider a plant with several assembly stations and one test fixture used for a customer-specific configuration. Assembly can build units all day, but the test fixture can only qualify one unit at a time. As demand shifts toward that configuration, finished-looking units start collecting before test. The factory appears busy, but shipment waits for the fixture. Tooling has its own maintenance needs. Cutting tools wear, molds need service, gauges need calibration. Fixtures can suffer damage or need inspection after a defined number of cycles, depending on the process and the plant's rules. Those events eat into the production time you can count on, especially when a narrow product mix puts repeated demand on the same physical tool. A tool can become the limiting resource long before the machine hits its calendar limit. Now, I'm not suggesting you track every drill bit as a strategic asset. That would create a lot of data and not much better planning. The useful question is much simpler. Which tools, fixtures, molds, and test assets actually change the answer when you decide whether to accept, release, or sequence work? Model those as constrained resources. In practical terms, that means the planning logic needs to link the product operation to the required tooling. It needs a quantity, a status, a location, a calendar where maintenance or calibration blocks use, and any rules about which machines or product versions the tool supports. For some plants, this model can start with a short list of shared assets that already cause planning trouble. A scarce mold set. a coating rack, a welding jig, or a test adapter. The goal isn't to build an encyclopedia of tooling, it's to stop planning against resources that don't exist in a usable state. This approach also exposes a real investment choice. If one fixture repeatedly limits a profitable order stream, the plant can assess whether buying another fixture would relieve the bottleneck. Without the model, the same pain shows up as vague overtime, late delivery, or complaints that the schedule keeps changing. Nobody sees the actual cause. There's a more subtle problem, too. Product-specific tooling can turn a supposed alternate route into fiction. The machine might have the right envelope speed and controls, but if the required fixture only fits on one machine, or the tool program needs approval before it can be used elsewhere, that broad machine group doesn't give you flexible capacity. It gives you a theoretical option. Planning needs to separate those two things. A theoretical option belongs in engineering discussion. A usable option belongs in the schedule with its conditions recorded clearly enough that the planner doesn't have to discover them through a phone call after the order's already been promised. Physical tooling is part of the factory's capacity model because it controls which work can happen at the same time. Ignore it, and your available machine hours become an estimate built on missing equipment. And machines don't run production by themselves. Skills and shift coverage change the answer. Here's the real challenge. A resource calendar can show an open night shift but the work still can't run because people aren't there. A machine needs an operator who can run the job, but some jobs also need a setter who can establish the process, an inspector who can approve the first part, a programmer who can correct the program, or maintenance support when things go sideways. Those roles shape usable capacity more than the machine calendar does. Say you have a production cell running stable, repeat work across all shifts. The night team knows the equipment well, but then the schedule introduces a new variant with a different tool set and a changed program. The machine calendar says the night shift has time, and the work instructions may even sit in the MES, but the person authorized to validate that first run works days only. So the order waits, or someone takes a risk the plant's own quality or safety rules don't permit. Neither outcome shows up in a broad machine hours report. The report sees a free resource, but production sees an incomplete team. Skills aren't just a headcount issue. A plant can have enough operators in total and still lack the right skill at the moment a constrained process needs it. One qualified person may need to cover several cells, and another... might hold certification for a material, a welding process, a test method, or a customer-specific procedure. Those limits can change with the product mix. A week dominated by standard products may run fine with the normal shift pattern, but bring in more complex variants, and the same staffing level becomes a problem because each variant pulls on a smaller pool of qualified people. The total labor hours may look fine, while the schedule starts waiting for a particular skill. That's not a people problem. It's a planning input. Plants often keep skill data somewhere. Training records, staffing plans, local matrices, or the knowledge of a production leader. Each source has a reason to exist. The issue comes when a planning system treats all staffed hours as equal, even though the work requires different levels of approval and experience. They aren't equal. A serious mixed feasibility check links an operation to the people or roles it needs. That doesn't mean assigning every person months ahead in a rigid schedule. In many factories, that would create its own problems. It means the planning logic knows that certain work can only run on specific shifts, with specific roles available under rules the plant actually follows. Consider inspection. A product family may run through machining without much trouble, then need a specialist inspection step before release. The equipment could have time and the parts could be ready, but if the qualified inspector isn't present until the next day, the order can't move. The work is complete physically, but not operationally. Safety adds another layer. Some operations require a defined staffing level, and a person may be technically trained but unable to work alone on a shift. Maintenance activity may require a lockout procedure, supervision, or a second approved role. These aren't exceptions. A planning model can wave a way to make a date fit. They're part of the factory. Cross-training can change the answer over time, and it's often discussed as a general improvement target. That's fair, but planning needs something more concrete. Which skill gap actually causes missed dates and which qualification, if added to a shift, creates a real alternative route or extends the usable window at a constrained operation? Those questions turn cross-training into an operational choice. Maybe the best response to a recurring mix problem isn't another machine. It might be qualifying a second setter for a high-pressure cell, training an inspector on a common product family, or changing shift coverage, so approved support exists when the work reaches that stage. You only see those options when people appear in the model alongside equipment. This needs care. Skill data can change, certifications expire, people take leave. A planning model shouldn't pretend it knows more than it does. It should show where a plan relies on a named qualification, a thin coverage assumption, or a gap that someone must resolve before release. That makes the trade-off visible early. Once you include shift coverage, a capacity figure starts to look less like one number and more like a set of real-time windows. Some support standard work, others support complex work, some can absorb disruption, and others can only keep stable production moving. That's how the factory operates. And even when the right machine, tool, and person line up, the order still can't start unless the inputs for that order are ready. Material constraints turn capacity into waiting time. You can have the machine, the fixture, and the qualified person ready, and still lose the slot because the material isn't there. That sounds basic, but here's what actually happens in practice. Material constraints get treated as a supply chain problem somewhere outside production planning. The reality is that a missing component changes the sequence a factory can run and leaves capacity sitting idle, waiting for work that can't start. Take a common assembly order, the plant holds most of the parts, labor is scheduled, and the assembly station shows open time. Then one purchased electronic module arrives two days late. The order can't start, even though every capacity report around that station still looks healthy. The hours exist, but the work doesn't. That's the gap most planning systems miss. Raw material creates the same problem in process industries and discrete manufacturing. A product may need a specific alloy, batch, coating, resin, or approved supplier lot. The system says you have stock, but it's the wrong specification for that order. Maybe it's below the required quantity stuck on quality hold or already allocated to another customer commitment. So you have inventory, but you don't have usable material. Material availability needs to mean more than something similar sits in the warehouse. It has to answer whether the right material in the right quantity with the right approval status can reach the operation before that operation starts. That time element changes everything. A delivery due late in the week might support the monthly plan, but it can't support an order that needs to start Monday to ship on time. The calendar doesn't care about your stock levels. Every order runs against two clocks. One tracks the production route, and the other tracks when material and components become usable. If those clocks don't meet, the order waits. And when it waits, the schedule may fill that open slot with another job, which then shifts the setup sequence, the queue, and the availability of the next operation. A late component can ripple through a factory even when it only affects one order. That ripple is invisible on a standard capacity report. Now, substitute rules matter more than most planners realize. In many plants, you can't simply swap one material for another just because the inventory system shows a similar description. The substitute may need engineering approval. It may work for one customer and not another. It may affect traceability, process settings, quality checks, or even the finished product certificate. A substitute is a controlled option, not an emergency guess. Treating it otherwise creates risk that no schedule can fix. Lot restrictions add more limits. Some products need material from one approved source. Some require matched lots, others can't use stock held for another order because of customer ownership, export rules, or a quality issue still under review. These rules may sit across ERP quality systems, warehouse processes, and local knowledge on the floor. If the planning logic can't see them, it schedules fantasy. And that fantasy becomes real when the line stops. There's also work in process, or WIP. An order may have material available for its first operation, but depend on a semi-finished part from another route before it reaches final assembly. If that upstream work slips, downstream capacity turns into waiting time. The assembly team may stay busy with other work, but the original delivery promise now depends on a chain that no broad capacity total can explain. That chain is where the real constraints live. This is why material status from ERP needs shop floor context before you release work. ERP can tell you planned receipts, stock records, purchase orders, allocations, and bills of material. All useful planning facts. But ERP alone may not know that a delivery arrived at the gate but hasn't passed incoming inspection, that the available lot sits in a blocked location, or that the upstream operation has produced quantity but not released it for use. Without that context, your schedule is a guess. The factory needs a usable material view. That view links each order to its required inputs, their approved status, their expected availability, and the point in the route where they matter. Then, a feasibility check asks a practical question. If we schedule this order in this slot, will every required input actually be ready? Not theoretically, not at some point in the week, ready when the operation starts. Sometimes the answer changes the sequence. A planner may bring forward another order that has complete material rather than holding a machine and team for work that can't begin. Sometimes it triggers a supplier call, a quality decision or a commercial conversation before the schedule turns into a daily negotiation. That's far better than releasing everything and hoping the parts arrive in the right order. Hope is not a planning strategy. Material constraints don't remove capacity. They strand it. They turn planned production time into gaps, extra set-ups, and work that waits in front of the next step. A feasible product mix needs the right demand on the right resources, but it also needs each order's inputs to become usable at the moment the route requires them. And once due dates enter the picture, even a plan with enough material and enough hours can still overload the factory at exactly the wrong time. Due dates create a different kind of overload. A weekly capacity plan can fit perfectly and still fail by Tuesday morning. Here's why. Customer demand doesn't arrive as an even stream across a week or a month. orders carry due dates, and those dates concentrate demand on the same shared resource during the same short window, even when the total hours for the full period look manageable. That's the part that catches most planners. Picture a planner reviewing the next five working days. The combined load on the constrained finishing cell sits below the weekly calendar. That sounds safe. But most of the orders that need that cell, promise, shipment, by Wednesday, while the available time after Wednesday, cannot recover those commitments. The week fits, but the first half doesn't. And the second half can't fix it. This is a different form of overload. It isn't always visible as more work than the factory can complete in total. It shows up as too much work hitting the same resource before the same deadline. A plan that looks green at week level can already contain an impossible cluster of work at day level. That cluster is the real bottleneck. Time buckets can hide that problem. When you load work by month, a late slot looks as useful as an early slot. When you load by week, Friday appears interchangeable with Monday. For an order that must ship Tuesday, those hours have completely different meaning. Due dates turn capacity into a time-phased problem, and time-phasing is what most planning systems ignore. A realistic check asks not only how much load each resource receives, but when each operation must happen for the order to complete on time. The first operation needs a slot early enough for the next operation to follow. Then inspection, packaging, or final release may need their own time. The order doesn't need capacity sometime this week, It needs a chain of capacity at the right points in the week. That chain can break even where total hours remain open. The break point is when you find out your plan isn't real. Imagine several orders for different customers, all due near the same date. They come from different product families and use different early steps. As they move through production, they converge at one shared test station. Each order looks reasonable on its own. Together they create a peak that the station cannot absorb before shipment. That's the load the planner needs to see before releasing work to the floor. Once the peak appears, people often try to fix it with urgency. A late order gets higher priority. Someone asks the team to squeeze it in. Another order gets moved aside. The schedule changes, the team changes direction, and the displaced order becomes tomorrow's emergency. Expediting doesn't create time. It changes who waits. And it usually makes things worse. Sometimes that choice is right. A customer commitment, a safety-related part, or a commercial decision may justify moving one order ahead. But a feasibility process should expose the cost of that decision. Which orders move later? Which resource absorbs the extra pressure? Does the new priority force another change in sequence? Are you protecting one due date by quietly risking three others? Without those answers, priority becomes noise. And noise doesn't ship orders. Simple dispatch rules can help in stable conditions. Earliest due date, for example, means work the order with the nearest due date first. That rule can reduce lateness in some situations because it gives the team a clear way to choose from a queue, but it doesn't solve every mix problem, and stable conditions are rare in most plants. If two urgent jobs need a long changeover between them, running them strictly by due date may waste scarce time and delay both. If an order reaches the resource before its material or prior operation is ready, its early due date doesn't turn it into executable work. If one job consumes a narrow test asset later in the route, the best sequence may depend on more than the date printed on the order. Due dates need context, just like capacity does. Context is what makes the difference between a schedule and a wish list. This doesn't mean planners should ignore due dates in favor of a perfect machine sequence. Customer promises matter. It means the plan has to show the real trade-off between delivery risk and the cost of getting there. A schedule can then support a proper decision. Protect the date, negotiate the date, change the order, or choose a different production path where one exists. That conversation is much easier before the work hits the floor. After that, you're firefighting. I'd also be careful with monthly service measures when testing product mix. A plant can ship most orders by month end and still create daily chaos over time and strained customer relationships because too many commitments fell into the same few days. The monthly result may look acceptable while the operating pattern remains unstable. Customers don't experience your average capacity, they experience their promised date. And they remember when you miss it. So use broad capacity to screen demand, then test the mix against time-phased load at the operations that control delivery. Look at the day, shift, or finite slot that the work actually needs. Not only the period where the planning report can place it. Once too many orders compete for the same early slot, the production cost starts appearing in the work that waits. And that cost is almost always higher than you think. Queue time is often the cost. Nobody planned. Here's the problem most manufacturers don't talk about. When too many orders all need the same early slot, the first thing you see is a queue. Work reaches an operation and just sits there because the resource, person, tool or process approval it needs is busy with something else. That wait often adds more lead time than the actual work, especially in a complex plant where an order moves through several handoffs and each one depends on a finite slot being free. Now, a queue isn't automatically bad. Some waiting exists in almost every factory because demand and process times don't arrive in a perfectly smooth pattern. The problem starts when the queue grows because the planned mix keeps feeding more work into a constrained step than that step can clear. Then waiting becomes the normal state. Picture a test area at the end of several production routes. Parts arrive from machining, assembly, and rework. The test team sees a full staging area, so it looks like there's plenty of work available. Meanwhile, upstream teams keep producing because their local schedules tell them to stay busy. Here's the thing. Those parts don't become shipments while they wait. They become work in process. WEP and WIP can create a false sense of progress because you've already consumed material, labor, and machine time. People can point to racks full of partly completed product, but the customer needs finished, released product, not a growing collection of orders parked before the same constrained operation. More WIP doesn't fix the flow, It often makes the problem harder to manage. Once a queue grows, the team has to figure out which order belongs to which customer, which job has a real due date risk, which parts need further checks, and which material or paperwork still needs attention. The physical search effort grows right along with the queue and priorities start to collide. A late order gets moved to the front because someone escalated it. That may protect one shipment, but every urgent order that jumps the queue pushes other work further back, and those displaced orders become the next set of escalations a day or two later. The queue turns into a priority auction, except nobody sees the full cost of winning. This is why a product mix can look manageable when you add up the total hours, but still damage delivery performance. The mix might create a heavy wave of work at one shared step. Upstream capacity keeps converting raw material into WIP, while the constrained step releases finished orders at its own pace. The plant feels busy. Lead time grows anyway. There's a simple idea from operations management called Little's Law. You don't need the formula for the practical point. When more work sits in a system and the completion rate doesn't rise with it, the average time work spends in that system increases. Put less formally, if you keep putting more cars into a traffic jam, the trip takes longer. That doesn't mean the answer is always to reduce WIP blindly. Some processes need buffers. Long lead time materials, batch processes, and normal variation can all justify planned inventory between steps. The point is to know why the buffer exists, how much it should contain, and whether it protects flow or simply hides an overload created by the wrong mix. A planned buffer supports the schedule. An accidental queue consumes it. This distinction changes the planner's job. Instead of releasing all orders that appear due soon, the planner can ask which orders should enter the system now without flooding the operation that controls completion. That might mean holding work upstream, changing the release order, or protecting limited capacity for the products that need it most. Holding an order can feel uncomfortable. People often read it as inactivity, especially when an upstream machine has open time. But starting work early only helps when the next steps can absorb it in time. If the order will wait for days at the constraint, early release can tie up cash, floor space, and attention without improving shipment. The best release decision isn't always the earliest release. It's the release that supports a feasible path through the factory. That requires a view of the order route, the current queue, the due date, and the finite capacity ahead. Without that view, teams do what they can with local information, and the usual response is to keep equipment running, which leads to another uncomfortable point. Local efficiency can look good while flow through the factory gets worse. Local OEE can support a bad mix. There's a habit in manufacturing that causes trouble here. When delivery performance slips, people often look first at machine utilization and OEE, or overall equipment effectiveness. That makes sense up to a point. OEE helps you see whether a resource loses time through availability losses, slower running, or quality losses. If a machine stops often, runs below its expected rate, or produces reject parts, you need to understand that. But OEE answers a resource question. It doesn't answer the product mix question, Picture a plant where each department has a clear target to keep its machines busy. The cutting area keeps cutting, the machining area keeps machining, assembly keeps building, everyone can report strong utilization, and several resources may even improve their OE during the month. Meanwhile, finished orders still leave late. How can that happen? Because the work being produced may not match the work that needs to flow. An upstream cell can run efficiently on the easiest available orders, even if those orders will wait behind a constrained process later in the route. The cell looks productive. The factory gains more WIP and no extra shipments. That isn't a failure by the people running the cell. They're often doing exactly what their local measures ask them to do. The problem comes from treating local activity as proof of system output. They're related, but they're not the same. A factory doesn't earn delivery performance when an individual operation finishes. It earns delivery performance when the full order completes, passes the required checks, and ships when promised. So a machine can have a strong OEE number while the product mix creates poor flow. Imagine a broad machining group that can process many product families. The team sees a gap in the schedule and runs the available work that needs the least changeover. That choice may improve machine time and reduce setup loss. It can even appear sensible from the perspective of that machine. Yet the jobs they choose may feed a downstream process that already has too much work, while more urgent orders wait for a different machining step. The local machine stays busy. The constrained path receives more work it can't clear. The orders that matter for shipment remain incomplete. That's the conflict. OEE remains useful because it helps production teams improve the performance of equipment. A poor availability pattern at a shared resource can reduce what the schedule can realistically promise. Slow cycles can change the load. Quality losses can reduce usable output. You need that information. But OEE cannot decide which product should run next. It has no built-in understanding of customer dates, product routes, shared fixtures, material readiness, or the current sequence at another process. It can tell you a machine lost time. It can't tell you whether recovering that time will improve finished order throughput for the planned mix. Those are different decisions and they need different views. For product mix planning, bring the views together. Look at the constraint load created by the actual orders. look at flow through the required operations, look at delivery risk by due date, then use OEE to understand whether the resource performance assumptions inside that plan are credible. That puts each measure in the right place. A planner might see that a test process controls shipment for a certain product family. The team can then ask whether its planned capacity reflects actual performance, including common stops and quality losses. If the answer is no, the model needs a better assumption. If the answer is yes, extra activity upstream may simply create more waiting work. This is also why keep everything running, can become an expensive rule. When the mix is wrong, full local utilization can produce more handling, more space pressure, more searches for parts, and more arguments about which order deserves priority. The plant spends effort managing work that shouldn't have entered that part of the flow yet. A busy factory can still miss dates. I'm not suggesting idle machines should become the goal. That would be just as simplistic. The goal is to use resources in a way that supports the orders the factory needs to finish, under the limits that govern the current mix. Sometimes that means an upstream resource runs a different order. Sometimes it means the resource prepares for a later job. Sometimes it means the team accepts a short gap because releasing more work would only overload the next shared step. That can feel counterintuitive when a utilization report turns red, but a red utilization indicator may be less harmful than racks of product waiting for the one operation that controls shipment. The plan needs to judge work by its effect on flow delivery and the current constraint, not only by whether every asset stayed active. There's one more complication. Even a well-sequenced mix can change after production starts, because the planned route assumes parts move through it without unexpected quality loss. Yield, rework, and scrap distort the plan. Here's the problem I keep seeing. A schedule looks clean on paper when every routing time adds up nice and neat. But then, quality shows up that week, and suddenly the plan starts losing capacity it never accounted for. Nobody planned for that. Most planning standards assume a normal path. A part moves through its operation, passes inspection, and goes to the next step. And sure, you have to assume that You can't plan every order as if failure is guaranteed. But you still need an honest range around that assumption. So here's what changes. Some product families need more inspection than others. A new variant might need extra checks. A tight tolerance can mean more measurement, adjustment, or first-piece approval. And a customer-specific configuration might require a test sequence that standard work never touches. The product mix changes the quality load. That's the simple truth. Picture two weeks with the same planned hours on a machining cell. First week, the cell runs proven, repeat parts, everything smooth. Second week, it runs more complex parts that need extra checks after machining and more detailed testing before release. The machine load barely changes, but inspection and test suddenly face a very different kind of demand. And that changes whether the whole order finishes on time. Now, rework adds another path that standard routing treats as a rare exception. When a part needs correction, it might return to an earlier operation, wait for a specialist review, need a new test, or consume time on the same constrained resource that the original plan already loaded. The part doesn't vanish just because it failed the first time, It stays in the factory, competes for material handling and attention, and it can eat up scarce production time again. If the mix includes products with a higher chance of rework, a plan based on first-pass routing alone can look comfortable while the real week gets crowded. But I'm not saying you should slap a fixed rework penalty on every order and call it done. Rework patterns differ by product, process, material, and current conditions. A broad average might still hide the same problem, just with the more official number attached to it. Use what the factory already knows. If a product family regularly needs extra test time, Model that demand where it happens. If certain variants carry a known risk of a return loop, run scenarios with a reasonable allowance and make the assumption visible. If the data is too weak to support a precise estimate, say so rather than pretending the schedule has certainty it doesn't have. A plan handles an identified uncertainty far better than an unspoken one. Scrap creates a related issue, though it behaves differently. A reworked part consumes more process time. A scrapped part wastes material and the capacity already spent before anyone decides it can't ship. Then the factory might need to build a replacement, adding new work exactly when the schedule already feels tight. Scrap isn't just a finance number you record after the shift ends. For a constrained operation, scrap can remove capacity twice. First, the resource spends time producing the failed part. Then it might need to spend more time producing a replacement. If the product needs scarce material, the replacement may also wait for supply, turning a quality issue into a delivery issue. That link matters when the plant decides which mix to accept or release. Quality holds create another kind of delay. A batch might finish its physical work, but remain blocked while someone reviews a result, investigates a deviation, checks traceability, or waits for a disposition decision. The order looks nearly complete in one system, but it can't move to shipment. Production sees finished parts, the customer still sees nothing. When the mix includes more regulated products, new products, or products with tight inspection rules, those hold points need to sit in the feasibility view. You can't plan away every possible hold, but the plan should know that a route includes a release step, and that the release has a real lead time or limited review capacity. Otherwise, the factory plans to ship parts before it has permission to ship. In practical terms, separate stable facts from uncertain performance. Stable facts include required inspections, test operations, approval steps, and known rework routes. Performance assumptions include expected first pass yield, likely rework demand, and the chance that a hold takes longer than normal. Both belong in the discussion, but they don't carry the same confidence. So when the mix shifts toward products with more quality exposure, planners need to see the effect before release. They need to know whether the inspection team can absorb the load, whether replacement demand threatens a constrained process, and whether the promised date leaves enough room for the route to handle normal variation. That's not pessimistic planning. It's planning for the factory that actually produces the parts. And after quality alters the route, another question follows. How much of the planned machine time can you genuinely expect to survive the week? Reliability changes, effective capacity. Let's talk about effective capacity, because that's another place where the plan gets distorted. Planned capacity often assumes a resource will behave like its calendar. If the machine has eight scheduled hours, the plan treats those eight hours as available, maybe reduced by a standard efficiency factor. But production rarely gets a week that clean. A machine can stop. A process can drift. A product change can need extra warm-up, adjustment, or cleaning. Maintenance can find wear that needs attention before it turns into a larger failure. None of that means the plan failed. It means the plan needs to account for how the equipment actually behaves. Here's the distinction. Effective capacity is the time you can reasonably expect to use for the work in front of you. That's not the same as rated speed multiplied by calendar hours. Rated speed usually comes from stable conditions with the right material, a known setup, and no unexpected interruptions. A real schedule includes product changes, operator handovers, normal stops, plant maintenance, and the occasional problem nobody could predict. The question isn't whether uncertainty exists. It always does. The question is whether your planning process treats uncertainty as part of the production system or hides it behind a clean capacity number and waits for the shop floor to absorb the difference. Now, product mix changes this more than many people expect. A machine might run one family of products for days with few issues, then behave completely differently when the schedule moves toward a more demanding family. Maybe the new material creates more toolware. Maybe the product needs tighter settings and more checks. Maybe each changeover leaves the machine less stable for the first part of the run. Reliability can depend partly on what you ask the resource to produce. Picture a shared machining cell. The planner sees room in the calendar and brings forward a group of complex parts. On paper, their standard runtime fits. In practice, the parts need frequent tool checks, longer adjustments, and more maintenance intervention because the process puts extra stress on a component already close to its service limit. The machine doesn't simply lose time. The planned mix changes the chance and shape of that lost time. That's why maintenance and planning need a more direct conversation. Preventive maintenance doesn't compete with production the same way an unplanned stop does. It protects the resource from a bigger disruption later, but that doesn't make the timing easy when urgent orders arrive. If maintenance needs a four-hour window on a constrained resource, that window belongs in the feasibility check. Skipping it might create a short-term slot for an order, but the schedule should show the assumption clearly. We are taking a known maintenance risk to protect the state. Sometimes leadership may choose that risk. Often, once they see the likely downstream effect, they'll choose another option. A plan should support that choice, not quietly bury it. Now, I know it's tempting to solve this with one universal availability percentage. Take every machine's calendar, remove a fixed allowance, and call the remainder realistic capacity. That can be useful as an early rough screen. But it can also create false confidence. A fixed allowance doesn't distinguish a stable product from a difficult one. It doesn't know whether the resource faces repeated changeovers, whether a tool reaches its life limit during the planned batch, or whether a maintenance task must happen before a product can run safely. It turns different operational conditions into one average number. The factory still has to live with the differences. A better approach uses scenarios. Start with the normal operating case based on recent and credible performance for that process and product family. Then test the disruption case that production recognizes as plausible. A maintenance intervention, a slower start after a changeover or reduced output from a resource with a known issue. You don't need to predict the exact minute of a stoppage. You need to know whether the mix can absorb a credible loss of time without turning every customer commitment into an escalation. If one modest disruption causes multiple orders to miss their dates, the plan has very little room in it, even if the main capacity report stays green. That's a useful finding before release. So reliability doesn't mean planning for disaster every week. It means separating hopeful capacity from capacity that can survive normal factory conditions. When the product mix puts extra strain on a shared resource, the realistic question isn't whether the machine has hours on its calendar, it's whether those hours will still exist when the work reaches the machine. Utilities and plant services can become constraints. Here's something that often gets overlooked. There's another form of capacity that sits completely outside the main production schedule. The machine, tool, material, and team may all be ready, but the plant service that supports the process simply doesn't have enough room to handle the load. And that's where the plan starts to break down. Now here's why that actually matters in practice. Some product families consume shared services in very different ways, and the mix can push those services past a safe or practical limit long before the main work centers even look full on the report. The constraint shows up somewhere nobody was watching. Take heat treatment. It's a classic example. A furnace doesn't work like a machining center with a simple hourly slot for every part. Instead it has a chamber size, a recipe, a heat cycle, a cool-down period, loading rules and sometimes restrictions on which materials can run together. So the furnace calendar can look wide open while the actual batch space has already disappeared. You just can't see it from the schedule. Consider a plan that includes several orders all needing the same heat cycle before shipment. Each order looks manageable by itself, but put them into the same week and the oven becomes a shared constraint. You can't just add another order because the nominal machine capacity report still shows open hours elsewhere. The batch process sets the pace, not the machine time. Compressed air creates the same kind of problem, especially when several high-demand processes run at the same time. A plant may have enough equipment capacity for a group of machines, but not enough stable air supply to run every air-intensive operation together without affecting pressure, process quality or other production areas. And that limit never appears in an ERP routing. Nobody flags it. Power demand works exactly the same way. Some plants manage peak electrical load because large equipment like ovens, welders, chillers or test rigs draw heavily at certain times. A product mix that shifts toward energy-heavy work changes the loading pattern across the day, even if the total production hours don't change. The order book may fit perfectly, but the utility window may not. Cooling water, steam, vacuum, clean room capacity, extraction and wastewater treatment also control what work can run at the same time. These aren't background details you can ignore. For the processes that depend on them, they are production resources. Picture a plant with several coating operations. Each booth may have a free operator and a clear schedule. Yet the extraction system only supports a limited number of booths at full use under the plant's safety rules. Running everything at once doesn't create more throughput. It creates a condition the plant shouldn't run. Safety rules define capacity too. Sometimes the restriction comes from the environment rather than a physical limit. process needs a controlled temperature range. A clean room supports only a fixed amount of activity before cleaning or monitoring is needed. Certain materials can't run together because of contamination risk, fire risk, or emissions rules. Those conditions shape the feasible mix in ways that never show up on a capacity report. And this gets missed because plant services often belong to separate teams. Production owns the order sequence. Engineering owns the process rules. Facilities manages utilities. Environmental health and safety teams set operating limits. Each group sees its own piece of the problem. The plan needs to connect those parts before the week begins, not after the schedule has already broken. Now, the good news is you don't need to build a full physics model of every utility system just to improve mix planning. Start with the shared services that repeatedly force last-minute changes. If heat treatment capacity drives delivery, model the furnace recipes, batch rules, and calendar. If peak power constrains certain work, model the approved operating windows. If clean room access limits product release, treat that capacity as finite. use the limits that actually alter the decision. There's a useful distinction here. A machine resource tells you whether a process can perform work. A plant service tells you whether the plant can support that process while other work runs. Both conditions must hold at the same time. One without the other doesn't produce a finished order. This can also change investment discussions. A plant appears to need another production machine when the actual constraint sits in cooling, extraction, test power, or oven batch capacity. Buying the machine might increase local activity while the shared service still limits output. That's an expensive way to discover where the constraint lives. So when you test a product mix, widen the definition of capacity. Include the services, batch windows, environmental rules, and safety limits that decide whether several orders can run together. The resource that controls the plan may not look like production equipment at all. And when that constraint stays invisible, its cost rarely lands in one obvious place. The hidden cost shows up across the factory. When a bad product mix hits an unseen constraint, the cost doesn't arrive as one neat line in a finance report. It spreads through the plant and each team sees only the part that lands on its desk. Production sees overtime. Planning sees a schedule that needs changing again before the previous version has reached the floor. Customer service sees a late order and starts calling for answers, while logistics sees a shipment that now needs a faster and more expensive route. And nobody calls it the cost of the mix, they just feel it everywhere. Picture a week where the factory accepts extra demand for a product family that looks attractive on paper. The order value looks good, the main machine group still has open time, and the sales team has a customer asking for a fast commitment. So the order enters the plan and then begins consuming scarce time at a shared process that already supports several committed orders. The first response may look harmless. Add a few overtime hours. Ask someone to move material faster. Put the customer order at the front of the queue. Each action can solve a local problem, but the total cost keeps moving outward through the factory. Overtime rarely stays contained to one operation. If a late order needs extra work at a constrained process, it may also need a later inspection, extra packing effort, a warehouse handoff outside the normal window, and transport planning that no longer fits the usual dispatch cycle. The plant can still ship, but it ships through a more expensive operating path. And the original schedule becomes less trustworthy. Expediting causes a different kind of cost. Someone spends time chasing parts, checking material status, moving work between areas, finding the right paperwork, and asking teams to change their plans. Those people may not appear as a direct production cost on the order, yet the effort pulls attention from work that should have been stable. The factory starts running on interruption. Premium freight becomes visible because it has an invoice. Excess handling may not. Neither does the time a supervisor spends deciding which order to move, or the time a planner spends rebuilding a sequence after every new escalation. But those costs belong to the same chain of events. The product mix created a plan that couldn't hold. inventory can rise at the same time, which feels strange until you look at the flow. Teams build work early because they fear a future capacity problem, because they want to keep local resources busy, or because they're trying to protect a material position. The result can be more stock and more late orders at once. That's a familiar factory contradiction. The stock sits in the wrong place, in the wrong form, or before the wrong constraint. It consumes material, space, handling, and working capital, while the orders customers need still wait for one missing operation, test, approval, or component. More inventory doesn't mean more usable output. Margin can erode even when the incoming order looked profitable. A product with a strong unit margin may trigger overtime, disrupt a stable sequence, push other work into late delivery, and force premium freight on several shipments. Finance sees the direct margin on the new order. Operations carries the wider cost of the disturbance. Both views can be accurate, but neither is enough on its own. There's also a trust cost. When planners release a schedule that changes every day, production teams stop treating it as a plan and start treating it as a suggestion. They build their own local rules, keep private notes, and rely on calls or messages to learn what actually matters today. You can understand why. They're trying to protect delivery in an unstable situation. Still, the more the factory depends on informal workarounds, the harder it becomes to improve the planning process. The most experienced people can often keep things moving for a while, but their knowledge remains trapped in conversations rather than shaping the decision before the order gets released. The cost of a bad mix doesn't sit in one department because the factory doesn't work in one department. It appears as overtime in one place, inventory in another, freight elsewhere, and lost confidence everywhere in between. So when sales, finance, and operations discuss which products to accept, defer, or promote, they need to look beyond margin per unit. They need a shared view of the constrained time and the operational cost that the mix creates. That's the real conversation worth having. Margin per unit can mislead the mix decision. Here's the thing about margin per unit. It can look great on paper. and still lead you to the wrong decision for this week's mix. I know that sounds odd, especially when sales sees a good price and finance sees a healthy direct margin. But here's what those numbers miss. How much of your scarce production time that product actually consumes, and what committed work it pushes aside. Picture two orders. The first has a lower margin per unit, but moves through the constraint quickly with a stable route, while the second has a higher margin per unit, but needs much longer at the one resource that controls delivery for several other product families. The second order seems better, until you ask a different question. You need to ask, what does each order contribute per hour of the resource that limits the flow right now? That's the constraint-based view. If one process has little room, every hour assigned to it becomes a choice. Not just what to produce, but what not to produce with that same hour. Margin per unit hides that trade-off. Now, contribution per constrained hour isn't a magic number either. It's a useful lens, but it won't decide the whole mix by itself. The constraint can shift as the mix changes, Setup time eats into usable time, and a product with a lower short-term return might protect a strategic customer, complete a kit, or prevent a service failure downstream. The decision needs context around that number. Take a plant that gets an urgent request for a high-margin variant. Sales wants to accept it. Operations sees it consuming a long test cycle at a shared station. Finance calculates a good return, but customer service knows that moving other orders risks dates already promised to long-term accounts. All of those views describe part of the same decision. The trouble starts when each team works from a different version of capacity. Sales sees open hours, operations sees a crowded sequence and a thin staffing window, finance sees unit margin, and the planner sees due dates, material risk, and a list of orders no one wants to delay. Then someone tries to settle it with a spreadsheet formula. A formula can help structure the discussion, comparing direct margin, constraint time, setup demand, and overtime cost. But once several orders share tools, people, material, and downstream steps, A simple ranking can produce a bad sequence. The highest score doesn't always create the best plan. Consider this. Selecting only the best margin per constrained hour might leave a long setup between products, consume a scarce fixture or block a customer order that completes a larger shipment. A mixed decision also includes service commitments, contractual duties, product launch needs, customer relationships, inventory exposure, and the risk that an assumption proves wrong. That doesn't make the decision vague. It makes it a real business decision. The planning model should give people a shared fact base. Which resource limits the current mix? How much time each proposed order consumes there? Which committed orders face delivery risk? And what changes when a new order enters the plan? Then leaders can choose openly. They might accept the higher margin order and approve overtime, defer it to protect existing commitments, split the order, alter the quantity, use an approved external route, or negotiate a later date. None of those choices should be automatic, and they shouldn't be. A planning system should expose the cost, not pretend it owns the commercial decision. This is where finance, sales, and operations need the same constraint model, even if they ask different questions. Finance needs to see the cost of consuming limited time, sales needs an answer that reflects what the plant can actually deliver, and operations needs a plan that doesn't turn every accepted order into another floor-level emergency. Without that shared model, margin becomes an argument about whose number wins. With it, the conversation changes from, is this product profitable, to what does accepting this product do to the whole mix, and are we prepared to accept that consequence? That's a much harder question, and the one a factory has to live with. Why Excel persists, and why it breaks here. When a planner needs to test a late order before lunch, Excel is often the fastest place to start. And that isn't a criticism. A spreadsheet gives experienced people a blank space where they can test quantities, change dates, add a note about a tool problem, and apply the local knowledge that never found its way into an ERP field. In many plants, that flexibility keeps production moving. A planner might know that eroding time is optimistic for one variant, a fixture will return from repair later in the week, or a senior operator can cover a difficult setup on Thursday but not Wednesday. They can put those facts into a workbook quickly, without waiting for IT or master data releases. That kind of practical work matters. Excel works well for bounded analysis, like comparing a few demand cases, estimating the impact of a known capacity loss, or preparing for a planning meeting. A well-built sheet can help people ask better questions. The problem starts when the sheet becomes the place where the factory's real production rules live, because then the planning logic becomes hard to trust. When an order needs an alternate route, the planner needs to know if that resource can process the product, if the right tool exists, if approved staff cover the shift. if material can arrive at the operation, and if the new sequence creates trouble somewhere later, each fact sitting in a different file system or person's memory. A spreadsheet can hold all of that, but it doesn't keep it current. So when someone changes a routing in engineering, a tool enters maintenance, a worker's qualification expires, or a supplier date moves, the planner may not learn about it until the schedule already depends on an assumption that no longer holds. The cell formula still calculates, but the plan still fails. That's where version problems appear. Sales works from one capacity workbook, production adjusts another copy after the morning meeting, supply chain maintains its own material view, and a scheduler carries a personal file with setup assumptions nobody else knows. Every file looks reasonable on its own, but when people compare them, they find different order quantities, different calendars, and different definitions of capacity. Then the discussion turns into a search for the latest file, rather than a decision about the best production choice. Apparently, version names ending in Final Final 2 remain part of industrial architecture. The deeper issue isn't Excel, it's hidden assumptions. A planner may apply a sensible rule without writing it down, like reserving a scarce resource for a customer order, because they know the downstream process will struggle otherwise. Another planner who doesn't know that rule changes the sequence and accidentally removes the protection. The spreadsheet contains numbers, but not always the reason behind the numbers. That becomes risky when routing, Setup, skills, materials, and due dates all change at the same time. Each change looks manageable alone, but together they create a dependency problem that grows faster than a human can reliably recalculate across tabs, formulas, emails, and notes. The planner doesn't lack effort. The model lacks structure. So I wouldn't argue that manufacturers should remove Excel from planning. That ignores why people rely on it. Excel remains useful for analysis, exploration, and fast preparation, and it can support a planner who understands the process. But it can't replace governed production logic when the business needs a repeatable feasibility decision. That logic needs clear data ownership, agreed rules for resources, routings, constraints and calendars, and a way to trace why an order can run and why it can't. People need room for judgment. They don't need to rebuild the factory model every Monday. The planners who maintain these sheets deserve more respect than they usually get. They compensate for disconnected systems and incomplete master data with experience, memory and quiet manual checking. That work keeps orders moving. until the product mix changes faster than any workbook can keep up with. ERP, MES, and IoT. Each know something different. Here's the problem most manufacturers don't talk about. Spreadsheets keep filling the gaps because each system only holds part of the production answer. None of them automatically turns those pieces into a decision about whether a particular product mix can actually run. Take your ERP. It starts with commercial demand. Customer orders, planned numbers, bills of material, inventory records, purchase orders, and usually the standard route a product should follow. All of that tells you what the business wants the factory to make. ERP also holds work orders, target dates, planned supply, and basic resource standards. For medium-term planning, that's a pretty useful view of demand against capacity. But here's the thing. An ERP routing usually describes the intended process Not every real condition that determines whether the order can start on a particular machine during a particular shift with the current mix. It knows the plan. It may not know the condition of that plan. Now zoom into the shop floor and your MES knows a different set of facts. It tracks work as it moves through operations. Order progress, actual quantities, labor activity, quality events, non-conformance, work instructions, and exactly where an order stopped. That gives production a much more current view. If an order completed machining but waits for inspection, the MES knows that. If a batch failed a check, an operator recorded a reason code, or a routing step needs rework, that information lives close to execution. For mixed feasibility, those facts change the starting point of the next planning decision. A work order isn't just open or closed, it sits somewhere in the root. But an MES may not hold the wider demand picture, the full material supply position, or the commercial priority behind every order. It might know that a machine can execute an operation, while the rule about customer approval for an alternate process lives in engineering documentation or an ERP master data record. Execution context is not the same as end-to-end planning context. That's the distinction you need to keep in mind. Then there's IoT, the machine data layer. It collects machine states, counts, alarms, cycle signals, energy readings, and other operational events from equipment and sensors. For a production team, this is often the closest signal to what equipment is doing right now. Machine data can tell you a resource stopped, slowed down, or completed a cycle. It can show a condition changed before anyone records it manually, which supports real-time visibility, maintenance work and better estimates of actual process performance. But a machine signal doesn't know why an order matters. A cycle count can't tell you which customer commitment depends on the part. An alarm doesn't know whether the order requires a scarce fixture later in the route. A machine state may show available time, but that time is unusable because the required material, operator approval or downstream test slot isn't ready. Raw signals need business and production meaning wrapped around them. This is where teams run into a frustrating gap. ERP says the order should run. MES says where it currently sits. IoT says what the equipment is doing. Each system can be right. And the planner still can't answer a simple question. Can we accept this demand without putting existing commitments at risk? The answer sits between the systems. Connecting data feeds helps, but a connection alone doesn't settle the meaning of the data. You need common identifiers, agreed definitions and rules that link an order to its operations, required resources, materials, tools, people, and current execution state. Otherwise, you've connected the dots between IT and OT, but nobody knows which dots belong to the same production decision. As a Microsoft MVP, I spend a lot of time working with Azure, Microsoft Fabric, Power BI, and AI in industrial architectures. Those platforms can help collect, govern, and analyze data across business and shop floor systems. They don't replace the manufacturing logic that describes how work can actually flow. ERP remains the source for demand and supply. MES stays close to production execution. IoT stays close to equipment behavior. Maintenance, quality, tooling, and workforce systems each carry another part of the answer. The job is not to force every fact into one source system. The job is to create a trusted planning view that uses the right facts from each system at the right time with clear ownership of what each fact means. Only then can you test whether the product mix fits the factory you have this week, not the simplified factory implied by a capacity total. And even when all those records sit in one data platform, there's still a missing piece. Data tells you what exists. Production context explains how those things depend on each other. Data does not equal production context. Bringing records together doesn't automatically create a usable production model. You might have an order number from ERP, an operation record from MES, a machine event from IoT, and a quality result from another system. All of those describe something real. But a planner still needs to know whether that specific order can move through its required route using the right resource under the conditions that apply now. That relationship is production context. Think about an order for a configured product. The order record gives you the quantity and due date. The routing gives you the intended operations. A machine record shows that one possible resource has free time. None of that proves the order can run there. Maybe the resource needs a fixture that's already assigned elsewhere. Maybe only one approved operator can run that process. Maybe the alternate route only applies to a certain material group. or revision. Maybe the order must pass a test step before a downstream operation can start. The records exist. The dependency chain remains unclear. That's the difference between a data collection and a production model. A data collection can answer what orders are open. A production model can answer if I release this order now, what does it consume? What does it block? and can it still finish by the promised date? For product mix decisions, you need the second answer. Now, people sometimes use the term digital twin, and I think it helps to be precise. A digital twin for planning doesn't have to be a 3D model of a factory with animated forklifts. That looks impressive in a demo, but it doesn't solve a scheduling decision. An operational digital twin describes the factory in terms that the decision needs. It connects a product to its process, each process step to approved resources, and captures the constraints around those resources. calendars, setup rules, tools, qualifications, materials, and quality conditions. Then it links that planned model to the current state coming from production. In practical terms, it gives the planner a working answer to a simple question. What can run, where, when, and under what limits? A knowledge graph can help here because it models relationships directly. Instead of storing each fact as an isolated row that someone joins later, the graph can represent the links between product, process, resource, tool, person, material, and order. Take a machining operation. The model can state that product family A requires operation 30, which runs on machine group B, but only with fixture C. Fixture C supports a limited set of variants and requires periodic service. And on the night shift, only certain people hold the qualification to set it up. Now, the planning logic has something concrete to work with. The point isn't that every factory needs to build a graph database on day one. The point is that the relationships must exist somewhere in a governed form. a semantic model, a digital twin model, a specialized planning system, or some combination. What matters is that the logic doesn't live only in someone's head. This also means the context model needs ownership. Engineering owns which routing and revision apply to a product. Production owns realistic setup and resource rules. Quality owns inspection requirements. Maintenance owns asset availability and planned work. Workforce leads own qualifications and shift coverage. A model without owners drifts quickly. Changes need control too. If engineering approves a new alternate route, The planning view needs to know when it becomes valid, for which products and what conditions come with it. Same thing if a tool leaves service or a qualification expires. Otherwise, the system produces a clean answer from stale rules. That's worse than an obvious gap, because people may trust it. There's also a useful discipline in separating facts from assumptions. A required fixture is a fact. A likely setup duration is an assumption. A quality hold could be a known root step, but its exact duration varies. When the planner reviews a feasibility result, they should see both the hard restrictions and the assumptions that shaped it. Then people can challenge the right part of the plan. This is where data work becomes operational work. You aren't collecting more records because a platform can store them. You're building a shared representation of how the factory produces, so a product mix decision reflects the factory's real limits rather than a broad capacity total. Once those relationships are clear, you can follow the information from source systems into a practical planning architecture. A practical architecture for mix feasibility. Once you've defined those relationships, the architecture starts to make sense. You're not trying to build one giant system that owns every production fact. Instead, you're creating a planning flow that brings the right facts together, applies the right rules, and gives people a clear reason for the answer. Here's where it gets practical. Start at the source. ERP gives you demand, order dates, product structures, plant material supply, and the approved business level route. MS brings the current state of work already on the floor. What's started, what's completed, what's waiting, and where quality or rework changed the original path. Maintenance systems add asset status and planned windows. Quality systems add inspection rules, holds, and release status. Tooling records tell you whether a fixture, mold, or gauge is available. Shop floor signals give you current machine state and recent process performance. Each source owns its own facts, and that distinction matters. You don't want a planning layer quietly rewriting a maintenance record or an analytics model becoming the unofficial source for engineering routing changes. The architecture needs clear boundaries because planning decisions are only as credible as the data ownership behind them. Azure and Microsoft Fabric handle this well. They give you a governed data and analytics layer where records from ERP, MES, quality, maintenance, and OT systems come together with shared IDs, controlled access, history, and traceability. Collecting those records is just the first step. Next, you need a semantic model. Think of it as a shared set of business meanings. A planner, production lead, and finance team can all talk about the same order, operation, resource, and due date without each team applying its own hidden definition. For mixed feasibility, that semantic model connects an order to the operations it requires. Each operation links to approved resources, resource calendars, process times, setup conditions, required tools, worker qualifications, material availability, and any restrictions that decide whether that operation can happen. That model turns records into a planning question. Take an incoming order. the model traces the product revision, its route, the operations still required, the approved machine groups, the resource calendars, the current work already reserved on those resources, and the constraints that could prevent the order from moving. That's a much better starting point than asking whether a work center still shows open hours. Here's a practical choice. The semantic model doesn't need to perform every scheduling calculation itself. Its job is to provide a trusted description of the factory and its current state. A specialized finite scheduling simulation or optimization engine can then apply production rules and test whether the mix fits through the available resources over time. That separation keeps the architecture honest. Microsoft fabric stores and governs the data. Azure handles integration, processing, security, and AI services where they fit. A scheduling engine calculates sequences, finite resource allocation, alternate routes, and constraint conflicts using production logic built for that job. No single layer replaces the others. Power BI then helps explain the result. It shows planners and leaders where the load appears, which due dates face risk, what constraint blocks a proposed order, and how one demand scenario differs from another. But Power BI alone doesn't create feasibility. A report can show where the load is, but it can't resolve the conflict just because the visual looks tidy. The feasibility answer comes from the underlying rules, the time-based resource model, and the scheduling or simulation logic that tests the plan. That distinction prevents a common failure mode. building a very polished dashboard around a capacity calculation that still assumes every product can run anywhere, at any time, with any available person and tool. The dashboard may be accurate about its input. The input may still describe a factory that doesn't exist. The architecture also needs a feedback loop. Once the schedule releases, MES and shop floor signals return actual progress, delays, quality events, and resource status to the planning view. Planned assumptions get checked against what the factory actually experienced. Over time, that lets the organization improve the standards that affect decisions. It doesn't mean chasing perfect data for its own sake. It means correcting the assumptions that repeatedly cause the feasibility answer to differ from the weak production actually lives through. So the flow runs from source systems into governed data, through a shared context model, then into specialized decision logic, and back again through execution feedback. That gives planners something far better than a green capacity bar. It gives them a reasoned view of whether the proposed mix can move through the factory under the conditions that apply right now. And once that architecture exists, people often group simulation, optimization, and AI together. But they shouldn't. Each one answers a different question. Simulation, optimization, and AI solve different problems. Once the planning architecture can describe the factory, people often lump simulation, optimization, and AI together, and I get why. All three support production decisions, but they do different jobs. Start with simulation. It asks, if we run this proposed mix under these rules, what's likely to happen? You give it a demand mix, process routes, resource limits, shift calendars, setup rules, and the current work in progress, and then it simulates how orders move through that model over time. Where does work wait? Which due dates face risk? Which resource builds the longest queue when the sequence changes? Simulation doesn't declare one answer best. It helps you understand the behavior of a proposed plan. That's useful when the factory deals with variation. Say a planner wants to test whether a new order can fit. They run one case with normal setup times, then another where a changeover takes longer or a shared test station loses part of a shift. The result doesn't predict the future perfectly, but it shows how much room the plan has before it breaks. A plan that fails under a normal, credible disruption deserves a different conversation. Optimization asks another question. Given the rules and goals, can we find a better feasible plan? The word better matters. Better according to what? Shorter lateness, more on-time shipments, lower setup demand, higher contribution from constrained time. You need to state the goal, because the system won't guess the commercial trade-offs that leadership hasn't decided. A finite scheduling engine searches through sequences and resource assignments that would take a planner far too long to test manually. For example, it can check whether order A should use one approved route while order B uses another, and group compatible work to reduce changeovers while still respecting dates and capacity limits. But the engine only works with the rules it receives. If the model claims two products can run on the same machine with the same tool, the optimizer will trust that. And if it ignores a qualification rule or material hold, it may produce a schedule that looks efficient but fails on execution. Optimization is disciplined search. It isn't factory wisdom. Now bring in industrial AI. It can help forecast demand patterns, estimate risk from past behavior, detect unusual machine conditions, classify quality signals, or flag orders at risk based on current execution data. Those are useful because they deal with uncertainty, patterns, and large volumes of operational information. For example, an AI model might detect that a product family takes longer after a particular changeover pattern, improving the scheduling model's assumptions. Or it might identify that an asset's recent behavior differs from the plan, prompting a new scenario test. AI can inform the planning decision, but it doesn't replace the need for production rules. Generative AI sits in a different spot. A co-pilot style assistant can help a planner ask questions in plain language, retrieve orders affected by a constrained test resource, explain why a scenario creates late work, or point out changed assumptions. That can save time, especially when the underlying data and context model are trustworthy. Still, I'd be careful about asking generative AI to create the production schedule on its own. It works by producing likely language or structured output from patterns and context, while finite scheduling depends on explicit constraints, time windows, and repeatable rules. One explains and explores, the other must prove whether work actually fits. You can use both together. The scheduling engine calculates feasible options, simulation shows how those options behave under credible variation, and AI detects risk and improves estimates so people can explore the result without manually digging through records. Then the planner and production team decide what to do. Before trusting any AI recommendation, Ask, does it know the approved route for this revision, that the fixture is unavailable, that the material is on quality hold, or that the night shift lacks an approved setter? If the answer is no, the recommendation may sound informed while missing the constraint that decides the outcome. That's not an argument against AI. It's an argument for putting AI in an architecture with facts, context, and clear limits. The next step is turning that architecture into a planning process people can use before sales promises a date and before production releases work that the factory cannot finish. A better mixed feasibility process So here's a better approach to mix feasibility. You start before anyone freezes the weekly schedule, and instead of treating one forecast as a promise, you treat it as one demand scenario among several the factory might need to handle. That sounds like a small change, but it completely changes the conversation. Instead of asking whether the plan fits a single forecast, you ask what happens if demand shifts toward a difficult family, an urgent order arrives, or a customer changes the required date. Planning turns into a test of choices, not a defense of one number. You start with firm demand, then layer in what's likely possible or still under discussion, and you keep those categories clear because nobody benefits when a tentative sales opportunity quietly enters the production plan and later gets treated as a customer commitment. For each scenario, you check the production facts that decide whether work can flow. Current route, planned process times, resource calendars, setup needs, tool availability, skills by shift, and material assumptions. You're not verifying every master data field in the company, just the facts that can change the answer to the decision in front of you. A feasibility process needs explicit assumptions. Record a material delivery date as uncertain if it is. If a route can use an alternate machine only after engineering approval, don't count that machine as open capacity until that approval exists. And if a standard time no longer matches the product revision, flag it before the order creates a problem on the floor. The goal is visible reasoning, not false precision. Next, run a finite check before you promise a date or release the work. Finite means each order consumes time on a real resource within a real calendar, competing with all other orders for that resource, and the system respects the conditions you've chosen to model. But the result should not just say yes or no. A useful result tells the team where the pressure lands, when it lands, and what that pressure does to the rest of the plan. Perhaps the new demand fits if a batch runs in one campaign, or it fits only if a qualified setter covers a later shift. or perhaps it misses because one test step becomes overloaded for two days, even though the main production area still looks open. Those are very different decisions. When you compare scenarios, don't reduce everything to total machine load. Compare constraint demand over time, likely flow time, delivery risk, work in progress, and the expected margin effect, because the choice with the highest apparent revenue may produce a poor operational result if it creates late committed work, extra overtime, or a queue that takes weeks to clear. You need to see the trade-offs together. Now that also means the process can't belong only to planning. The planner may own the schedule, but sales owns part of the demand decision, production knows whether the sequence is workable, supply chain knows the material risk behind the dates, and finance can frame the cost and return. Each group needs the same starting model, even when they reach different conclusions. Picture an exception meeting around a late customer request, where instead of debating whose capacity number is right, the group sees a few feasible paths and the conditions attached to each one. accept the order and delay lower priority work, accept part of it with a later balance, use an approved outside process, or change the sequence and accept more setup effort. Then someone with the right authority chooses. That human decision remains part of the process. A system can calculate that one option protects due dates while another protects margin, but it can't decide what the business should value most in a specific commercial situation unless leaders have already set that rule. And sometimes they shouldn't set one fixed rule because a long-term customer issue, a contractual commitment, a product launch, or a supply risk may justify an exception, and the feasibility model doesn't remove judgment. It stops judgment from operating without a clear view of what each choice costs in capacity, time, and risk. Keep the process close to the rhythm of the factory and refresh the current state from execution data, rechecking scenarios when a material date moves, an asset becomes unavailable, a quality hold changes, or demand changes enough to affect the shared constraint. Don't rebuild the whole plan for every minor event, but don't wait until the weekly meeting when a known change has already broken the schedule. The process should match the decision speed you need. A practical mix check is a repeatable way to answer a simple question. Given the orders we have, the conditions we know, and the limits we accept, what can we genuinely commit to? It's not another report ceremony. Once that question becomes routine, the next issue is scope. And you don't need to model every product and every resource. before you can make one difficult mix decision better. Start with one product family and one constraint. You don't need a factory-wide model before you can improve a real planning decision. Start where the current process repeatedly creates pain. A product family that creates late orders, a resource that always attracts escalation, or a queue that production can see but nobody can explain early enough. Keep the first scope narrow. Pick one product family with enough repeat volume to learn from, but enough variation that the mix changes the result, then choose the shared resource that most often controls whether that family moves on time. It could be a test station, a furnace, a coating booth, a machining cell, or a final inspection step. Choose the problem people already recognize. Say a plant produces a fairly stable core range alongside configured variants, and the main work centers look manageable in the weekly plan, yet the configured variants repeatedly build a queue in one test area. Planners react by moving orders, Production adds hours and customer service reacts when the dates start slipping. That test area gives you a practical starting point. Set a planning horizon that matches the decision. If sales needs to decide whether to accept demand for next week, don't model the entire year. Use a period long enough to include current work in progress, the committed orders that compete for the resource, and the downstream dates that the decision could affect. The first question can stay simple. Given this family and this shared resource, can this proposed mix finish when we say it will? Build the minimum product process resource model from facts you already trust. List the variants in scope, link each to the operations it needs, identify which work reaches the selected constraint, how long it normally stays there, which tools or approvals apply, and when the resource can actually process the work. You're building a decision model, not a museum of master data. Include the current work already in the system because a feasibility check that starts with an empty resource calendar rarely tells you much about Monday mornings. Capture the orders already waiting, already running, or due to arrive at the constraint during the horizon. And then you can test a proposed mix against the work the factory has already promised to complete. Start with a small set of rules. Perhaps some variants require a specific fixture, the resource needs a changeover between product groups, or one shift cannot run a certain test without qualified cover. Add the rules that repeatedly change the plan, not every possible detail that might exist somewhere in documentation. A model earns trust by explaining the decisions people face. Historical testing helps here. Take past weeks where the product mix created a visible queue or caused delivery dates to move, feed the known order mix into the model using the rules and dates that applied at the time, then compare the result with what production experienced. Did the model point to the same constrained resource, show pressure in roughly the same period, and identify which variants competed for the limited time? You shouldn't expect a perfect replay because shop floor work includes interruptions, judgment calls, and changes that nobody recorded cleanly. But if the model consistently misses the problem people remember, don't add a dashboard and call it done. Find out which planning fact is absent or wrong. Maybe standard times need work, the tool rule never entered the routing, or the resource calendar treats an unavailable shift as open. Those gaps tell you where better data can change an actual decision. That's a much better reason to improve data than simply because a field exists. There's a human side to this as well. Bring the planner, the production lead, and the people closest to the selected constraint into the first model review, because they'll often spot an assumption that looks harmless in a system, but creates trouble in the real process. Listen carefully when someone says, that only works if... That phrase usually points directly to a constraint worth modeling. Don't try to win the first project by proving that every order can be scheduled automatically. Win it by helping the team answer one recurring question with less guesswork, less manual checking, and fewer surprises after release. If the model can show why one mix fits and another does not, it has already changed the conversation. From there, expand only when the next constraint genuinely affects the decision, and the scope can grow with evidence rather than turning into a long data project that loses contact with the production problem it started with. Ownership, data quality, and change control. Here's the real challenge with building a planning model that actually works in practice. Once it starts influencing real decisions on the floor, somebody needs to own each piece of it, not in that vague sense where everyone owns the data. because we both know that just means nobody can fix it when a planner spots a problem on a Tuesday morning. You want a named owner for every planning fact. Engineering owns product routes, approved alternates, and the date when an engineering change becomes active. Production owns the practical rules around setups, resource use, and what a process can actually handle. Tooling, maintenance, quality, workforce. Each team needs a clear scope for the facts they control. Now, that doesn't mean one person has to manually maintain every record. It means people know who can confirm a rule, who can approve a change, and who has to act when the schedule depends on data that doesn't match what's happening on the floor. Take a standard process time. It starts as an engineering estimate, and then production learns through repeated runs that a newer variant actually takes longer at a certain operation. If that difference changes which product mix can fit, the team needs a real path from observation on the shop floor to reviewed planning data. Otherwise the planner just keeps compensating in private and nobody knows the model is drifting. The feedback loop has to be simple enough to use under pressure. An operator, team lead, or scheduler should be able to flag that a setup duration, routing, tool condition, or resource rule no longer fits the work. The right owner reviews it, checks the evidence, and either changes the model or explains why the current rule still holds. A complaint without a resolution path just becomes another note in someone's inbox. Engineering changes need extra care because a routing rarely changes in isolation. A new product revision might use a different material, require a new inspection step, add a tool, or permit an alternate machine under specific conditions. The planning model needs to know not just the new route, but when it applies and which open or future orders it affects. A route marked as approved isn't enough when the new fixture won't arrive until next month. Version control gives the team a way to trace those decisions. When a feasibility result changes, people should be able to ask which routing version, calendar, setup rule, and resource state shaped that answer. That doesn't mean turning planning into a paperwork exercise. It means you can explain why the answer changed instead of restarting the argument from scratch. Traceability protects both the planner and the floor. It also helps to separate constraints from assumptions. A qualified person required for a regulated process is a hard constraint. A setup expected to take four hours based on recent work is an assumption. Material on a quality hold is a hard constraint until release. While a supplier delivery date might be a planning assumption with a stated confidence level, those categories should not blur together. When leaders review a product mix scenario, they need to see where the plan is actually blocked and where it depends on a judgment call. If a scenario works only because a supplier meets an uncertain date or because an experienced setter stays late, that needs to appear clearly in the result. A feasible plan with hidden assumptions is just a polite form of surprise. Data quality also needs a practical standard. You don't need every field completed to build a useful model. You need the data that changes a production decision to be accurate enough, current enough, and owned by someone who can answer for it. That puts the attention in the right place. Fix unused attributes with poor data when they become relevant. But if the calendar for a constrained resource repeatedly misstates available time, deal with that first. And if tools appear available in a system while they sit in repair, the mix decision will keep failing no matter how tidy the rest of the data looks. is about fitness for the planning decision, governance often sounds like a monthly meeting with a slide deck and a long list of actions. That's not the kind of governance this work needs. It needs everyday discipline, a clear owner, a visible change, a review path, and a way for execution to correct planning facts. The model stays useful only when it stays connected to the work. As the scope grows, this discipline becomes even more important. Without it, a planning model gradually turns into another static record of how people once believed the factory operated. With it, the model can keep pace with new products, changed routes, repaired tools, skill changes, and the normal mess of production. The aim isn't perfect data. It's a planning model that changes when the factory changes, before the next capacity report tells everyone they're green again. Common ways mix planning goes wrong. Once you start putting ownership and change control around the model, a few recurring mistakes become easier to spot. Most of them don't come from careless people. They come from planning shortcuts that work often enough until the mix changes and exposes the assumption underneath. One mistake is treating average capacity as a delivery commitment. A monthly report can show that a work center has room overall, while the actual orders compete for the same narrow time window, the same process step, or the same setup sequence. Average load answers a screening question, but it doesn't answer whether individual orders can finish on their promised dates. Think about a resource with open time late in the week, while most of the mix needs it before Wednesday. The weekly total might fit, but the customer dates don't. If someone accepts demand based only on that weekly number, Production inherits a problem that no amount of calendar arithmetic can solve. Time matters as much as hours. Another mistake is assuming an alternate resource solves an overload. On paper, a second machine may carry the same operation code. That can be useful, but it doesn't mean the product can move there today. The alternate route might need a fixture that isn't free, a program that hasn't been released, an operator with specific qualifications, or quality approval for that product revision. Sometimes it can run there, but at a different rate with more scrap risk, or only after a change that disrupts another planned job. An alternate resource is an option only when its conditions are true. Teams also release more work when queues start growing. It feels like a sensible response because the floor needs work, and managers don't want people or machines waiting. Yet when work already waits at the shared constraint, releasing more of the same mix usually adds more work in progress without increasing completed orders. The queue gets deeper, and priorities become louder. That behavior often comes from local measures. An upstream area sees open time, so it keeps producing. The constrained operation is sees more material arriving than it can process. Supervisors then spend their day sorting, moving, and escalating while the schedule loses any stable order. The factory stays busy, but delivery still slips. Then there's the mistake of talking about AI before you have usable factory constraints. Someone asks for a co-pilot to recommend the best mix or a machine learning model to predict the schedule. Those tools may help later, but they can't repair a missing root rule, an unknown fixture limit, or a calendar that claims a skilled operator is available when they aren't. The system needs a model before it needs a clever interface. If the model doesn't state which products can run on which resources, under what conditions, then an AI tool can only make a polished guess. A confident explanation of an impossible plan remains an impossible plan. The language may sound better than the old spreadsheet, which is not the same thing as improving the decision. There's some dry irony there. We'll ask generative AI to explain the factory before we've explained the factory to ourselves. The last mistake is measuring a planning project by the number of system connections. Teams may connect ERP data, MES events, maintenance records, and machine signals then declare progress because more data now flows into one place. Data movement isn't the outcome. The test is whether a planner can make a better choice before releasing work. Can they see that an accepted order consumes the last usable slot at a constrained process, test an alternate route, and see the tool, skill, and approval conditions attached to it, and give sales a date that reflects the actual production path? If those questions still require phone calls, private workbooks, and a meeting to reconcile conflicting numbers, the integration work hasn't reached the decision yet. That doesn't mean the project failed. It means the next task is clear. Move from connected records to governed production logic, then judge the work by fewer avoidable schedule changes, clearer exception decisions, and a plan that the floor can recognize as real. The planner's job changes once that model exists. They no longer spend all their time proving why the plan can't work. They can show the choices and let the business decide which consequence it's willing to own. The planner's decision changes when the model exists. Think about it this way. It's Tuesday afternoon. Sales just dropped a late demand increase for a high margin product family, and the customer wants delivery inside the current planning window. Without a detailed mix model, the conversation starts with a capacity report. Someone spots unused hours on a machine group and says the plant can handle it. The planner knows that answer is probably wrong, but proving why takes half a day of calls, checks, and manual changes. And that's if they're fast. Now, with the model in place, the planner starts somewhere else entirely. They add the proposed order to the current plan with its actual product revision, route, due date, quantity, material status, every condition attached to its process steps. Then the system tests the consequence against work already committed. Maybe the order fits, but only if it uses the shared test resource during a narrow slot on Thursday, and that pushes two existing orders beyond their promised dates. or perhaps it fits through machining, but the required fixture is already tied up with another commitment and can't support parallel work. So the answer becomes specific, and the planner now compares real options rather than arguing from a single capacity total. They can accept the full order, defer it, accept only part, use a permitted substitute if product and customer rules allow, send a process step to an approved outside supplier, add a shift, or change the sequence and accept the extra setup time. Each option carries a cost and a condition. For example, adding a shift might create enough time at the constraint. but only if qualified people can cover it and the material arrives on time. Outsourcing might protect internal flow, but it adds cost and introduces another supply risk. Deferring the request may protect existing commitments, though sales could lose an opportunity the business wants to pursue. Nobody gets a free option, that's the whole point. A good model also exposes the downstream effect. It doesn't stop at the first overloaded resource, It traces the proposed work through the entire remaining process, showing which orders lose their place, which delivery dates move, which tools become unavailable, and where the plan depends on uncertain conditions. That changes the tone of the meeting. Instead of production saying no and sales challenging the number, the entire team sees the same choices. They ask whether the customer will accept a split delivery, decide whether overtime is justified, protect a prior commitment and negotiate a later date, or accept the risk openly if the order carries a wider commercial reason. But here's the thing. The decision still belongs to people. A planner shouldn't become the person who decides which customer matters more. And a scheduling engine shouldn't quietly choose between a contract, a long-term relationship, and a high-margin urgent request, just because someone set a weight in a model months ago. The model informs the choice. It doesn't own it. So the result needs to show its assumptions alongside its recommendations. If the order fits only if a supplier meets a planned date, say it. If it depends on a setup duration drawn from limited history, show it. If the system lacks current tool status, don't bury that gap behind. a green status. Uncertainty needs a place in the decision. I think that's where many planning projects either earn trust or lose it. People don't expect a system to know everything, but they do expect it to admit what it knows, what it assumes, and what it cannot confirm. A model that shows its limits gives experienced planners room to apply judgment. Say the planner presents two feasible paths– One protects the new order, but creates a delivery risk for a committed customer. The other protects current dates, but requires the new customer to accept a later delivery. The system shows the resource demand, sequence impact, and stated assumptions for both. A commercial leader then makes a commercial choice with operational facts in front of them. That's a better use of technology than asking a dashboard to declare there is capacity, or asking AI to produce a confident answer from partial context. The planner moves from defending a schedule to framing a decision that people can understand and own. and the factory receives a plan with an explicit choice behind it. Not another urgent order that arrives on the floor with no one willing to explain what it displaced. Available capacity is not a feasible product mix. A capacity report still has a place. It can screen demand, show broad pressure, and tell you where to look first, but it cannot promise that a proposed product mix will actually run. Feasibility depends on the product, the process it needs, the resource and time available, and the conditions around that work, in other words, the constraints that turn nominal hours into actual production choices. When you test those conditions before release, you reduce schedule churn before it reaches supervisors, operators, and customers. You give sales and operations a shared way to discuss what a new order will displace. A green capacity report can still describe an impossible production week. So if you're working through this in your own plant, I'd like to hear how you test product mix feasibility before you commit a customer date. That's where the rubber meets the road, and it's the place where a good model earns its keep.