It's 4 PM on a Thursday and you just promised a Tuesday delivery

The customer is on the phone. They want 400 machined housings by Tuesday. You say yes, because saying no costs you the account. Then you hang up and walk to the shop floor to find out whether you can actually keep the promise you just made.

That walk is the whole problem. The answer lives in your head, on a whiteboard, in a spreadsheet three versions behind, and in the lead hand's memory of which jobs are really running versus which jobs the schedule says are running. By the time you reconcile all of it, it's 4:40, the answer is "probably," and "probably" is how due dates get missed.

Production scheduling is the system that turns "probably" into a number you can stand behind. For a job shop running high mix and low volume across shared machines, it is not a back-office chore. It is the function that decides whether you ship on time at full margin or burn capacity firefighting. The hidden cost of getting it wrong runs 5–10% of revenue in a typical job shop (Qlector 2025) — for a $2M shop, $128,000 to $276,000 a year once the downstream costs are added in.

This guide covers the whole picture: what scheduling actually is in a job shop, what it costs you when it slips, the capacity logic that breaks most tools, the metrics that matter, how the common scheduling methods fail, how to handle the hard cases, and how to choose software without overbuying. It's long because the topic is. Use the section headers to jump to what you need.

What production scheduling actually is in a job shop

Start with a distinction that most ERP documentation blurs: planning and scheduling are not the same thing.

Planning answers what to make and roughly when — which jobs are in the queue, what materials they need, which week they're due. Scheduling answers the harder question: given the machines, people, and hours you actually have, in what exact sequence does each operation run, on which machine, starting when. Planning is a list. Scheduling is a commitment against finite resources.

In a high-volume plant that runs the same part all day, scheduling is nearly trivial — you set a line rate and hold it. A job shop is the opposite case. You might run 60 active jobs across 18 machines, each job with a different routing, different setup, different due date, and different customer. Two jobs want the same 5-axis mill on Wednesday. A rush order lands and has to slot in somewhere. An operator calls in sick and the only person cross-trained on the wire EDM is out. The schedule isn't a list of what to make — it's a constantly contested allocation of a small number of expensive, shared resources.

That's why generic scheduling advice — the kind written for assembly lines or distribution centers — translates so badly. A job shop's defining trait is variety. Your competitive advantage is the ability to take work other shops can't, which means your routings are irregular by design. Any scheduling approach that assumes stable, repeating flow will fight you on every non-standard job, and almost all of your jobs are non-standard.

Good job shop scheduling does three things at once. It sequences operations so machines stay fed without colliding. It respects the real constraints — setup time, available shifts, tooling, operator skills — instead of pretending capacity is infinite. And it stays current, because a schedule that's accurate Monday morning and stale by Monday noon is worse than no schedule, since people stop trusting it. The mechanics of that constraint-respecting part deserve their own treatment; if you want to go deep, start with how finite capacity scheduling works.

The real cost of getting scheduling wrong

The reason scheduling deserves this much attention is that it's expensive in ways that don't show up on a single line of the P&L. The losses are distributed — a little late delivery here, a little idle machine there, an overtime Saturday to recover from a sequence that didn't hold — which is exactly why shops underestimate them.

Here's the headline number again, because it's the one that reframes the conversation: manual scheduling inefficiency costs a typical job shop 5–10% of revenue (Qlector 2025). For a $2M shop, that lands between $128,000 and $276,000 per year once you add the downstream effects — expedite freight, overtime, scrap from rushed setups, and the margin you give back when you discount to apologize for a late shipment. That's not a software line item you can cut. It's leakage spread across the whole operation, and most of it is invisible until you go looking. We break the full calculation down in the true cost of manual production scheduling, and you can run your own shop's number with the ROI calculator.

Three specific costs make up the bulk of it.

Scheduling conflicts. When two jobs are scheduled on the same machine at the same time — or when a job reaches a machine that's still tied up on the previous run — somebody pays. A single scheduling conflict that reaches the floor costs $250 to $1,000 in machine restart, resequencing, and lost capacity (Product Brief §2). The shops that bleed here aren't careless; they just can't see the collision before it happens, because the schedule lives in a format that can't warn them. Preventing those collisions is its own discipline — see how to prevent machine scheduling conflicts.

Unplanned downtime. Not all downtime is equal. Unplanned downtime runs 35% more expensive than planned downtime (Arda Cards 2026), because it cascades: the machine that drops mid-run doesn't just stop that job, it pushes every job queued behind it, and the recovery sequence is improvised rather than designed. A good schedule doesn't prevent the machine from breaking, but it gives you a structured way to reflow the work instead of scrambling. The full breakdown is in the cost of unplanned downtime in a job shop.

Capacity you can't see. The most insidious cost is the capacity you have but can't promise. If you can't tell a customer with confidence when a job will ship, you do one of two things: you quote conservatively and lose work to a faster shop, or you quote aggressively and miss the date. Both are expensive. Reliable scheduling turns your real capacity into a number you can sell against. That's the difference between capacity planning as a guess and capacity planning as a system.

Put numbers to it with a concrete case. Take a 25-person contract machining shop doing $2M a year. The Qlector range alone puts manual scheduling leakage at $128,000 to $276,000 (Qlector 2025). Now layer in the conflict cost: if this shop hits just two scheduling collisions a week at the midpoint of the per-incident range, that's roughly $50,000 to $100,000 a year in restart and resequencing cost on its own ($250–$1,000 per incident, Product Brief §2). None of that shows up as a line you can point to. It shows up as a slightly-too-high overtime number, a freight bill that's always a bit hot, and a margin that's softer than the quotes implied. The leakage is real; it's just diffuse, which is exactly why it survives for years unexamined. Running your own version of this arithmetic is the single most useful first step — the ROI calculator does it from your inputs.

There are roughly 16,627 machine shops in the United States under NAICS 332710 (Census County Business Patterns). The overwhelming majority of them schedule with tools that can't surface any of these costs in time to act on them. That's not a knock on the operators — it's a description of where the tooling is.

Finite vs. infinite capacity: the distinction that breaks most tools

If you take one technical concept from this guide, take this one, because it explains why so many scheduling tools feel wrong the moment you load a real shop into them.

Infinite capacity scheduling assumes a machine can do whatever you ask of it, whenever you ask. You assign work to a resource and the system happily stacks it up, with no regard for whether the hours physically exist. Most MRP backward-scheduling logic works this way: it takes the due date, subtracts the lead times, and tells you when to start — without checking whether the machine is already booked solid that week. The output looks like a plan. It isn't one. It's a wish.

Finite capacity scheduling does the thing a human scheduler does intuitively: it knows each machine has a fixed number of available hours per shift, per day, per week, and it refuses to schedule more work into a resource than that resource can hold. When two jobs want the same machine, finite logic forces a sequence — one goes first, the other waits or moves. The schedule it produces is achievable, because it was built against the constraint instead of around it.

The reason this matters so much in a job shop is that your constraints are real and tight. You have a handful of machines, some of them irreplaceable (the one 5-axis, the one big-envelope lathe), and they're the bottleneck through which most jobs must pass. An infinite-capacity tool will cheerfully tell you that bottleneck is fine while it's already 140% booked. A finite-capacity tool shows you the overload as overload — visibly, before it becomes a missed date — so you can resequence, add a shift, or push a non-urgent job.

This is also why a Gantt-style visual schedule earns its keep. When capacity is finite and contested, the most useful thing you can do is see the contention — bars colliding, a machine row stacked three deep, a gap where a machine sits idle while work waits behind a bottleneck. A list can't show you that. A wall of overlapping bars can. The full mechanics of constraint-aware sequencing are covered in the finite capacity scheduling explainer, and the planning side — turning finite capacity into a forward booking number — in the machine capacity planning guide.

What a schedule that actually holds looks like

It's worth being concrete about the target, because "better scheduling" is vague enough to mean nothing. A schedule that holds has a few observable properties, and you can check your own against them.

It's built at the operation level, not the job level. A job isn't one block of time — it's a routing of operations, each on a different machine, in sequence. The housing job might be saw, then mill, then deburr, then inspect. Scheduling at the job level ("this job is due Tuesday") hides the contention, because the real fight is over the mill on Wednesday afternoon, not the job in the abstract. A schedule that holds places each operation on a specific machine in a specific window, which is the only level at which collisions are visible.

It's reflowed on a rhythm, not in a panic. The schedule will be wrong by mid-morning — a machine goes down, a part fails inspection, material arrives late. That's normal. The difference between a robust shop and a fragile one is whether reflowing the day is a five-minute routine or a twenty-minute ordeal. When it's cheap, you do it constantly and the schedule stays true. When it's expensive, you stop doing it and the schedule drifts away from reality until people abandon it. This is the single most important practical test of any scheduling tool: how long does it take to drag a slipped job and let everything behind it resequence? If the answer is "long enough that nobody bothers," the tool has already failed.

It produces a dispatch list the floor trusts. The output that matters most isn't the master Gantt — it's the simple, ordered list each operator gets: here's what runs next on your machine, and after that, and after that. When that list is accurate and current, operators stop interrupting the scheduler to ask what's next, and the scheduler stops being a human router. When it's stale, operators revert to their own judgment, and the schedule becomes fiction.

It has slack where slack belongs. A schedule with zero slack shatters the first time anything moves. A schedule with slack everywhere wastes capacity. The craft is putting the slack in the right place — protecting the bottleneck, leaving flex on the machines that can absorb surprises. A shop that schedules every machine to the minute isn't running tight; it's running brittle.

If your current schedule fails two or more of these tests, the gap isn't effort — it's that the tool can't support the behavior. You can't reflow hourly in a format that takes twenty minutes to update, and you can't see operation-level collisions in a tool with no concept of finite capacity.

The metrics that actually matter (and the one that misleads)

You can't improve scheduling without measuring it, but the manufacturing world is full of metrics that sound rigorous and tell you very little. Here's what's worth tracking in a job shop and how to read each one honestly.

On-time delivery is the metric customers actually grade you on

Everything else is a means to this end. On-time delivery (OTD) is the percentage of jobs that ship by the date you promised. It's the number your customers track whether or not you do, and it's the one that decides whether you keep the account and whether you can charge a premium for reliability. A shop that ships on time consistently can quote with confidence and defend its margins. A shop that doesn't ends up competing on price, because reliability is off the table. The practical levers for moving this number are in improving on-time delivery in a job shop.

OEE tells you how much real production you get from a machine

Overall Equipment Effectiveness (OEE) is the cleanest single measure of how productively a machine actually runs. The standard definition is a product of three factors:

OEE = Availability × Performance × Quality

• Availability is the share of scheduled time the machine was actually running (downtime, setups, and waiting drag this down).
• Performance is how fast it ran versus its ideal cycle time (minor stops and slow running drag this down).
• Quality is the share of parts made right the first time (scrap and rework drag this down).

Because the three multiply, OEE punishes you compounding-ly. A machine that's 90% available, running at 90% performance, producing 90% good parts is at 0.9 × 0.9 × 0.9 = 73% OEE — not 90%. The world-class OEE benchmark is 85% (Nakajima/TPM literature), and very few job shops get there, because the job-shop reality of frequent setups and short runs attacks all three factors at once.

The honest way to use OEE is as a diagnostic, not a scoreboard. The first time most shops calculate it properly, the number is sobering — and that's the value. It tells you whether your problem is uptime, speed, or scrap, which determines what to fix. Work the formula on your own machines with the OEE calculation guide for manufacturers, and see how OEE and utilization fit together in the OEE and utilization hub.

Machine utilization is useful — and easy to read wrong

Utilization is the percentage of available time a machine is producing. It's worth tracking, but it's the metric most likely to mislead, in two opposite directions.

Read it too literally and a low number looks like failure. But consider the math: a shop running two shifts, Monday through Friday, has its machines available 80 of the 168 hours in a week. Even at a flawless 100% of available shift time, calendar utilization is structurally capped below 50% — that's just the hours math, not a performance problem. Comparing your number against a "machines should run 85%" benchmark borrowed from a 24/7 plant is comparing two different things.

Read it too eagerly and high utilization looks like success when it's actually a warning. A machine pinned near 100% has no slack to absorb a rush order or a breakdown, which means it's also the machine most likely to blow up your due dates when something shifts. The goal isn't to max every machine — it's to keep the bottleneck fed while leaving enough flex elsewhere to handle the work job shops actually take. Calculate it cleanly with the machine utilization rate calculator.

Schedule adherence and setup time: the two job-shop-specific reads

Two more metrics earn their place in a job shop specifically.

Schedule adherence is the share of operations that ran when the schedule said they would. It's distinct from on-time delivery: you can hit a due date while your schedule was wrong all week, by absorbing the chaos with overtime and expedites. Low adherence with high OTD means you're shipping on time by brute force, and brute force doesn't scale. Tracking adherence tells you whether your schedule is a plan you execute or a story you reconcile after the fact.

Setup and changeover time is the quiet OEE killer in high-mix work. A shop running long production batches amortizes setup across hundreds of parts; a job shop running tens of parts per job eats the setup on every changeover. That's not a flaw to eliminate — it's the cost of the variety that makes you competitive — but it is a number to schedule around. Sequencing jobs to group similar setups (same material, same fixturing, same tooling) can claw back real machine hours, and you can only do that deliberately if you can see the full queue at once. This is another place a visual schedule pays for itself: setup-friendly sequencing is obvious on a board and invisible on a list.

A worked example ties the metrics together. Say your bottleneck mill shows 80% availability, 85% performance, and 95% quality. Multiply: 0.80 × 0.85 × 0.95 = 65% OEE. Now you know where to look — availability is the laggard, and in a job shop that usually means setups and waiting, not breakdowns. That points you at sequencing and changeover reduction rather than maintenance. The metric didn't just score you; it told you what to fix. (Those input percentages are illustrative — plug in your own to make the diagnosis real.)

For the full scorecard — OTD, OEE, utilization, schedule adherence, and the rest — and guidance on which to track at which stage of maturity, see the production scheduling metrics and KPIs guide.

How most shops schedule today — and where each method breaks

Almost every job shop already has a scheduling system. It's just usually a system that scales worse than the shop does. Here are the three common methods and the exact point where each one stops working.

The whiteboard

The whiteboard is the most honest scheduling tool ever invented, which is why it survives. It's instantly visible, everyone on the floor can read it, and updating it takes a marker. For a small shop with a handful of machines and a short job list, it's hard to beat.

It breaks on three things: history, distance, and density. It has no memory — once you erase Tuesday, Tuesday is gone, so you can't see what actually happened versus what you planned. It exists in exactly one place, so the second person who needs the schedule has to walk to the wall, and nobody outside the building can see it at all. And it runs out of room: past 15 or 20 concurrent jobs, the board becomes a smudged mess that takes longer to read than to ignore. The honest comparison of where the wall stops paying off is in whiteboard vs. scheduling software.

The spreadsheet

Excel is where most shops go when they outgrow the whiteboard, and for good reason — it's free, it's familiar, and a clever scheduler can build something genuinely useful in it. Plenty of shops run on a spreadsheet for years.

The break point is interaction between jobs. A spreadsheet stores data; it doesn't understand constraints. It will let you type the same machine into two rows at the same time without a word of warning, because it has no concept of finite capacity. It can't show you a collision before it happens. And the maintenance burden grows with the job count — every change is a manual edit, every edit risks breaking a formula, and the one person who understands the file becomes a single point of failure. Past roughly 20 concurrent jobs, the time spent keeping the sheet accurate starts to exceed the time it saves. We walk through the specific failure modes and what to move to in the Excel production scheduling alternative.

The ERP scheduling module

Many shops that have invested in an ERP — for quoting, job costing, purchasing — assume the scheduling problem is solved because the ERP has a scheduling module. Sometimes it is. Often it isn't, for a structural reason: most ERP scheduling modules were built as planning tools, and a lot of them schedule to infinite capacity. They'll generate a backward-scheduled plan that ignores whether the machine hours exist, which produces a confident-looking schedule that the floor quietly ignores in favor of the whiteboard.

The other issue is friction. ERP scheduling modules are often slow to update and clumsy to resequence — which is fatal in a job shop, where the schedule changes hourly. If reflowing the day takes twenty minutes of clicking, nobody reflows the day. They work around the tool, and the tool becomes a system of record that doesn't match reality. When the ERP's scheduling is the part that doesn't fit, the answer usually isn't a bigger ERP — it's a dedicated scheduling layer. That trade-off is the subject of when an ERP is overkill for job shop scheduling.

Handling the hard cases

Steady-state scheduling is the easy part. What separates a robust scheduling approach from a fragile one is how it handles the disruptions that are guaranteed to come.

Rush orders

Every job shop takes rush orders, because rush orders are often the most profitable work and saying no costs you the relationship. The problem is that a rush order isn't free — it displaces something. Slotting a hot job onto the bottleneck machine pushes every job behind it, and if you can't see what you're pushing, you're trading a visible win for an invisible string of late deliveries.

The shops that handle rush orders well don't have more capacity — they have more visibility. They can see, in seconds, what a rush job displaces and decide consciously whether the trade is worth it, instead of discovering the damage a week later when the bumped jobs come due. Concretely: a hot job lands needing six hours on the only 5-axis on Wednesday. The question isn't "can we fit it" — you can always fit it by pushing something. The question is "what does it push, and what does that cost." If it bumps a job that has three days of slack before its due date, take the rush at a premium and move on. If it bumps a job that's already tight, you're trading one happy customer for one angry one, and you should price the rush to cover that — or say no. You can only make that call in seconds if the displacement is visible. The decision framework is in scheduling rush orders in a job shop.

Long-cycle and multi-week jobs

Some work doesn't fit a daily scheduling rhythm at all. A mold or die job can tie up a machine for days or weeks, with long, uninterruptible cycles where stopping mid-run means scrapping hours of work. These jobs need to be scheduled as blocks, around which everything else flows, and they punish any tool that assumes jobs are short and interchangeable. The specific tactics — protecting long cycles, sequencing around them, and quoting them honestly — are in scheduling long-cycle mold and die jobs. Project-based machining work, like oil and gas components with milestone deliveries and heavy traceability, has its own shape again; that's covered in project-based scheduling for oil and gas machining.

Many customers, many priorities

A general contract shop juggling dozens of customers faces a coordination problem more than a sequencing one: every customer thinks their job is the priority, and reconciling those competing claims against finite machines is a daily negotiation. The schedule becomes the referee — a shared, visible source of truth that ends the argument about whose job is really running when. How to structure that across a multi-customer book is in scheduling a general job shop with multiple customers.

A note on regulated work: if you run to a standard like IATF 16949 or AS9100, scheduling intersects with traceability and process control in ways that matter. This guide describes the scheduling implications only — it doesn't tell you what the standard requires of you. Confirm the specifics with your certifying body or auditor, because compliance requirements are not something to take from a blog post.

Choosing scheduling software: the four tiers, and how not to overbuy

At some point the methods above run out, and the question becomes what to buy. The market is confusing because tools that look adjacent solve genuinely different problems and price an order of magnitude apart. Here's how the landscape actually sorts, by what each tier is built to do. Compare on the objective attributes — price, pricing model, deployment, scheduling depth, dependencies, implementation time — and let those decide.

Tier 1 — Cloud MRP

MRP (Material Requirements Planning) tools are inventory-first. They're built to track materials, manage procurement, and tie production to stock, with scheduling as a secondary module rather than the core. They suit growing manufacturers whose central problem is materials and inventory.

Katana MRP is a cloud MRP positioned this way, with a Core Plan from $299/month and add-on modules from $199 to $999/month (katanamrp.com/pricing, verified May 2026); it's inventory-first and serves apparel, food and beverage, and e-commerce SMB manufacturers, with scheduling as a secondary module. MRPeasy is another cloud MRP, priced per user at $49 to $99 per user per month (mrpeasy.com/pricing, 2026), serving growing manufacturers that want full MRP including CRM and procurement. The thing to weigh: if your bottleneck is materials, an MRP fits; if your bottleneck is sequencing shared machines, scheduling-as-a-secondary-module may not give you the depth a job shop needs.

Tier 2 — Job shop ERP

A full job shop ERP bundles quoting, job costing, purchasing, and scheduling into one system. JobBOSS² is a job shop ERP of this kind, priced from $200 per user per month with implementation typically starting at $5,000 (top10erp.org, 2026); it includes job costing, purchasing, scheduling, and ITAR modules, prices per user, and requires an implementation engagement. The value of an ERP is integration across the whole business. The cost is that you're buying — and implementing — a lot of system to get the scheduling, and the scheduling depth varies. If you already need the full ERP, this can make sense; if scheduling is the only piece that's broken, it's a large purchase to fix one function.

Tier 3 — Enterprise APS

At the top sits enterprise Advanced Planning and Scheduling (APS). PlanetTogether is an enterprise APS in this category, built for Fortune 500 and multi-plant manufacturers; it requires integration with an existing ERP and a multi-month implementation, and it offers deep finite-capacity optimization. For a large, multi-site operation with a dedicated planning team, that depth is the point. For an SMB job shop, it's typically more system, integration dependency, and implementation than the problem calls for. (We're describing what enterprise APS is, not quoting a price here — see the verification note below.)

Tier 4 — Standalone visual scheduling

The fourth option is a dedicated scheduling tool that does one job well: finite-capacity, drag-and-drop visual scheduling, without the inventory, costing, and procurement weight of an MRP or ERP. This is the tier built for the shop whose scheduling is broken but whose other systems are fine — the shop that doesn't need a new ERP, just a way to see and sequence work against real capacity. Visual Machine Scheduler sits here. The full landscape, tier by tier, is laid out in production scheduling software for job shops, and the specific APS-vs-MRP-vs-standalone trade-off is dissected in comparing APS, MRP, and standalone scheduling.

The selection mistake to avoid is buying a tier up from your actual problem. A shop that needs to sequence 18 machines doesn't need a multi-month APS implementation, and a shop drowning in materials chaos won't be saved by a pure scheduling tool. Match the tool to the bottleneck. A structured way to run that evaluation — requirements, shortlist, trial — is in the scheduling software selection hub, and transparent pricing for the standalone approach is on the pricing page.

A practical sequence for fixing your scheduling

You don't have to solve all of this at once, and you shouldn't try. The shops that improve scheduling successfully do it in order.

First, measure where you actually are. Pick one number that hurts — on-time delivery is usually the right one — and track it honestly for a month. Add OEE on your bottleneck machine if you can. You can't tell whether anything you change is working without a baseline, and the baseline is almost always worse than the story you've been telling yourself.

Second, find the constraint. Most job shops have one or two machines that gate everything. Identify them. The bottleneck is where scheduling discipline pays off most, and where slack is most dangerous. Everything upstream should be sequenced to keep the bottleneck fed; everything downstream should be sized to clear its output.

Third, get the schedule out of one person's head. The single most common fragility in a job shop is that the schedule lives in the mind of one experienced scheduler. That works until they're sick, on vacation, or gone. Moving the schedule into a shared, visible form — even a better spreadsheet, to start — de-risks the whole operation.

Fourth, match the tool to the constraint, not to the catalog. Once you know your bottleneck and your real numbers, the software decision gets simple. If materials are the problem, look at MRP. If the whole business needs integrating, look at ERP. If the problem is specifically seeing and sequencing work against finite machine capacity, look at a standalone visual scheduler. Don't buy capability you won't use to solve a problem you don't have.

We build scheduling software for SMB manufacturers, and the pattern we keep seeing is shops jumping straight to step four — buying a tool — before doing steps one through three. The tool then gets blamed for a problem the shop never actually defined. Measure first. The right tool is obvious once you know your constraint.

Fifth, keep score after you change something. The most common reason a scheduling improvement fails to stick isn't the tool — it's that nobody confirmed it worked, so the old habits crept back. Compare the same baseline number you started with, one month and three months after the change. If on-time delivery moved, defend the new way of working. If it didn't, you've learned something cheaply: the constraint was somewhere other than where you looked. Either outcome is worth more than a vague sense that things feel better, which is the level of evidence most shops settle for and the reason scheduling problems recur.

Where to go from here

Production scheduling for job shops comes down to a few durable ideas. Capacity is finite, so schedule against the constraint instead of around it. The costs of getting it wrong are real and large — 5–10% of revenue (Qlector 2025) — but mostly invisible until you measure them. The metrics that matter are on-time delivery, OEE, and a clear-eyed read of utilization, not vanity numbers borrowed from plants that don't run like yours. And the right tool is the one that fits your actual bottleneck, not the most feature-dense one you can find.

If you're early in this, start by quantifying the problem. Run your shop's numbers through the ROI calculator to see what manual scheduling is costing you, and read the true cost of manual production scheduling for the full breakdown. If you're further along and comparing tools, the scheduling software selection hub and the OEE and utilization hub are the two places to go deep. And if you'd rather start from templates and calculators than a full tool, there are a few in the store.

When you're ready to see what finite-capacity, drag-and-drop scheduling looks like with your own jobs on the board, start a free trial of Visual Machine Scheduler — no credit card, 14 days. The fastest way to understand whether a dedicated scheduling layer fits your shop is to load a week of real work into one and watch the collisions you've been absorbing show up where you can finally see them.