Labor Standardization for Multi‑Machine Servicing: Calculating Operator Load

Why shift calculations often don’t match reality

On paper a shift often looks smooth. In reality an operator doesn’t live by averages but by moments when two machines need attention at once. One is still cutting a part while the other already stands waiting for loading, unloading or a measurement.

Because of this, multi-machine servicing calculations easily produce overly neat numbers. If you take an averaged cycle for the area, the operator’s load looks acceptable. But an operator can’t split into pieces. While they are at one machine, the second one loses minutes.

Different cycle times quickly break a simple average. Suppose the first machine needs attention every 4 minutes and the second every 7. In a table everything looks calm. In practice their cycles regularly overlap and waiting appears in bursts. So the report shows a feasible norm while the crew is constantly trying to catch up.

Short but mandatory actions often get left out of the calculation: fine adjustments after a size change, control measurements, recording batch results, chip cleaning, tool changes as wear occurs. Each action takes little time, but over a shift they form a noticeable block of time.

Another mistake is counting only pure machine time. A shift is not only cutting. Especially on CNC machines, the operator spends time walking to the machine, checking, reacting to a signal and handling small disruptions. Separately these are seconds; together they change the whole picture.

Therefore a calculation only “matches” on paper. If the norm looks better than the real shift, it almost always means some work simply wasn’t included in the data.

What data to collect before calculating

The problem is usually not the formula but the input numbers. Before calculating, collect precise data for each machine and each operator action — not just a shift average.

First, record machine time. For each machine fix the duration of the automatic cycle for one part or operation. If one lathe runs 95 seconds and another 140, you can’t merge them into one number. Different cycles immediately change the load.

Next, break down manual work step by step. Instead of a single line “machine servicing,” list real actions: approach, remove part, load blank, close door, press start, clear chips, perform a quick check. Then you see what takes 8 seconds and what takes 25.

It’s useful to note where each action happens. On a multi-machine cell, transfers take noticeable time. If machines are three steps apart, that’s one situation. If the operator has to go around a trolley and reach the inspection station, the times are different.

A typical observation card includes the machine cycle per machine, manual loading and unloading actions, transfers between machines and inspection points, checking a part and recording results, plus setup, tool change and other out-of-cycle work.

The last block is often lost. Tool approach, size correction, insert replacement, clearing the cutting area should not be mixed with normal servicing rhythm. It’s better to account for them separately or the standard will be too optimistic.

Also record several repeats, not a single measurement. One cycle may go smoothly while the next is stretched by chuck blowing or a repeat measurement. The more precise the observation, the fewer disputes later about the norm.

When data is collected this way, you can calculate load without guessing or adding “by eye” corrections.

How to break the shift into time types

You cannot treat the shift as a single block. First break it into time types; otherwise operator actions, machine work and downtimes will be mixed and the result will be wrong.

Start with a simple split: what the machine does automatically and when the operator is personally engaged. Machine time is the part of the cycle when cutting happens and the person can attend another machine. Manual time is loading a part, clamping, removing, measuring, tool change, entering correction, chip removal and starting the cycle.

Record operations step by step, not by memory. Even a short 6–8 second action, if repeated hundreds of times, noticeably changes the calculation.

What to put in the table

For each repeating step usually four fields are enough:

• action name;
• duration of one execution;
• who is occupied then — operator or machine;
• how many times the action repeats per shift.

Then sum only those actions where the operator actually spends time. If the machine cycle is 90 seconds and the operator is needed only 25 seconds, the operator’s load is those 25 seconds.

Losses and waiting should be kept separate. Do not hide them inside manual time. Crane waiting, searching for a cutter, an extra trip to a rack, delay due to the first part after setup — these should be separate lines so it’s clear where the standard is honest and where the shift loses time due to workplace organization.

Another common mistake is getting the repetition frequency wrong. If the operator measures every fifth part, record it that way. If a tool change is needed every 40 parts, convert it into time-per-change via the repetition number.

On CNC lathes often placed in pairs or triples, this breakdown quickly shows where the operator is overloaded with hands-on work and where machines just wait for loading.

Step-by-step: how to calculate operator load

Don’t take the whole shift at once. First choose a common cycle in which you can see what each machine does and how long the operator is busy manually. If machines have different cycles, it’s convenient to use the shortest cycle as the baseline so short approaches aren’t lost.

Common errors here are simple: some actions are counted in minutes, some in seconds, and some simply estimated “by eye.” Such a calculation quickly drifts. Convert all operations into one time unit immediately.

1. Record each machine’s cycle and all operator actions in seconds or minutes. For example: remove part, load blank, press start, measure, clear chips, bring pallet.
2. Take the shortest machine cycle as the common calculation cycle. If one machine runs 90 seconds and another 150, use 90 seconds as the base.
3. Within that cycle sum only the operator’s occupied time. Machine cutting time without human participation is not counted in operator load.
4. Divide the total operator occupation by the duration of the common cycle. If the operator is actually busy 54 seconds in a 90-second cycle, the load is 54/90 = 0.6, i.e. 60%.
5. Then check the route timing: can the operator reach the next machine before its automatic work ends? If two actions overlap, a paper calculation still doesn’t guarantee the shift will run smoothly.

One formula gives only the overall load level. For real work that’s not enough. You must see where bottlenecks appear: measurement, tool change, material feed, crane waiting, handling finished parts. These short episodes often cause delays to the next machine.

If the load reaches 100% or higher, the operator cannot keep up without breakdowns. Even 85–90% should be validated minute by minute, especially when machines have different cycles. On the shop floor minor losses add up quickly and eat the buffer.

This calculation order quickly shows whether one person can handle a second or third machine, or whether the servicing standard is inflated.

Example: a shift with two machines

Take a simple shift where one operator runs two machines. The first turns a bushing with a full cycle of 4 minutes (240 seconds). The second makes a flange with a 6-minute cycle (360 seconds). The operator spends 50 seconds at the first machine and 70 at the second for loading, unloading and a quick check.

First calculate average occupation. At machine one the operator needs 50/240 = 0.208, at machine two 70/360 = 0.194. Summed together that’s 0.402, so roughly 40% operator load. By the average number one person can run both machines comfortably.

But the average doesn’t show where queues appear. It’s better to map the work over 12–15 minutes. Twelve minutes is convenient because the 4- and 6-minute cycles produce a clear pattern in that time.

• 0:00–0:50 — operator works at machine 1;
• 0:50–2:00 — operator works at machine 2;
• 4:50–5:40 — again machine 1;
• 8:00–9:10 — machine 2;
• 9:40–10:30 — machine 1 again.

On this segment it’s clear the operator has windows of waiting between manual tasks: 2 minutes 50 seconds, then 2 minutes 20 seconds, then a short pause. That’s a good sign: the servicing standard isn’t overstated.

A queue still shows up but not immediately. If you extend the timeline, around 14:30 machine 1 will again need 50 seconds, while machine 2 finishes at 15:10. So machine 2 will wait 10 seconds for the operator — not a failure but a local overlap. It’s not overload, just a typical rhythm overlap.

The conclusion is simple. With this pair the operator is loaded at around 40% and recurring queues are small. To eliminate even 10 seconds you can change start order or slightly shift the start of one machine.

What changes with three machines of different cycles

With one operator serving three machines the issue usually hides not in total time but in short overload peaks. Two machines can almost finish at the same moment, producing a dense block of unloading, loading and restarting. The average looks tolerable while in practice the operator is late.

With three machines the shortest cycle begins to set the entire pace. If one machine needs attention every 90 seconds while the others run 140 and 210 seconds, the operator adapts to the short rhythm. Longer cycles then don’t provide as much slack as the table suggests.

The average is almost always too coarse. It doesn’t show what happens when unloadings coincide — and that’s exactly when the servicing norm is tested.

On a CNC lathe cell this becomes visible quickly. Suppose operator times are 18, 24 and 30 seconds for machines 1–3. Formally the manual time sum may fit. But add a single extra measurement, a repeated start or a short chip-removal delay and the small reserve vanishes.

For three machines it’s better to build a time chart than to use an averaged cycle. Mark each machine’s automatic cycle end, operator transfers, manual actions, inspections and recurring delays. Then you’ll see where load is steady and where peaks occur. If two machines regularly wait for the operator, the standard is too high. If overloads occur only after an occasional measurement or setup, the calculation needs a separate reserve, not a pretty average.

With two machines you can sometimes smooth such moments by changing the visit order. With three machines this works worse. A short cycle can break the whole schedule and even a 10–15 second mismatch becomes a queue at the machines.

Common mistakes

Most calculation errors stem from input data, not from formulas. People usually take only machine time because it’s easy to read from a controller, while operator actions are recorded too roughly. The cycle then looks shorter than it is.

The most frequent slip is forgetting manual operations in each repetition. The operator doesn’t just wait for the end of a cycle. They approach the machine, open the working area, remove a part, load a blank, clean seating, close and start, sometimes enter a correction or note a size. If that takes 25–35 seconds but the calculation assumes 10, the error grows quickly over the shift.

The second problem seems small but spoils the standard: travel between machines. If machines sit close together a transfer can take 3–4 seconds; if the operator must walk around an obstacle it’s 7–10 seconds. Over a shift that’s a noticeable loss.

Another frequent mistake is mixing setup time with the repeating cycle. For example, a setup took 20 minutes for a batch of 100 parts but was entered into the cycle as if present each run. You must distribute setup time by repetition: per batch, per shift or per series. Otherwise the servicing standard will be unrealistically heavy.

The same applies to control. The first part is almost always checked separately and then samples are checked at intervals. If you omit that, operator load looks good only on paper. In practice a measurement often falls at the worst moment, and the neighboring machine waits.

One more error is looking at the average hourly load and relaxing. A breakdown doesn’t happen “on average” but in a specific minute when two machines need the operator at once.

A good example: two machines where one finishes every 2 minutes 40 seconds and the other every 3 minutes 10 seconds. Hourly averages may look acceptable, but if in one moment you must remove a part from the first machine and measure the second, the operator can’t be in two places at once. That’s where the calculation fails.

Before approving a standard, check not only the total minutes but also the busiest segment. If at cycle overlaps the operator doesn’t have at least a 5–10 second reserve, the standard is already on the edge. Such a mode won’t hold up long.

A quick check before approving the standard

Don’t rely only on the overall percentage before approval. An operator can be 80–85% occupied and still miss a machine at the most inconvenient moments.

The final check should follow the real cycle, not a pretty table. Walk through the shift minute by minute: approach, remove part, load blank, start, check, record, move to the next machine.

If any actions overlap at a point, the standard is already too tight. On paper this may be hard to see, but on the shop floor such a detail turns quickly into downtime at a machine or into operator rush.

First check the route. The operator should arrive at each machine before the end of its automatic cycle, not after the stop signal. Even 20–30 seconds repeated many times per shift reduce output noticeably.

Then leave a reserve for short disruptions. In a normal shift there are small losses: chips impede removing a part, a measurement takes half a minute longer, a tool needs attention, the operator is distracted by material or marking. If the calculation only works under a perfect rhythm without such pauses, it’s not a workable standard.

A quick verification needs four questions:

• Are there moments when two machines require the operator at the same time?
• Is there a small time reserve within the cycle?
• Can measurement and recordkeeping fit in without disrupting other actions?
• Does the calculation match what you see in a real shift?

Measurement and recording are especially often miscounted. They’re treated as if done “in passing.” In practice inspections and entries occupy space in the cycle. If the operator measures or records after every part, this must be included in the standard.

Finally, compare the calculation not with a single good shift but with several observations: start of shift, middle and the last hour. If the standard is met only when everything goes without delays, it’s not a workable norm. If the operator can work without rush and a small reserve remains, the calculation can be accepted.

What to do with the calculation result

The load number alone doesn’t solve anything. It helps to understand where the operator loses time and whether the shift can run without rush and idle periods. If the calculation shows overload, don’t immediately change the standard. First try to adjust the work scheme.

Often changing the visit order helps. The operator doesn’t have to follow the same loop. If one machine has a short cycle and another provides a long window, it makes sense to clear the short cycle first and use the long one for unloading, inspection and preparing the next operation. This simple reorder sometimes removes extra transfers and waiting.

Look at actions that can be shifted into less busy parts of the cycle. Measurements, result recording, bringing blanks or light tool prep belong where the operator has a free 20–40 seconds. Then the shift runs more smoothly and the calculation matches daily reality.

If one person can comfortably run two machines on paper, it doesn’t mean they will handle three as well. Compare both schemes separately. Look not only at average load but at time reserve. If with three machines the operator has almost no pauses, any small issue will break the rhythm: a measurement runs long, a part is tight, a machine needs attention. Formally the standard may add up, but the cell will run in bursts.

Usually one of several conclusions follows: leave the scheme as is; change the visit order; move some manual tasks to another window of the cycle; abandon the third machine; or recalibrate the standard after a trial shift.

That’s how labor standardization for multi-machine servicing works: not for a pretty number in a table, but for a clear and stable shift.

If you are still choosing machines for such a cell, it’s useful to look not only at the rated cycle but at the planned servicing scheme. You can discuss this with EAST CNC: the company supplies CNC lathes and machining centers and helps with selection, commissioning and service. That way the calculation relies on the actual cell layout rather than averaged numbers.