Run Your Factory Like a Flow Chart: Visual Scheduling in EDGEBIC

Visual production scheduling software replaces the wall of tables with two graphical surfaces that mirror how a factory actually thinks: a routing drawn as a flow chart of connected operations, and a schedule drawn as Gantt bars you can drag, stage, and save. In EDGEBIC by User Solutions, those two surfaces (the graphical routing designer and the scheduler Gantt) are live views of the same scheduling data, so what you draw is what the finite capacity engine plans, and what the engine plans is what you can grab and move.

This pillar covers both halves: building a routing on the canvas (nodes, connectors, sub-assemblies, per-job copies) and reading and editing the schedule on the Gantt (bar states, drag modes, staged saves, and the safety prompts that keep manual edits honest). It draws on the documented behavior of EDGEBIC, the current-generation platform from User Solutions, a company that has helped manufacturers schedule since 1991, including GE, Cummins, BAE Systems, and the US Navy.

The Routing Is the Recipe, and You Can Draw It

Every product EDGEBIC schedules carries a Bill of Routing (BOR): the ordered list of operations that build one unit. Each step names a work center, states its hours, and points at what comes next. Traditionally you maintain this in a grid. In EDGEBIC you can also draw it.

The BOR Designer shows the routing as a diagram: each step is a node, each next-in-sequence link is a connector arrow, and every chain terminates at the end product node. Grid and designer are two views of one routing; switch freely with the Data Grid and Designer toolbar buttons, and anything saved in one is what the other shows.

The canvas layout is simple:

Building a step visually

Adding an operation is four moves: drag a machine from the Toolbox onto the canvas, switch on Draw Connector, drag an arrow from the upstream node onto the new one, and connect the new node onward toward the end product. The arrow you draw is exactly the next-in-sequence value the grid holds; there is no translation layer.

Then fill the numbers in the Properties panel. For a weld step, that might be 0.5 hours of setup time, 0.25 hours required per unit, and zero queue time. The same panel exposes the advanced timing fields when a step needs them: a shift-aware queue buffer after the step, a flow-step overlap lag that lets the next operation start a set number of hours after this one starts, transit days for offsite operations, and lot-streaming transfer batches (covered in depth in what a transfer batch is).

Those fields are not decoration; the engine composes them in a strict order after allocating capacity: allocation end, then queue buffer, then lot-streaming window, then transit delay. A concrete case from the engine reference: a paint step for 100 widgets at 0.30 hours per piece with 1.0 hour setup takes 31 hours in total, but with a 25-piece transfer batch, assembly may begin at setup plus 25 times 0.30, which is 8.5 hours after paint starts, plus a half-hour handling delay. Downstream starts Monday 17:00 instead of waiting until Wednesday afternoon: a two-day overlap you configured with two numbers on a node.

Connectors carry meaning too. Right-click one and you can set its type: Normal (sequential), Parallel (dashed), or True Alternative. A parallel connector attaches a machine that runs alongside the step; a true-alternative connector attaches a machine that can replace it, with the scheduler picking whichever finishes earliest. In the documented two-mill example, when Mill-1 is booked solid for three days and Mill-2 (20% slower) is free tomorrow, the engine evaluates both and routes to Mill-2 because the slower machine still delivers the earlier finish.

For a step-by-step build of a complete routing on the canvas, follow the companion walkthrough: how to build a routing as a flow chart in EDGEBIC.

Sub-assemblies on the canvas

Drag a product (not a machine) onto the canvas and connect it into the step that consumes it, and you have modeled a component. If that component has a routing of its own, EDGEBIC marks it as a sub-assembly with a star, and at schedule time the engine explodes it: a 100-unit parent order also plans 100 frames through the frame's own weld and paint steps, timed so frames are ready exactly when the consuming assembly step needs them. The explosion is recursive through any depth of sub-assemblies.

The safety net

The designer validates on save. A missing end product, a step that cannot reach the end product, or an end product with outgoing arrows are reported as errors: fix the connectors rather than saving around them. Free-floating annotation notes are available for context ("waiting on tooling quote"), and the scheduler deliberately ignores them; numbers belong in fields, context belongs in notes.

Every Scheduled Job Carries Its Own Frozen Routing

Here is the design decision that makes visual routing editing safe on a live factory: when a job is scheduled, EDGEBIC freezes a private copy of the routing for that job. Engineering can change the standard BOR all week; a job already on the floor keeps planning, printing, and rescheduling against the recipe it was sold with.

The Scheduled Job BOR tab is where you manage that copy, with the same designer canvas plus a live header strip showing job progress, actual versus estimated hours, the current step, projected finish, and the due date. Four controls define the behavior:

The documented impact example makes the trade-offs concrete. A 100-unit widget job is mid-production with sawing complete when engineering improves assembly from 0.30 to 0.25 hours per unit:

• Do nothing: the job continues on its frozen copy; assembly still plans 30.5 hours, and shop paperwork stays exactly as printed.
• Adopt the change: tick Use Global BOR on Reschedule and reschedule; assembly re-plans at 25.5 hours and finishes five shift-hours earlier. The completed sawing step is untouched, because history is never rewritten.
• Customize one job: add a one-off rework step to just this job's copy in the designer, save with Update this Job BOR, and reschedule. The standard, and every other job, is unaffected.

Steps you add to a job's copy survive reschedules; the scheduler recognizes them as part of that job's recipe and places them in their proper spot in the chain.

The Gantt: One Bar, One Operation, Ten States

EDGEBIC's scheduler Gantt shows every checked job across work-center lanes. One bar is one operation: one routing step of one job on one machine. Operations of a job read left to right in routing order, and a bar that appears to skip a day is usually just skipping a weekend or holiday, because bar positions follow the shift calendars.

The bar colors are a state language, and learning it turns the Gantt from a picture into an instrument:

Two more visual elements matter. A slate bar labeled Lead Time at the end of a job is the display-only lead-time tail, showing the end-item lead time between the last operation and final availability; it consumes no capacity and cannot be dragged. And a bar carrying the parallel symbol is a parallel work-center step: drag it and its synchronized siblings move together, because they always run in lockstep.

A deeper read of the overlay system, including how planned versus actual positions draw once real dates exist, is in reading the EDGEBIC Gantt: planned vs actual.

Dragging With Intent: The Three Drag Modes

The single most important control on the Gantt is the Drag writes selector, because it decides what a saved drag means:

The rule of thumb from the user guide is worth memorizing: past work gets Actual Start & End, running work gets Actual Start, future work gets Planned Start. Dragging a future operation with the actuals mode selected tells the system the work already happened, which skews progress figures. The Planned Start pin exists precisely so you never have to fake an actual to hold a future position.

Drags stage, they do not save. Each dragged bar turns to the Overridden state and joins a pending set; Save Changes writes everything at once, Discard snaps everything back. You can also drag a bar onto a different work center's lane to move the operation to another machine, or right-click for an exact Move Operation to Date/Time entry.

EDGEBIC's editing philosophy here is deliberate: override and warn. You can drag a bar anywhere, and the system warns about questionable moves but does not block you. You are the planner; the system trusts your judgment, stages the change, and lets the next reschedule re-plan the rest of the job around your decision. Saving a drag records dates; it does not re-run capacity math. That is what the Re-Schedule button is for, and it re-plans only the jobs you touched, leaving the rest of the plant alone.

Two safety mechanisms keep manual edits honest:

1. The prior-operations prompt. Save a change on an operation whose earlier steps have no actuals, and EDGEBIC warns you, lists the missing work centers, and offers to auto-fill their planned values as actuals, tagged as system auto-filled so they stay recognizable. Cancel and log properly, or accept the backfill knowingly.
2. The downstream flag. After a save, any later operation in the same job that may now be out of sequence turns Downstream Changed. Nothing about it changed in the database; it is a visual to-do list. Drag those too, or press Re-Schedule and let the engine tidy up.

A morning on the Gantt, worked

The user guide's example runs a widget job (20 units) through saw, mill, and paint:

1. Monday morning, all three bars show Default: the engine's plan has the saw finishing at 10:30 and the mill running until Tuesday 12:30.
2. The saw finished early and the mill actually started at 10:00. You set Drag writes to Actual Start, drag the mill bar to 10:00, and save. The bar turns Actual Start Applied: in progress, end open.
3. Sales asks whether painting can wait for a color change until Thursday. You switch to Planned Start, drag the paint bar to Thursday 08:00, and save. The bar shows Planned Applied: nothing pretends the painting happened.
4. You press Re-Schedule. The engine keeps the mill's real start, plans its remaining hours forward, honors the Thursday paint pin, and reloads the committed plan.

Three different intentions, three different modes, zero fiction in the data.

The Job View: One Job, Full Depth

Where the scheduler Gantt answers "what is the whole plant doing," the Job View tab answers "where exactly is this job." Pick a job and you get a summary panel (planned window, quantity, operation count) topped by the hours roll-up: total hours, actual hours, remaining, and percent complete, summed live from the job's operations. Below it, a per-operation grid carries scheduled and actual dates, hours, pieces, rates, and completion percentages, with a Gantt strip you can switch between hour, day, week, and month scales.

The Job View is also where job-level actions live: logging actuals, completing or reopening the job, the audit trail, Excel export, and a targeted Re-Schedule. Those execution workflows are the subject of the shop floor execution guide; the visual point here is that plan and reality are always drawn together, never overwritten. Once actual dates exist, the bar draws at the actual position while the scheduled dates stay in the grid columns, so the variance is visible at a glance instead of buried in a report.

One quality-of-life behavior worth knowing: your grid layouts save themselves. Column widths, order, visibility, sorting, and grouping persist per user with no save button, and a newly shipped column still appears inside your saved layout.

Why Visual Beats Tabular for Scheduling Work

A fair question: grids hold the same data, so what does the visual layer actually buy? Three specific things, each grounded in how the surfaces above behave:

Structure errors become visible before they become schedule errors. A routing drawn left to right makes a missing connector or a dead-end branch obvious, and the designer refuses to save a chain that cannot reach the end product. In a grid, a broken next-in-sequence value is one cell among hundreds.

Change impact is spatial. Drag a mill operation one day later and the Downstream Changed flags light up on exactly the operations that need review. The same information exists in date columns; the Gantt makes it pre-attentive.

The floor and the office share one picture. The same diagram that plans the job becomes, in the Actual Live view, a read-only progress board with per-step status badges, logged-versus-planned hours, and a projected finish. Planners, supervisors, and sales argue from one drawing instead of three spreadsheets.

This is also the through-line of the product's heritage. User Solutions built EDGEBI as the graphical companion to the RMDB scheduling engine; EDGEBIC folds that visual experience and the engine into one application, which is why the flow-chart designer and the Gantt operate on the same live objects rather than exchanging files. If you run RMDB or EDGEBI today, the upgrade path preserves your routings and master data through import masks.

Getting Started

A practical first week with visual scheduling in EDGEBIC looks like this:

1. Draw one real routing. Pick a product whose process everyone knows and build it on the canvas: nodes, connectors, real hours. Validate against the floor's actual sequence. The worked examples series walks a complete build from an empty database.
2. Schedule it and read the bars. Run the scheduler, open the Gantt, and match each bar state to the legend. Check where queue times and the lead-time tail land.
3. Stage a change and discard it. Drag two bars, watch the pending count, then press Discard. Knowing that nothing saves until you say so is what makes the surface safe to explore.
4. Practice the three drag modes on a test job. Record a real start, pin a future operation, and reschedule. Watch the pin hold and then dissolve when an actual arrives.
5. Edit one job's private routing. Add a step to a scheduled job's copy and confirm the standard routing is untouched.

If you want to see your own routings on the canvas before committing to anything, contact US for a demo: bring a routing spreadsheet, and the import masks plus the designer will turn it into a living flow chart in the same session. For the platform-wide context around this pillar, start with the complete EDGEBIC guide.