What EDGEBI Users Gain in EDGEBIC

EDGEBI users gain a unified application that keeps their visual scheduling and extends it: a drag-and-drop routing designer, a schedule optimizer, and live shop-floor actuals, all in one place. In EDGEBIC by User Solutions, the interactive Gantt and drag-and-drop scheduling you know from EDGEBI carry over directly, but they no longer sit on top of a separate engine. The graphical experience and the scheduling engine are the same modern application, and the visual idea now reaches into the routing itself. EDGEBI remains fully supported, so the move is yours to time.

The continuity: your visual instincts carry over

EDGEBI's value was making scheduling visual and hands-on: an interactive Gantt, drag-and-drop adjustments, a picture of the plan you could reason about at a glance. None of that goes away in EDGEBIC. The Gantt is still interactive, jobs still move by dragging, and the visual scheduling you built your workflow around works the way you expect.

This is a continuation, not a replacement of the way you work. EDGEBIC is the next generation of the same product line, and the graphical experience is one of the two things it inherits (the other being the RMDB engine). Your planners keep their muscle memory. What they get is more range around it. The full picture of what moves across is on the RMDB to EDGEBIC upgrade guide.

One application instead of two

The most immediate change is architectural, and you feel it every day. Running EDGEBI meant two installs sharing a database: RMDB holding the engine, EDGEBI holding the graphical layer. EDGEBIC folds them into a single modern application built on .NET 8. The engine and the visual experience are the same program.

In practice, the context switching disappears. Building a routing, scheduling it, dragging a job on the Gantt, and reading planned-versus-actual all happen in one place. There is no hop between tools to get from the picture to the plan, because the picture is the plan.

The routing becomes a flow chart

EDGEBI made the schedule visual. EDGEBIC makes the routing visual too. In the drag-and-drop graphical routing designer, every operation is a node and every dependency is an arrow, with sub-assemblies, annotations, and product images on the canvas. You schedule straight from the diagram.

This is the natural extension of the EDGEBI instinct. The same planner who reschedules a job by dragging it now builds the routing by connecting nodes. The way your factory actually flows is the way you draw it, and the drawing is executable. For a routing you brought over from a previous install, this means you can move your routings into EDGEBIC as data and then open any of them as a flow chart.

A deeper engine underneath

Because EDGEBIC unifies the line, the visual layer now sits on the deepest engine User Solutions has shipped. Beyond the finite capacity scheduling you already had, EDGEBIC adds Theory of Constraints anchor scheduling, backward just-in-time scheduling, work center groups, parallel and alternate work centers, lot streaming, sequence-dependent setup matrices, and operators and skills as real constraints. You do not have to use all of it, but it is there when a job needs it, and it shows up in the same visual tools you already use.

The optimizer proposes, you decide

A capability with no EDGEBI equivalent is the schedule optimizer. One layer evaluates dozens of complete schedules and returns the best, guaranteed never worse than your baseline. A second layer uses Google OR-Tools CP-SAT mathematical optimization and reports a proven optimality gap, so you can see how close the proposed schedule is to provably optimal.

Crucially, the optimizer does not act on its own. It proposes, and you review a side-by-side comparison and accept or discard. Nothing changes without your decision, which keeps the planner in control the same way dragging a job on the Gantt always has.

Actuals flow into the picture

EDGEBIC adds a shop-floor kiosk: a touch app where operators start work, count pieces, pause with a reason, and complete. Those actual hours and dates flow straight into the schedule without a planner retyping anything, and they appear on the Gantt as planned-versus-actual overlays.

This changes what a drag-to-reschedule means. Because completed and in-progress work is preserved exactly, a reschedule moves only what has not happened yet, resuming from where the shop actually is. The visual plan you drag on is now grounded in real progress, not just the last plan.

Nothing you rely on is taken away

It is worth being explicit about the direction of the change, because upgrades often trade one thing for another. This one does not. Everything EDGEBI gave you is still there: the interactive Gantt, drag-and-drop rescheduling, the visual read on the plan. The new capabilities sit around that core rather than replacing it. You are not learning a different tool that happens to schedule; you are using the same visual approach with more reach.

That matters for adoption. A planner who opens EDGEBIC for the first time finds the Gantt they know and works exactly as before, then discovers the routing designer, the optimizer, and the actuals overlay as they need them. The learning curve is additive, not a reset, which is why EDGEBI users tend to be productive on day one and pick up the new capabilities at their own pace. EDGEBI stays fully supported the entire time, so there is never a moment where you are forced off the familiar before the new is proven.

A worked example

A shop runs EDGEBI over RMDB today. A planner's day involves opening RMDB to adjust a routing in a grid, switching to EDGEBI to see the Gantt, dragging a job, and switching back.

In EDGEBIC the same day is one application. The planner opens the routing as a flow chart, drags a node to reorder an operation, schedules from the diagram, and sees the Gantt update in the same window. When a rush order arrives, they drag it into place on the Gantt and the reschedule leaves this morning's completed work untouched, because the kiosk already reported it. Before publishing, they run the optimizer, glance at the comparison, and accept the sequence that cuts two changeovers. Four tools and two context switches became one screen.

The takeaway

EDGEBI users lose nothing and gain range. The interactive Gantt and drag-and-drop scheduling carry over; the two installs become one application; the visual idea extends into a routing designer where operations are nodes and dependencies are arrows; a deeper engine sits underneath; the optimizer proposes improvements you accept or discard; and kiosk actuals ground the picture in real progress. EDGEBI stays supported, so you move when you are ready. See the platform in full on the EDGEBIC overview, read the full path on the RMDB to EDGEBIC guide, and when you plan the move, consider running a pilot on one cell first.