Skip to content
Industry reportsAll articles

Production Planning Software: 2026 APS TCO & Build Cost

Standard ERP material requirements planning assumes infinite machine capacity and static lead times. Here is how modern Advanced Planning and Scheduling software uses constraint programming, setup matrices, and real-time MES telemetry to build executable factory schedules.

Artem Zaitsev
Artem ZaitsevCTO · Idealogic
Author: Artem ZaitsevPublished: Updated: Reading time: 24 minHow we write →
On this page
Idealogic: production planning software, MRP vs APS

Production planning software turns customer demand into a schedule that a factory with a finite number of machines, tools, and skilled operators can run. Nearly every manufacturer owns an ERP system with a Material Requirements Planning (MRP) module. Even so, most daily plant schedules are still built by hand, in fragile multi-tab Excel workbooks, by veteran master schedulers.

The reason is age. ERP MRP engines were designed in the 1960s and 70s to calculate material purchase orders, and sequencing jobs on a shop floor was never part of the brief. Standard MRP backward-schedules work orders from delivery dates using static, padded lead times and an assumption of infinite work-center capacity. When demand spikes or a CNC cell goes down, MRP piles 42 hours of production onto a single 24-hour day. Modern production scheduling software, built on Advanced Planning and Scheduling (APS), replaces those static assumptions with mathematical optimization. It models sequence-dependent changeover matrices, secondary tooling constraints, and live telemetry from your manufacturing execution system (MES), then produces a conflict-free dispatch queue down to the minute.

The short version

  • Infinite MRP vs finite APS: Legacy ERP MRP calculates material requirements with fixed lead-time buckets and assumes infinite capacity. Finite APS won't let two jobs overlap on the same machine, mold, or certified operator.
  • Padding lead times backfires. Inflate ERP routing lead times to absorb variability and orders release early, work-in-process (WIP) queues grow, and actual cycle times get longer. That's Little's Law (L = λ W).
  • CP-SAT suits discrete job shops: Mixed-Integer Linear Programming (MILP) handles multi-plant master planning and batch sizing. For Job-Shop Scheduling Problems (JSSP) with sequence-dependent setups, Constraint Programming with SAT (Google OR-Tools CP-SAT) is often the stronger practical baseline than a generic MILP formulation.
  • Asymmetric changeover matrices save capacity: Grouping compatible product attributes (allergens, polymer colors, sheet gauges, die families) in an N × N setup matrix wins back bottleneck hours without capital equipment spend. Our worked example below assumes a 25% cut in setup losses.
  • Closed-loop MES feedback prevents drift: Subscribing to real-time scrap counts, cycle times, and downtime from MES and CMMS software via ISA-95 / IEC 62264 lets the scheduler repair timelines in seconds, while frozen horizons keep schedule nervousness down.
  • A custom solver can cost less than a suite. For plants with domain-specific physics, an API-first CP-SAT optimization service inside your manufacturing ERP and MES software stack runs $95,000 to $210,000 in CEE (at $75/hr, vs $209,000 to $462,000 US at $165/hr). In our 36-month model that's $161,200 to $692,400 less than PlanetTogether, Siemens Opcenter APS, or Kinaxis Maestro.

Why ERP MRP Breaks Production Planning on the Shop Floor

Master schedulers distrust their ERP for a reason, and it sits in the core algorithm: classical MRP logic (Orlicky, 1975). Traditional MRP executes four deterministic steps: it reads the Master Production Schedule (MPS), explodes the multi-level Bill of Materials (BOM), nets requirements against warehouse inventory and open purchase orders, and backward-schedules planned order releases using fixed routing lead times.

At no point during that backward pass does standard MRP ask whether Work Center 104 actually has an open slot at 14:00 on Tuesday. The algorithm assumes every work center has infinite capacity and every part family waits in queue for the same fixed time, however loaded the factory is.

The Lead-Time Syndrome and Little's Law (L = λ W)

On a real shop floor, queue time isn't a constant property of a part number. It's a non-linear function of utilization, governed by Little's Law (L = λ W, where WIP inventory L equals throughput λ times flow time W) and Kingman's approximation, which Hopp and Spearman call the VUT equation in Factory Physics: W_q ≈ ((c_a^2 + c_s^2) / 2) * (ρ / (1 - ρ)) * t_s.

As work-center utilization ρ approaches 100%, waiting time W_q grows hyperbolically (it diverges like 1 / (1 - ρ)) whenever arrival variability (c_a) or processing variability (c_s) is non-zero. At 92% utilization that multiplier is already 11.5. When a bottleneck hits 92% utilization and orders slip, ERP administrators typically increase fixed item-master lead times from 5 days to 10 days, triggering the Lead-Time Syndrome:

  1. Because the ERP believes the part takes 10 days, its next nightly MRP run releases next week's work orders onto the floor 5 days earlier.
  2. Releasing an extra week of orders floods the physical shop floor with immediate WIP inventory (L).
  3. By Little's Law (W = L / λ), doubling WIP while bottleneck throughput (λ) remains capped doubles the actual time parts spend waiting in pallets (W).
  4. Orders are now late even against the 10-day allowance, prompting administrators to inflate lead times to 15 days and choking the plant with unfinished inventory.

Blindness to Secondary Constraints and Sequence-Dependent Setups

Traditional bucketed planning also ignores three physical realities that govern real factories:

  • Sequence-dependent setup matrices: ERP routings assign a single static setup time (such as 45 minutes) to an operation. On a real extrusion line, switching from natural polyethylene to black carbon compound might take 15 minutes, while purging black carbon back to medical-grade clear resin means a 180-minute tear-down.
  • Multi-resource synchronization: Running a stamping job requires Press #4, Progressive Die #118B, a 3mm coil feeder, and an operator holding a Level 3 die-setter certification simultaneously. If Press #4 is free but Die #118B is mounted in Press #2, the schedule fails.
  • Intra-day sub-assembly pegging: MRP plans in daily or weekly buckets. A weldment scheduled to finish "on Wednesday" might come off the welding cell at 22:30 Wednesday night, while MRP scheduled final assembly to consume it at 07:00 Wednesday morning.
Why ERP MRP schedules collapse on the shop floor and how finite-capacity APS optimization resolves physical bottlenecks.
Scheduling DimensionLegacy ERP MRP I / MRP IIManual Excel Schedule BoardsFinite-Capacity APS Software
Capacity ModelInfinite capacity or weekly bucketed averagesMental heuristics on 1 to 2 bottleneck linesSimultaneous finite capacity across machines, tools, and shifts
Time GranularityDaily or weekly bucketsShift-level blocksContinuous minute-by-minute intervals
Changeover LogicFixed average setup time per routing stepPlanner's memory of which families run well togetherAsymmetric N × N sequence-dependent setup matrix (S_i,j)
Secondary ConstraintsIgnored (machines only)Tracked manually via color-coded cellsMulti-cavity molds, fixtures, cranes, tank storage, labor skills
Sub-Assembly PeggingBucket-level netting (risks intra-day starvation)Manual cross-tab VLOOKUP checksStrict precedence graph (Start_child ≥ End_parent + Transit)
Disruption ResponseNightly batch regeneration (8 to 24 hour lag)2 to 4 hours of manual cut-and-pasteEvent-driven local neighborhood repair in 15 to 120 seconds

Inside the Planning Hierarchy: S&OP, MPS, MRP, and Finite APS

Good manufacturing software architectures keep the ERP. They split planning into layers that follow ISA-95 / IEC 62264 and NIST Smart Manufacturing Operations Planning and Control:

  1. Sales and Operations Planning (S&OP) [3 to 18 months, Monthly]: Aligns commercial sales forecasts, inventory targets, capital equipment, and shift staffing across plants. This is the layer supply chain planning software covers.
  2. Master Production Scheduling (MPS) [4 to 12 weeks, Weekly]: Translates S&OP targets and firm orders into a rough-cut capacity plan (RCCP) for finished goods.
  3. Material Requirements Planning (MRP) [2 to 8 weeks, Daily/Weekly]: Explodes the BOM inside the ERP against MPS demands and generates long-lead supplier purchase requisitions.
  4. Advanced Planning and Scheduling (APS) [1 day to 4 weeks, Minutes]: Ingests firm work orders and verified raw material availability, solves the finite combinatorial scheduling problem, and locks operation sequences.
  5. Shop-Floor Dispatching and Execution (MES) [Shift / Real-time, Seconds]: Receives the executable OperationsSchedule from APS, enforces recipe interlocks, tracks Overall Equipment Effectiveness (OEE), and streams progress back to APS.

Production Scheduling Software Under the Hood: MILP vs CP-SAT

Assigning discrete manufacturing operations to finite machines over time is the Flexible Job-Shop Scheduling Problem (FJSSP), which is strictly NP-hard. If one work center has 15 jobs waiting in queue, there are 15! = 1.3 × 10^12 possible sequences on that machine alone. Across 40 work centers and 2,500 routing operations, greedy heuristics (such as Earliest Due Date) get stuck in local optima and leave downstream assembly waiting for parts. Modern production planning software relies on two solver families, MILP and CP-SAT.

1. Mixed-Integer Linear Programming (MILP)

MILP formulates the plant as linear inequalities over continuous variables (start times S_i, batch sizes Q_i) and binary decision variables (x_i,j,m in {0, 1} if job i precedes job j on machine m). Commercial solvers like Gurobi and CPLEX, alongside open-source solvers like HiGHS tracked on the Mittelmann optimization software benchmarks, solve MILP models via Branch-and-Cut.

Where MILP wins: Multi-plant MPS, continuous chemical blending, lot-sizing optimization, and balancing inventory holding costs against overtime budgets across weekly buckets.

Where MILP struggles: In minute-by-minute discrete scheduling with sequence-dependent setups, disjunctive no-overlap rules require "Big-M" linear constraints of the form S_j ≥ S_i + p_i + setup_i,j - M(1 - x_i,j,m).

When the LP relaxation sets x_i,j,m = 0.5, the Big-M term makes the constraint vacuous, weakening lower bounds on problems with hundreds of discrete operations.

2. Constraint Programming with SAT (CP-SAT)

Hybrid solvers led by Google OR-Tools CP-SAT model operations as native Interval Variables (start, duration, end, is_present) and combine constraint propagation with a Lazy Clause Generation (LCG) SAT engine. When you declare add_no_overlap alongside a setup transition matrix, CP-SAT applies edge-finding propagators and boolean nogood clause learning to prune infeasible subtrees quickly across parallel multi-core workers.

In practice the model gives each job a start and end variable, then adds a circuit constraint so the solver picks one order for the jobs on the line. Each chosen transition forces the next job to start after the previous one ends plus its changeover from the setup matrix, which already rules out overlap. Real models usually add interval variables and add_no_overlap as well, because the propagation gets stronger. The objective is usually the makespan, with a hard time limit such as 15 seconds. Check the solver status for OPTIMAL or FEASIBLE before you trust any start time, and a cutoff with no feasible answer should fail loudly. Method names follow the snake_case style of the current OR-Tools Python reference; older CamelCase names such as NewIntVar still appear in plenty of tutorials.

Modeling Secondary Tooling, Molds, and Operator Skill Matrices

In stamping, injection molding, die casting, and CNC machining, the real constraint is often secondary tooling or setup labor. CP-SAT handles these with three structures:

  1. Alternative Machine & Tooling Tuples (new_optional_interval_var): Each valid (Machine, Tooling_Asset) pair is an optional interval. add_exactly_one activates one tuple per job, while separate add_no_overlap constraints guard both the machine and the specific mold or progressive die.
  2. Cumulative Resource Pools (add_cumulative): For shared resources like 4 certified TIG welders on night shift or a 600 kW peak furnace power limit, add_cumulative(intervals, demands, capacity) stops simultaneous jobs from exceeding physical supply.
  3. Synchronized Setup Technician Windows: Splitting operations into a SetupInterval (consuming both machine and a Level-3 Setup Machinist) followed by a RunInterval (Start_run == End_setup) prevents five machines from finishing at 07:00 and sitting idle waiting for a single setup tech.

Multi-Objective Cost Functions

Production-grade APS engines optimize one weighted objective function that trades off delivery dates, setups, WIP, and stability: min Z = Σ w_o · T_o + α Σ S_i,j · x_i,j + β Σ E_o + γ · C_max + δ Σ Δ_baseline(o), with the sums running over operations o and setup arcs (i,j).

Here T_o penalizes tardiness past customer due dates, S_i,j minimizes non-productive setup minutes, E_o prevents starting non-bottleneck operations weeks early before warehouse management systems (WMS) need them, C_max compresses shift makespan, and Δ_baseline penalizes shifting jobs during reactive rescheduling.

Still building the plant schedule in Excel?
We build custom finite-capacity scheduling engines on Google OR-Tools CP-SAT with ISA-95 integration. They turn ERP work orders into conflict-free shop-floor sequences.
Audit your scheduling architecture

Sequence-Dependent Setup Matrices and Theory of Constraints (DBR)

A sequence-dependent setup matrix is a table of changeover durations for every ordered pair of product families. Nobody can maintain that table between 5,000 individual SKUs (25,000,000 cells), so a sensible APS data model breaks setups down into orthogonal attribute matrices. The durations below are illustrative:

  1. Allergen / Sanitation Matrix (Food, Beverage, Pharma): Running a soy SKU after a dairy-plus-peanut SKU requires a 210-minute Clean-in-Place (CIP) caustic wash and ATP swab verification logged in your quality management software (QMS), whereas identical allergen profiles require a 10-minute wipe.
  2. Color / Resin Matrix (Plastics, Extrusion, Coating): Stepping from clear -> white -> yellow -> red -> black masterbatch takes a 12-minute purge per step; reversing from black directly to white requires a 180-minute screw pull.
  3. Dimensional / Tooling Matrix (Stamping, CNC, Packaging): Adjusting guide rails within the same carton footprint takes 15 minutes; swapping the forming turret takes 90 minutes.

The solver then combines them per pair: S_i,j = max(S^clean_i,j, S^color_i,j + S^tooling_i,j). Cleaning can run alongside a color and tooling change, so the longer of the two sets the changeover.

Embedding Drum-Buffer-Rope (DBR) into Finite Scheduling

Following Eliyahu Goldratt's Theory of Constraints Drum-Buffer-Rope (DBR) and the scheduling work recognized by the INFORMS Franz Edelman Award, an hour lost at a bottleneck is lost for the entire plant:

  • The Drum: The solver applies heavy changeover minimization weights on primary bottlenecks to construct multi-day campaign wheels that maximize constraint runtime.
  • The Time Buffer: Explicit protective buffers (4 to 8 hours) are inserted directly upstream of the bottleneck and final shipping so minor upstream micro-stops never starve the constraint.
  • The Rope: Feeder work centers are backward-scheduled from the bottleneck's locked start time, pulling raw materials from the WMS just in time.

Closed-Loop Rescheduling: Connecting ERP, APS, and MES

A static schedule printed at 06:00 is obsolete by 09:30 when a cutter shatters or an urgent expedite arrives. Modern smart factory architectures implement closed-loop event-driven scheduling. ERP, APS, and MES exchange ISA-95 Part 4 and MESA B2MML payloads over an MQTT / Eclipse Sparkplug B Unified Namespace, with OPC UA at the machine edge.

Closed-loop production scheduling lifecycle: how real-time MES execution telemetry keeps the finite schedule synchronized with physical shop-floor state.
  1. Order & Maintenance Sync: Sales order deltas from ERP, preventive windows from your CMMS, and RUL alerts from predictive maintenance software update APS availability tables incrementally.
  2. Schedule Publication (OperationsSchedule): APS publishes locked sequences specifying machine IDs, die numbers, target start/end timestamps, and BOM reservations to the MES.
  3. Real-Time Variance Detection (OperationsPerformance): As PLCs execute jobs, the MES emits live cycle velocity, scrap counts, and fault states aligned with ISO 22400-2 KPI definitions.

Preventing Schedule Nervousness: Three-Zone Time Fences

A global reschedule that swaps 300 downstream jobs mid-shift does more damage than the breakdown that triggered it. Production scheduling software avoids that with three time-fence zones:

  • Zone 1: Frozen Horizon (Current Time + 0 to 8 Hours): Jobs currently running on a machine or whose raw materials and tooling have already been kitted and staged at the line are locked (is_frozen = True). When a minor delay occurs inside the frozen zone, the system executes a deterministic Right-Shift Repair along the precedence graph without changing sequence or machine assignment.
  • Zone 2: Slushy / Bounded Repair Horizon (8 to 72 Hours): When a major breakdown or scrap spike occurs, the APS invokes a Warm-Start Local Neighborhood Repair, loading the previous schedule as a solution hint, locking unaffected lines, rerouting jobs off the faulted machine to qualified alternates, and applying a stability penalty (δ) against unnecessary sequence changes.
  • Zone 3: Liquid Optimization Horizon (Day 4 to Day 28): All newly released ERP orders and unallocated future capacity remain fully fluid during nightly global optimization runs, allowing the solver to assemble optimal multi-day changeover campaigns.

Each scheduled operation the APS sends to the MES carries roughly these fields. The shape is modeled on the ISA-95 Operations Schedule, and B2MML itself expresses it as XML.

FieldWhat it tells the MES
Schedule ID and frozen-horizon endWhich shift plan this is, and until when its sequence is locked
Work order and segment requirementThe ERP order and the routing step, for example an injection-molding operation
Earliest start and latest endThe time window the solver committed to
Equipment requirementThe work center and the specific mold or die asset
Personnel requirementThe qualification class and headcount, such as one Level-3 setup tech
Shop-Floor Disruption EventTelemetry SourceAutomated APS Rescheduling Response
Minor micro-stop (< 30 min)MES PLC cycle counterAbsorbed by DBR time buffer; deterministic right-shift on affected line only
Major breakdown (> 2 hours)CMMS emergency ticket + MTTRInserts UnavailableInterval; runs bounded CP-SAT warm-start to reroute slushy-zone jobs
Batch quality hold (> 5% scrap)QMS NCR eventDecrements net yield; spawns and inserts a make-up replenishment job ahead of assembly
Raw material supplier delayERP / WMS ASN updateAdvances earliest_release_time on pegged orders; pulls forward material-ready jobs
VIP expedite order insertionCommercial CRM / ERP Capable-to-Promise APIRuns 5-second trial CP-SAT insertion outside the frozen fence; reports impact before commit
The biggest mistake engineering teams make with production scheduling is treating the solver like a stateless calculator. If your CP-SAT model saves 12 minutes of setup time by swapping 40 work orders two hours before shift change, operators will throw the tablet in a drawer and go back to Excel. A production-grade scheduler locks kitted jobs inside a frozen horizon and uses warm-start stability penalties so the schedule only shifts where a real disruption demands it.
Artem Zaitsev · CTO at Idealogic

Off-the-Shelf APS Suites vs Custom Scheduling Engines

Buyers of production planning software usually weigh three paths: activating their ERP's native scheduling add-on, licensing a standalone commercial APS suite (such as Siemens Opcenter APS, PlanetTogether, Asprova, or Kinaxis Maestro), or engineering a custom optimization microservice powered by Google OR-Tools CP-SAT or HiGHS.

Evaluation CriteriaNative ERP Scheduling Add-OnStandalone Commercial APS SuiteCustom CP-SAT / MILP Scheduling Engine
Best Fit ProfileSimple make-to-stock assembly with low setup complexityMulti-plant discrete/batch manufacturing with standard rulesComplex process/discrete hybrids, proprietary constraints, high-mix operations
Solver CorePriority rules or basic finite-capacity schedulingProprietary heuristics or bundled MILP/metaheuristicsFull access to Google OR-Tools CP-SAT, HiGHS, or Gurobi with custom objectives
Custom PhysicsRigid; cannot model crane interference or energy tariffsPossible only via complex vendor scripting or paid customizationNative mathematical constraints tailored to exact plant physics
ERP / MES IntegrationNative to parent ERP; weak integration with third-party shop-floor MESRequires middleware adapters and flat-file or B2MML synchronizationEvent-driven REST/gRPC APIs and native Kafka / MQTT Unified Namespace consumers
36-Month All-In TCO$240k to $320k (module license + SI scripting + planner workarounds)$360k to $900k+ (per-plant subscriptions + certified SI services)$207,600 typical 36-mo TCO ($95k to $210k CEE build; $0 per-seat/per-plant fees)

When to Buy Off-the-Shelf vs Build Custom

You should buy a commercial APS suite if your plant runs standard discrete machining, stamping, or packaging processes where constraints fit standard template checkboxes (primary machine + secondary tool + setup matrix) and you lack internal or partner software engineering support.

You should architect a custom scheduling engine when:

  • Your bottleneck is governed by non-standard physics: Examples include continuous casting thermal decay timers, simultaneous overhead crane non-crossing geometry, shared manifold piping in chemical batch reactors, curing room 2D/3D spatial packing, or real-time electricity spot-price peak shaving.
  • You operate an API-first MES/ERP stack: A packaged APS then becomes one more system to integrate and license. We embed containerized Python/Rust CP-SAT solver microservices directly into our clients' custom software architectures, custom software cost structures, and industrial reporting platforms.
  • You need real-time Capable-to-Promise (CTP) quoting in your CRM: An API-driven solver lets commercial sales reps run a 3-second trial insertion of a prospective 50,000-unit order against live factory capacity to return an exact, profitable delivery date before the customer signs the contract.

Worked ROI: Mid-Market High-Mix Manufacturer

Take an illustrative $45M plastics and electromechanical assembly plant running 24 presses and 6 assembly lines across three shifts (6,000 scheduled plant hours/year):

  • Changeover Capacity Recovery: Bottleneck presses previously lost 22% of scheduled time (1,320 hours/year) to poorly sequenced color and mold swaps. Cutting setup losses by 25% via CP-SAT setup matrices reclaims 330 productive hours per press annually. At a $450/hour contribution margin across 4 bottleneck presses, the plant gains $594,000/year in throughput without new capital equipment.
  • WIP & Expedite Reduction: Dropping shop-floor WIP inventory from $3.2M to $2.2M saves $180,000/year in carrying costs (at 18%) and frees $1.0M in working capital. That's the same lever manufacturing inventory software pulls from the stock side. Lifting OTIF delivery from 78% to 95% saves another $140,000/year in weekend overtime and air freight. Together, the gains pay back a $150,000 CEE custom APS build ($330,000 US agency equivalent) in under 2.5 months.

APS Vendor vs Custom 36-Month TCO: Siemens, Kinaxis, PlanetTogether, NetSuite

Enterprise APS vendors rarely publish rate cards. Total cost of ownership builds up across per-plant fees, named planner seats, shop-floor viewer licenses, and rule scripting by a certified system integrator (SI). Four packaged options come up most often against a custom Google OR-Tools CP-SAT finite scheduler in 2026. Vendor figures here are Idealogic estimates from public indications and typical SI rates as of November 2026, not published price lists.

  • Siemens Opcenter APS (formerly Preactor): Sold in Express, Standard, Professional, and Ultimate editions. The visual Gantt board for discrete plants is strong. Custom multi-resource or thermal constraints usually need partner scripting.
  • Kinaxis Maestro (formerly RapidResponse): Cloud-native concurrent planning and multi-echelon S&OP for large enterprises. Kinaxis doesn't publish pricing, and deals are quote-based. It's built for simulating a multi-tier supply network, which is more than you need (and more than you'd want to pay for) when the bottleneck is changeover sequencing on one shop floor.
  • PlanetTogether APS: Visual multi-plant APS that integrates with SAP and NetSuite, among others. There's no public price list; we estimate $36,000 to $120,000+ a year in subscription plus 1x to 2x that in implementation services. Quick to launch for standard machine-and-mold routings. Expect custom work once co-product batch chemistry or custom ISA-95 Unified Namespace events enter scope.
  • NetSuite Advanced Manufacturing / native ERP finite scheduling: Adds work-order backward and forward scheduling inside the ERP, and Oracle documents finite capacity scheduling for it. We estimate a $30,000 to $75,000/yr module uplift plus SuiteScript consulting. It fits plants where one setup time per routing step is close enough. If your changeovers depend on sequence, test that in a demo before you commit.

The worked 36-month TCO comparison assumes a 2-plant high-mix manufacturer (8 master and shift schedulers, 35 shop-floor supervisors viewing live dispatch queues, bidirectional ERP and MES integration):

36-Month TCO Line Item (2 plants, 8 planners, 35 viewers)Siemens Opcenter APS UltimateKinaxis MaestroPlanetTogether Multi-Plant CloudNetSuite / Native ERP Finite ModuleCustom CP-SAT Scheduler + ERP/MES Loop
1. Implementation, solver rules & ERP/MES connector CapEx$85,000 (Siemens SI partner setup)$180,000 (SI network & data model)$70,000 (ERP connector + onboarding)$45,000 (ERP consultant scripting)$150,000 (2,000 hrs CEE @ $75/hr; $330k US)
2. 36-mo plant, planner & viewer software subscriptions$234,000 ($6,500/mo x 36)$648,000 ($18,000/mo x 36)$252,000 ($7,000/mo x 36)$144,000 ($4,000/mo add-on x 36)$25,200 ($0/plant & $0/seat; $700/mo compute)
3. 36-mo adapter maintenance, scripting & planner workarounds$54,000 (20 hrs/mo SI/admin)$72,000 (dedicated schema admin)$46,800 (connector & rule updates)$108,000 (40 hrs/mo manual Excel repair)$32,400 (12 hrs/mo solver tuning @ $75/hr)
Total 36-Month All-In TCO$373,000$900,000$368,800$297,000$207,600 (100% of $150k CapEx included)
Years 4 to 5 Annual Run-Rate$96,000/yr$240,000/yr$99,600/yr$84,000/yr$19,200/yr (add plants & seats at $0)

In this model, an owned Google OR-Tools CP-SAT finite scheduling engine with a closed-loop ERP/MES adapter, built in CEE, comes out $165,400 below Siemens Opcenter APS, $161,200 below PlanetTogether, and $692,400 below Kinaxis Maestro over 36 months. From Year 4 the software run-rate drops under $20,000/yr.

Idealogic's 2026 manufacturing and AI software development engineering tiers compare senior CEE squads at a $75/hr blended agency rate with US industrial optimization consultancies at $165/hr blended, which is our estimate. For context, Eurostat puts the average EU hourly labour cost at EUR 34.9 in 2025. That's a labour cost, not an agency rate.

2026 Custom APS / CP-SAT Build TierCore Mathematical Solver, UI & Integration DeliverablesTimelineCEE Build (@ $75/hr)US Agency (@ $165/hr)
1. Bottleneck CP-SAT Microservice & Setup Matrix MVPContainerized Python/OR-Tools CP-SAT solver for primary bottleneck cells, asymmetric N x N setup matrix, secondary tooling locks & CSV/REST ERP bridge (1,267 to 1,733 hrs)10 to 14 weeks$95,000 to $130,000$209,000 to $286,000
2. Full-Plant Finite APS, Interactive Gantt & ERP SyncMulti-stage precedence pegging, labor skill pools, Drum-Buffer-Rope buffers, React drag-and-pin planner Gantt workbench & bidirectional ERP integration (1,733 to 2,267 hrs)14 to 18 weeks$130,000 to $170,000$286,000 to $374,000
3. Multi-Plant Closed-Loop ISA-95 ERP/MES + Live CTP APIThree-zone frozen horizon, warm-start neighborhood repair on live MES software & CMMS events, multi-plant MILP+CP-SAT allocation & 3-second CRM Capable-to-Promise API (2,267 to 2,800 hrs)18 to 24 weeks$170,000 to $210,000$374,000 to $462,000

Implementation Roadmap: From Spreadsheets to Production Planning Software

Rolling out production planning software works best bottleneck first. The plan below is a 16-week pilot on one plant. A multi-plant closed-loop rollout (Tier 3 above) takes 18 to 24 weeks.

  1. Phase 1: Routing & Setup Data Hygiene Audit (Weeks 1 to 4): Pull 90 days of actual cycle time and changeover timestamps from your MES or OEE platform. Strip artificial lead-time padding from ERP item masters and build orthogonal setup attribute matrices for your top 20% bottleneck work centers.
  2. Phase 2: Bottleneck-First Solver Prototype (Weeks 5 to 8): Model the primary plant bottleneck ("The Drum") and shared tooling inside a CP-SAT service. Run shadow schedules alongside the master scheduler's Excel workbook for two weeks to tune objective weights (α, β, γ).
  3. Phase 3: Upstream/Downstream Propagation & Planner Gantt (Weeks 9 to 12): Expand the precedence graph across feeder cells and assembly lines using DBR buffers, and deploy an interactive web Gantt workbench for pinning VIP orders.
  4. Phase 4: Closed-Loop MES & CMMS Integration (Weeks 13 to 16): Connect live OperationsPerformance events, CMMS maintenance windows, and AI software development demand forecasting pipelines to switch on the 8-hour frozen horizon and automated neighborhood repair for the pilot lines.
Ready to replace spreadsheet scheduling with production scheduling software?
Share your work-center count, setup constraints, and ERP/MES stack. Our manufacturing engineers will return a custom CP-SAT architecture and 36-month APS TCO comparison.
Scope your finite scheduler

Occasional field notes on building software, no spam

Protected by Cloudflare Turnstile · Privacy · Terms

Artem Zaitsev
Artem ZaitsevCTO · Idealogic Development OÜ

CTO and Co-founder at Idealogic. Directing engineering, systems architecture, security, and full-stack delivery across web, mobile, and blockchain.

Frequently asked questions

  • Standard ERP Material Requirements Planning (MRP) calculates material shortages backward from customer due dates assuming infinite machine capacity and static, bucketed lead times. Advanced Planning and Scheduling (APS) software uses mathematical optimization and constraint programming to schedule operations down to the minute across finite machines, secondary tooling, and certified operator shifts while minimizing sequence-dependent changeover losses.

  • Because the ERP hands them a dispatch list the floor can't run. Legacy MRP engines ignore sequence-dependent washdowns, shared injection molds, jobs that need two operators at once, and machine breakdowns. So master schedulers export the orders to Excel and sequence the jobs by hand, using what they know about the plant's bottlenecks.

  • Mixed-Integer Linear Programming (MILP) excels at bucketed Master Production Scheduling (MPS), multi-plant capacity allocation, and continuous lot-sizing problems where linear relaxations provide tight bounds. Constraint Programming with SAT (CP-SAT) is usually the stronger choice for detailed minute-by-minute Job-Shop Scheduling (JSSP) with disjunctive no-overlap intervals, alternative routings, and asymmetric changeover matrices across hundreds of discrete operations. Most production scheduling software for high-mix plants ends up using both: MILP for the weekly plan, CP-SAT for the shift sequence.

  • A sequence-dependent setup matrix is a table of changeover durations for every ordered pair of product families on a work center. The matrix is asymmetric. Running dark chocolate after milk chocolate may need a 15-minute purge, while going from peanut products to a nut-free line means a 210-minute chemical sanitation cycle.

  • When an unplanned machine breakdown or scrap spike occurs, re-optimizing the entire plant schedule from scratch moves every downstream work order, and material handlers and tooling crews end up staging the wrong jobs. Closed-loop APS engines prevent schedule nervousness with a frozen time fence on active setups and a bounded CP-SAT neighborhood repair that penalizes deviations from the baseline sequence.

  • ISA-95 (IEC 62264) Part 4 and B2MML, its XML implementation maintained by MESA, define canonical data structures for the Operations Schedule and Operations Performance models. The ERP passes commercial master orders to the APS, which publishes resource-allocated OperationsSchedules to the MES. As orders execute, the MES returns real-time OperationsPerformance actuals so the APS tracks true remaining work center capacity.

  • Packaged APS suites fit standard discrete machining or repetitive assembly lines well. Manufacturers should build a custom CP-SAT or MILP scheduling service when competitive advantage depends on proprietary shop-floor rules, such as complex co-product chemical reactors, synchronized crane-and-furnace thermal constraints, dynamic energy tariff optimization, or tight real-time coupling with custom MES and WMS software.

  • It depends on how badly the bottleneck is sequenced today. The gains show up in three places: less sequence-dependent changeover downtime, smaller work-in-process (WIP) buffers, and better On-Time In-Full (OTIF) delivery. We haven't found a published benchmark worth quoting, so treat any percentage as a planning assumption. The worked example in this article models a 25% cut in setup losses on four bottleneck presses, WIP down from $3.2M to $2.2M, and OTIF up from 78% to 95%.

  • Siemens Opcenter APS (formerly Preactor) does detailed finite scheduling for discrete shop floors, usually configured by a partner. Kinaxis Maestro (formerly RapidResponse) is built for enterprise concurrent planning and S&OP across a supply network, with quote-based pricing. PlanetTogether fits mid-market multi-plant sites that already run an ERP. NetSuite Advanced Manufacturing adds finite-capacity scheduling inside the ERP, which is enough for simpler routings.

  • Building a custom Google OR-Tools CP-SAT finite scheduler with closed-loop ERP and MES integration costs $95,000 to $210,000 in Central and Eastern Europe at $75 per hour versus $209,000 to $462,000 in the US at $165 per hour. Across two plants over 36 months, our model puts an owned CP-SAT stack at $207,600 all-in, compared with estimates of $297,000 on NetSuite finite modules, $368,800 on PlanetTogether, $373,000 on Siemens Opcenter APS, and $900,000 on Kinaxis Maestro. Vendor figures are Idealogic estimates, not published price lists.

Still unanswered
Ask us directly

A senior engineer replies under 4 hours.