Closing the Loop from Shop Floor to Plan in EDGEBIC

A schedule is only alive if reality flows back into it. In EDGEBIC by User Solutions, the shop floor feedback loop closes that circuit: an operator punches real work at the kiosk, the punches roll up into daily actuals, the planner reschedules so remaining work plans forward from the real position, and a fresh dispatch list goes back to the floor. Every turn of that loop re-anchors the plan to what actually happened, which is the difference between a schedule you trust and a document that went stale by mid-morning. This article traces the whole loop, stage by stage.

Most scheduling failures are not failures of the initial plan. They are failures to update it. A shop generates a beautiful schedule Monday morning, and by Monday afternoon a machine ran long, a part was late, and a rush job jumped the queue, and the plan on the wall describes a factory that no longer exists. The feedback loop is what stops that decay. Here is how EDGEBIC closes it.

Stage One: The Punch (Floor to Data)

The loop begins at the machine. An operator at the shop floor kiosk taps Start Run on the queued job, and if no one has recorded it yet, the operation's actual start is stamped at that moment from the shared clock. Through the run they tap the Good counter per finished piece and the Scrap counter for a reject, picking a reason. When a machine stops, they tap Pause and choose a category. When the operation is done, they tap Complete and the actual end is stamped.

Each tap is a fact written straight into the shared database. There is no separate server and no integration middleware between the kiosk and the planner application: the two are two views of one live dataset. That architecture is why the loop can close without an integration project, a point that matters as much for a five-machine shop as it did for the User Solutions deployments across the 33 locations of a customer like Cummins.

Stage Two: The Rollup (Data to Actuals)

The individual punches do not go straight into the schedule. They roll up first. At completion, EDGEBIC collapses the closed run and rework punches into daily actuals: productive hours and good pieces per calendar day. Setup, pause, and down time are kept separate, feeding downtime and setup-variance reporting rather than the production hours. This is the level the scheduler, the Gantt, and the reports all read.

The rollup is where raw taps become the actuals that steer planning. Good pieces become the day's produced quantity; run hours become the day's logged hours; and through the effective rate each converts to the other. The planner can also log actuals directly for work that could not be punched live, and the two paths produce the same daily actuals. For the planner-side view, see how actuals flow into the EDGEBIC schedule.

Stage Three: The Reschedule (Actuals to Plan)

Now the loop turns back toward the plan. The planner runs a reschedule, and the engine reads the daily actuals to work out where the shop really is. It sorts every operation into completed, in progress, or not started; preserves the completed and logged history verbatim; computes the resume point from the last real finish; and re-plans the remaining work forward from there. The mechanics are covered in how a reschedule uses last night's actuals.

This is the stage where reality reshapes the future. If the night shift finished two hours late, the morning plan reflects it. Completed work does not move; remaining work queues behind reality; promise dates become honest. The reschedule is the moment the floor's data becomes tomorrow's plan.

Stage Four: The Dispatch (Plan to Floor)

The loop closes when the fresh plan reaches the floor. Supervisors read the new assignments from the dispatch view, grouped and ordered, and hand out each person's day at shift start. Because the plan was just re-anchored to overnight reality, the dispatch list is current before the crew arrives, not a stale sheet from yesterday. For how supervisors work this stage, see how supervisors use the EDGEBIC dispatch view.

And then the loop repeats. The crew works the fresh dispatch, punches their real work, and the next rollup and reschedule close the circuit again.

A Worked Example

Follow one job around the full loop over a day.

• Overnight. The mill operator punches a job at the kiosk: Start Run at 22:10, twenty good pieces logged, one coolant pause with its reason, Complete at 03:40. Real finish 03:40, two hours later than the plan expected.
• Rollup. Those punches collapse into daily actuals: the run hours and 20 good pieces land on the day, the coolant pause is kept separate for the downtime report.
• 07:45. The planner confirms the actuals and reschedules. The engine preserves the completed mill step at its real 03:40 finish, sets the resume point there, and re-plans the downstream paint step forward from 03:40 instead of the plan's earlier guess.
• 07:50. The planner prints dispatch. The paint booth's sheet already shows the job arriving later, reflecting the mill's real overnight finish.
• 08:00. The paint operator starts from the fresh sheet and, in turn, punches their real work, beginning the next lap of the loop.

Nothing in that cycle required a person to reconcile the plan against reality by hand. The loop did it.

Why the Loop Is the Whole Point

A plan without a feedback loop is a forecast that ages badly. A plan with one is a living instrument. The value compounds: each turn of the loop keeps the plan within an arm's length of the floor, so nobody is ever working from fiction, and the promise dates you give customers reflect what your shop is actually doing. This is the discipline behind the on-time delivery gains User Solutions customers have seen for over 35 years, from small job shops to programs as large as a Navy carrier overhaul: close the loop, every day.

The loop also depends on the pieces around it being sound. It only works if actuals are logged honestly, so logging first and rescheduling second is the habit that keeps it turning. It only stays clean if completed work is immutable, so history does not get overwritten each lap. And it only stays trustworthy if each operation record is clean, so the data feeding the reschedule is not junk.

Get those right, and the loop runs itself: punch, rollup, reschedule, dispatch, repeat. That is what closing the loop from shop floor to plan actually looks like, and it is the core of good WIP management.

For the complete tour, see the shop floor execution guide, and explore the platform at EDGEBIC.