Recipe scaling is the mechanism that resizes a recipe's quantities to match the batch actually being made. A master recipe is written for a nominal batch size, but real orders come in many sizes, so when a control recipe is instantiated the formula must be adjusted to fit. Scaling handles that adjustment: it multiplies the quantities that should grow with batch size while leaving alone the ones that should not. Getting scaling right, and knowing where it breaks down, is essential for anyone configuring the master-to-control-recipe instantiation that produces every batch.
recipe scaling in one line: Recipe scaling is the mechanism that adjusts a recipe's formula quantities, and sometimes its times, when a control recipe is instantiated for a batch size different from the master recipe's nominal size. Scalable parameters change with the scale factor while fixed parameters stay constant, and the scaling may be linear or nonlinear depending on how the process behaves.
The foundation of scaling is deciding, for each parameter in the recipe, whether it should change with batch size. Scalable parameters are those that grow proportionally: the mass of each ingredient, the volume of solvent, the quantity of product. If you double the batch, you double these. When a control recipe is instantiated for a larger or smaller order, the batch engine multiplies every scalable parameter by the scale factor, the ratio of the actual batch size to the master's nominal size.
Fixed parameters are those that must not change no matter the batch size. A jacket temperature setpoint is a fixed parameter: a 2000 kg batch reacts at the same temperature as a 1000 kg batch, so scaling must leave it untouched. Setpoints, concentrations, and ratios are typically fixed, because they describe intensive properties of the process rather than amounts. Marking these as fixed protects them from being wrongly multiplied.
Classifying every parameter correctly is the core setup task for scaling. A parameter wrongly marked scalable will drift the process off target as batch size changes; a parameter wrongly marked fixed will leave the batch short or over on an ingredient. Careful, deliberate classification of each parameter as scalable or fixed is what lets one master recipe safely produce batches across a range of sizes.
The simplest and most common form is linear scaling, where scalable quantities are multiplied directly by the scale factor. Double the batch and every scalable charge doubles. Linear scaling is correct for most bulk ingredients, where the amount needed really is proportional to batch size, and it is the default assumption in most recipe systems because it is both simple and usually right.
But not everything scales linearly. Some parameters follow a nonlinear relationship with batch size: a heating time may not simply double when the batch doubles, because heat transfer depends on surface-area-to-volume ratios that change with scale. A mixing time may need to grow differently than the volume. Where the physics is nonlinear, scaling must use a nonlinear function or a lookup rather than a straight multiplication, or the resized recipe will miss.
Times are the parameters most likely to need nonlinear treatment, which is why scaling can extend beyond quantities to durations. A well-built recipe system lets an engineer specify, per parameter, not just whether it scales but how, so that quantities scale linearly while a heating or mixing time follows the curve the process actually requires. Assuming everything scales linearly is a common source of subtle batch problems at the extremes of the size range.
Several real-world pitfalls trip up naive scaling. Catalysts and initiators often do not scale linearly, because their effect depends on concentration and kinetics rather than simple proportion, so scaling them by the batch factor can push a reaction too fast or too slow. Minimum charge limits are another trap: a small batch may scale an ingredient below the smallest amount a dosing system can accurately deliver, so the scaled value is physically unrealizable. Equipment limits at the top end matter too, since a scaled-up batch may exceed a vessel's working volume.
Because scaling happens during instantiation, these pitfalls surface exactly when a master recipe becomes a control recipe. The scale factor is computed from the ordered batch size against the master's nominal size, and every scalable parameter is resized in that step. This is why scaling and instantiation are inseparable: the control recipe the sequencer runs contains the scaled numbers, and any scaling error is baked into that batch. Validating the scaled control recipe against equipment and process limits before it runs is a sensible safeguard.
For a cloud SCADA platform coordinating batch or blending operations across sites, sound scaling logic is what lets one validated master recipe serve many order sizes without a separate recipe per size. When instantiation and scaling are handled consistently and the resulting control-recipe values are surfaced for review, remote engineers can confirm that a scaled batch stays within safe and accurate ranges before it starts. Treating scaling as a deliberate, reviewable step, rather than an invisible multiplication, keeps batches on target as sizes vary.
A scalable parameter changes proportionally with batch size, such as the mass of an ingredient, and is multiplied by the scale factor during instantiation. A fixed parameter stays constant regardless of batch size, such as a reaction temperature setpoint or a concentration, and is left untouched. Classifying each parameter correctly is what lets one master recipe safely produce a range of batch sizes.
No. Linear scaling, multiplying quantities by the scale factor, is correct for most bulk ingredients, but some parameters follow nonlinear relationships with batch size. Heating and mixing times often do not simply scale with volume because heat transfer and agitation depend on ratios that change with size. Those parameters need a nonlinear function rather than a straight multiplication.
Common pitfalls include catalysts that do not scale linearly because their effect depends on concentration and kinetics, minimum charge limits where a small batch scales an ingredient below what a dosing system can deliver accurately, and equipment limits where a scaled-up batch exceeds a vessel's working volume. Validating the scaled control recipe against equipment and process limits before it runs guards against these.
Merobix reads your field devices into a cloud SCADA - the real thing behind these terms, live in days from any browser.