Common production planning mistakes

The short answer

Most production planning failures are not exotic. They come from a short list of avoidable mistakes, and almost all of them trace to one of two root causes: feeding the plan bad inputs, or ignoring what the plan tells you. Get the inputs right — real net demand, real capacity, a current BOM, accurate stock — and MRP does its job: it tells you exactly what to make, what to buy, and when. Get them wrong and the same engine confidently produces a plan the floor cannot run.

This guide walks the seven mistakes that do the most damage, in the order they tend to compound — each with the mistake, why it hurts, and the fix. The thread running through all of them is that production planning software earns its keep only when demand, BOM, stock and capacity live in one connected model instead of disconnected spreadsheets — and when the shop floor feeds real numbers back into the next run.

1. Planning against gross demand, not net

The mistake. You order material for the whole demand quantity of a finished good — without subtracting the stock you already hold, or the material already inbound on open purchase orders and open work orders. The plan assumes you start from zero every time.

Why it hurts. It goes wrong in both directions at once. You over-order items already sitting in stores, tying up cash; and you miss shortages hiding behind open POs — an item that looks covered because a purchase order is due, until that PO slips and the plan never flagged it. Gross-demand planning is the commonest way a plan is at once too fat and too short.

The fix. Net properly. The correct requirement is gross demand minus stock on hand, open POs, open work orders and reserved stock — level by level as the BOM explodes. That is exactly what BOM explosion and netting does, so what you buy and make is only the genuine shortfall. The companion guide on preventing material shortages works the netting logic through end to end.

2. Ignoring capacity — infinite loading

The mistake. You run MRP, get a clean set of work orders, and release them without checking whether the machines can physically run the quantities in the time available. MRP on its own is an infinite-capacity calculation — it assumes any quantity can be made whenever needed.

Why it hurts. The plan looks feasible on paper and collapses on the floor. Work piles onto a bottleneck machine that cannot clear it in the window, the earliest due dates slip, and once a plan misses dates twice the shop stops believing it and reverts to firefighting. Infinite loading is how a technically correct MRP run produces an operationally impossible schedule.

The fix. Load finite. Lay the suggested work orders against each machine's available hours and read the percentage loading, so an overload is visible before release, not after a job is late. Machine loading and capacity shows daily load, % loading and projected availability per machine; anything over 100% gets levelled or re-sequenced on the Gantt schedule first. The guide on work-order prioritisation covers how to set and hold that sequence.

3. Stale BOMs and mistyped references

The mistake. The plan explodes an out-of-date Bill of Materials — an engineering change never applied, an old revision still live, or a component reference mistyped when the record was created.

Why it hurts. The explosion is only ever as good as the BOM it walks. If the structure is wrong, MRP plans the wrong quantity of the wrong item with complete confidence, and you discover the drift when the floor is short. There is a subtler trap underneath: on the shared platform the links between a plan, its work orders, purchase requisitions and stock reservations are stitched by reference-type string literals, not database foreign keys — so a single mistyped reference does not raise an error, it silently breaks the link and the connected record goes missing from the plan.

The fix. Treat BOM and engineering-change control as a disciplined step, not a typing convenience. Keep the BOM and ECNs current, and verify references at creation because nothing downstream will warn you if one is wrong. The explosion and netting engine reads the same item master and BOM that production uses, so a change applied once shows in the very next run.

4. Netting off inaccurate live stock

The mistake. The netting step subtracts a stock figure that does not match the physical shelf — receipts not yet booked, consumption not yet posted, or a stores count that drifted weeks ago.

Why it hurts. Netting is a subtraction, and the number you subtract has to be true. If the system thinks you hold 400 and the shelf holds 40, MRP nets off stock that is not there and plans a shortage into existence — the work order starts and stops for want of material the plan said was covered. Overstated stock creates phantom coverage; understated stock triggers needless buying. Either way the plan inherits the error and passes it to the floor.

The fix. Keep inventory live and accurate, and net against it in real time rather than a periodic snapshot. Because planning, production and inventory sit on one shared database, every MRP calculation reads current stock directly — no export, no overnight sync, no reconciliation window for the number to go stale. The production, inventory and purchase integration means a receipt or consumption posts once and the next netting run sees it immediately.

5. No plan-vs-actual feedback loop

The mistake. The plan uses standard cycle and setting times entered once, hopefully, and never compared against what the floor actually takes. Nobody books real actuals back, so the plan never learns.

Why it hurts. Optimistic standards repeat forever. If an operation genuinely takes twelve minutes but the routing says eight, every plan built on it promises 50% more than the machine can deliver — and plan attainment sits stubbornly below 100% while everyone blames the floor for a number the plan set wrong. Without a feedback loop the same over-optimism is baked into next month's plan too.

The fix. Book actuals at source and feed them back. When operators capture start, end and quantity by barcode at the machine — rather than a clerk reconstructing the shift from memory — you get real cycle times to replace the optimistic standards, and attainment climbs because the plan finally asks for something achievable. IoT and machine-data capture collects the events; plan-vs-actual, utilization, efficiency and OEE dashboards turn them into the numbers that correct the next run. The reporting side is covered in the guide on planning reports and KPIs, and the machine-level levers in improving OEE and machine utilisation.

6. Double-allocated stock

The mistake. Two plans, or two orders, both count the same physical inventory as available. Each nets it off, and each assumes the units are theirs.

Why it hurts. The stock existed on paper for both, but it can only be consumed once — so a phantom shortage appears when the second work order reaches for material the first already took. It is a quieter cousin of inaccurate stock: the number was right, but promised twice. In a busy shop running several concurrent plans, double allocation is one of the hardest shortages to diagnose because every report says the material was there.

The fix. Reserve stock against a plan. Committing specific inventory to a specific plan — through the stock-reservation entry (MRPReserveStockUpdate.aspx) and its report — means a second run cannot net the same units again, and the report shows exactly which inventory is committed to which plan. It is visible netting: nothing is promised twice, and that transparency is what makes concurrent plans trustworthy.

7. No reorder safety net and spreadsheet silos

The mistake. Planning runs in disconnected spreadsheets — demand in one file, the BOM in another, stock in a third, machine load in a fourth — reconciled by hand and emailed around. Between formal runs nothing automatically watches stock, so shortages surface only at the next cycle.

Why it hurts. Every file export is a chance for the numbers to diverge, and they always do: the buyer's stock sheet is a day behind the plan, the supervisor's load sheet never saw the last two orders. The plan is only as coordinated as the last manual reconciliation. Worse, a fast-moving item can drop below its reorder point mid-cycle and nobody notices until the line stops, because nothing was watching.

The fix. Two things. First, a live reorder-level dashboard that continuously watches free stock against each item's reorder point and suggests a purchase requisition the moment one breaches — the day-to-day safety net between runs, independent of any formal MRP cycle. Second, one shared item, BOM and stock master that production, inventory and purchase all read, so there are no file exports to drift apart. On the shared platform the production, inventory and purchase modules read the same tables the sales and production plan nets against — no interface, no copy, no reconciliation.

The seven mistakes, and the fix for each, at a glance:

A quick self-audit before you release the next plan:

• Is this plan netting against live stock, open POs, open WOs and reservations — or against gross demand?
• Have I checked finite machine loading, or am I releasing to infinite capacity?
• Is the BOM current, and are the plan-to-WO-to-PR references intact?
• Are the standard times in the routing the real ones the floor books, or last year's hopeful figures?
• Is any stock in this plan already reserved to another plan, and is the reorder dashboard watching the gaps?

Seasonal demand, job-work and India-specific traps

Two mistakes recur specifically for Indian manufacturers, on top of the universal seven. The first is ignoring seasonal and festival demand. Demand around Diwali, the wedding season or a fiscal year-end is not noise — it is a predictable surge, and a plan that treats every month as average under-buys long-lead material and firefights exactly when the peak arrives. Fold the seasonal pattern into the sales plan so the netting run orders long-lead items ahead of the surge, not during it.

The second is outsourced job-work lead times. A large share of components are sent out for plating, heat treatment or machining, and those outsourced (OSL) work orders carry lead times that belong in the plan as much as machine load. The component plan already splits the netted make requirement into in-house semi-finished (SFG) and outsourced (OSL) lines, so plan for the OSL round-trip rather than assuming it is instant. There is a compliance angle too: goods sent to and returned from a job-worker are reported through the ITC-04 return under GST, so the movement has to reconcile with what the plan sent — confirm the treatment and thresholds with your CA, and never treat a planning report as tax advice. Indicative INR pricing for the planning module is on the pricing page.

How Fast Planning avoids these

Fast Planning Software — built by Improsys in Pune under the Fast Technology brand, cloud or on-premise — is designed so the seven mistakes are hard to make, because demand, BOM, stock, capacity and actuals all live in one connected model on a single database.

Frequently asked questions