Post-process examples
Complete post-process pricing equations for vapor smoothing, dyeing, shot peening and media blasting, and thread inserts, plus three templates for building your own.
A post-process equation (Level 2) prices one post-process for one part line. It runs for every post-process assigned to the part's process, and only a post-process the customer selected adds to the line's price. This page works through complete implementations per post-process type: what the process does physically, how to model it as a post-process equation, and what to read from the process equation.
Add a post-process equation under Settings > Manufacturing > Post-processing > [post-process] > Equation. See Create an equation.
| Post-process | Process equation input used | Primary cost driver |
|---|---|---|
| Vapor smoothing | Part volume, area | Machine time + solvent |
| Dyeing | Part volume | Dye cost + batch utilisation |
| Shot peening and media blasting | Surface area | Machine time |
| Thread inserts | Operator-entered count, variable('Thread insert count', 0) in the post-process equation | Count × rate |
| Creating a custom post-process | Varies | Three templates to choose from |
Vapor smoothing
What this process does
Vapor smoothing uses a controlled solvent atmosphere (temperature + pressure) to reflow the outer surface of plastic parts. The result is a smooth, semi-glossy, near-watertight surface without material removal.
Key process characteristics for pricing:
- Batch process: a chamber holds N parts per cycle, typically 20-60 minutes per cycle
- Cost is primarily machine time + solvent consumption, not part-specific
- Larger parts consume more solvent and may displace smaller parts from the batch
- Parts are priced individually at Level 2, but the underlying cost is batch-level
How to model it
Three approaches, in order of increasing accuracy:
1. Flat rate per part (simplest - use when parts are consistently similar in size)
2. Volume-based (better - larger parts consume more solvent and chamber space)
3. Batch amortisation (most accurate - but requires estimating how many parts share a run)
For most shops, approach 2 is the right balance of accuracy and simplicity.
Volume-based algorithm
const { area } = specification
// Surface volume proxy: area × 1mm shell depth → mm3, then /1000 for cm3
const surfaceVolumeCm3 = (area * 1) / 1000
const ratePerCm3 = variable('Rate per cm3', 0.25)
const MIN_CHARGE = variable('Minimum charge', 8.00)
const calculatedCost = round(surfaceVolumeCm3 * ratePerCm3, 2)
const unitPrice = variable('unitPrice', Math.max(MIN_CHARGE, calculatedCost))
done(unitPrice, 2) // 2 hours for the whole line, whatever the quantityBatch amortisation algorithm
If you want to reflect batch economics precisely, calculate how many parts fit in a single chamber run and split the run cost across them:
/**
* Post-Processing Equation: Vapor Smoothing
* Pay for chamber space used across all runs
*/
const { width, height, length } = specification
const { quantity } = requisition
// Parameters — adjust to your machine
const costPerRun = 150
const chamberX = 100, chamberY = 150, chamberZ = 200
const spacing = 5
// Calculate max parts per run: test all 6 orientations, take the best fit
const orientations = [
[width, height, length], [width, length, height],
[height, length, width], [height, width, length],
[length, width, height], [length, height, width]
]
const partsPerRun = Math.max(1, ...orientations.map(([w, h, l]) =>
Math.floor(chamberX / (w + spacing)) * Math.floor(chamberY / (h + spacing)) * Math.floor(chamberZ / (l + spacing))
))
// Expose key values for override per part line
const capacity = variable('Parts per run', partsPerRun)
const runCost = variable('Cost per run', costPerRun)
// Unit price = total runs × run cost, spread across quantity.
// Math.ceil charges a partly filled run as a full run.
const finalUnitPrice = variable('finalUnitPrice', round(Math.ceil(quantity / capacity) * runCost / quantity, 2))
done(finalUnitPrice, Math.ceil(quantity / capacity) * 2) // 2 hours per runMaterial variables
No material variables required for the flat-rate or volume-based approaches - all values are in variable() fields that the operator can override per part line. If you want ratePerCm3 to differ per material, move it to material.variables['vapourSmoothingRate'].
Notes
- Very thin walls (<0.5mm) may distort during vapor smoothing. Consider flagging these with
reviewRequired. - Parts with deep internal channels may not smooth uniformly - operator judgement required.
Dyeing
What this process does
Dyeing immerses parts in a heated dye bath to add colour. Unlike painting, dye penetrates the surface layers rather than forming a coating.
Key process characteristics for pricing:
- Batch process: a dye bath handles many parts per cycle
- Dye cost varies significantly by colour (frequently used dyes are usually cheapest; while special colours are cost intensive)
- Soaking time varies by colour depth (lighter colours need less time)
How to model it
Two components:
- Dye cost: depends on colour - use a colour lookup
- Process cost: flat per batch, or area-based if you want to reflect how much dye the part absorbs
Area-based algorithm with colour multiplier
For larger parts where dye absorption is more significant:
const { area, color } = specification
const COLOR_MULTIPLIERS: Record<string, number> = {
'Black': 1.0,
'Grey': 1.2,
'Blue': 1.4,
'Red': 1.5,
'Yellow': 1.8,
}
const colorMultiplier = variable('Colour multiplier', COLOR_MULTIPLIERS[color ?? ''] ?? 1.5)
const BASE_RATE = variable('Base rate per mm²', 0.0015)
const MIN_CHARGE = variable('Minimum charge', 6.00)
const areaCost = round(area * BASE_RATE * colorMultiplier, 2)
const unitPrice = variable('unitPrice', Math.max(MIN_CHARGE, areaCost))
done(unitPrice)Notes
- If a colour isn't in your lookup, the equation uses a multiplier of 1.5 and does not flag the part for review. To quote unknown colours manually instead, end with
done({ price: unitPrice, reviewRequired: !(color && color in COLOR_MULTIPLIERS) }).
Shot peening and media blasting
What this process does
Shot peening / bead blasting propels small media (glass beads, plastic pellets, stainless shot) at the part surface at high velocity. Effects:
- Smoothing (bead blast): reduces surface roughness of parts
- Strengthening (shot peen): induces compressive stress, improves fatigue life on metal parts
- Cleaning (media blast): removes support, powder remnants or oxidation
Key pricing characteristic: cost is driven almost entirely by surface area - the machine blasts the entire surface of the part. Time per part scales with area. This can be a manual or automated process which might impact the cost as well.
Area-based algorithm
const { area } = specification
const ratePerMm2 = variable('Rate per mm²', 0.0018) // adjust per machine throughput
const MIN_CHARGE = variable('Minimum charge', 5.00)
const areaCost = round(area * ratePerMm2, 2)
const unitPrice = variable('unitPrice', Math.max(MIN_CHARGE, areaCost))
done(unitPrice)Notes
- Shot peening of metal parts (Ti, Inconel) uses the same structure but a higher rate and review flag for complex geometry that can't be fully reached by the shot stream.
- Parts with deep internal channels may need masking or multiple setups -
reviewRequiredforvolume / convexHullVolume < 0.5.
Thread inserts
What this process does
Heat-set brass or stainless steel inserts (M2-M12) are pressed into printed holes using a soldering iron or press. They provide durable threaded connections in plastic parts.
The number of inserts can't be calculated from geometry, so the Level 2 equation exposes it as a variable() for the operator to fill in and uses it to calculate the post-process charge. The equation does not need anything from Level 1.
Thread insert equation
const threadInsertCount = variable('Thread insert count', 0)
const threadInsertType = variable('Thread insert M size', 2)
// ... rest of your pricing & duration logic ...
// one could distinguish between different types, sizes and quantites with variable inputs
const RATE_PER_INSERT = 1.50 // this may depend on type and size
const MIN_CHARGE = variable('Minimum charge', 0) // 0 = no minimum (inserts are optional)
const calculatedCost = round(threadInsertCount * RATE_PER_INSERT, 2)
const unitPrice = variable('unitPrice', Math.max(MIN_CHARGE, calculatedCost))
const totalTimeInH = threadInsertCount * 2/60 // convert from minutes to hours
done(unitPrice, totalTimeInH)This creates a "Thread insert count" field for the thread insert post-process in the part's Modify Pricing dialog. The operator types the number of inserts when they review the order.
With the default count of 0, the price is 0, so Phasio sets the review flag. A customer who selects thread inserts cannot check out until you enter the count and click Approve for Purchase. While the option is unselected, the customer's quote does not include a price for it.
Size-dependent rates
If you charge differently for small vs large inserts, use a lookup. The insert size typically correlates with the model file name or a custom specification - or just expose multiple variable() fields at Level 2
// Level 2: separate counts per size
const m3Inserts = variable('M3 insert count', 0)
const m5Inserts = variable('M5 insert count', 0)
const m8Inserts = variable('M8 insert count', 0)
const M3_RATE = variable('M3 rate', 1.20)
const M5_RATE = variable('M5 rate', 1.80)
const M8_RATE = variable('M8 rate', 2.50)
const totalCost = (m3Inserts * M3_RATE) + (m5Inserts * M5_RATE) + (m8Inserts * M8_RATE)
const unitPrice = variable('unitPrice', round(totalCost, 2))
done(unitPrice)Notes
- If the operator doesn't fill in the insert count, it stays at 0 and the post-process charges €0 - which is correct (no inserts = no charge, but the pricing gate is triggered for manual review).
- This same pattern works for any manually-counted feature: threaded holes, colour changes, label placement, custom finishing.
Creating a custom post-process
Most post-processes can be built from one of three templates. Choose the one that matches how your cost scales, then modify the numbers.
Template 1 - Flat fee
Use when: the post-process costs roughly the same regardless of part size (e.g. inspection, marking, labelling, packaging).
// Level 2 equation
const FLAT_FEE = variable('Post-process cost', 8.00)
const unitPrice = variable('unitPrice', round(FLAT_FEE, 2))
done(unitPrice)That's it. The operator can override the fee per part line if needed.
Template 2 - Percentage of process price
Use when: the post-process adds a proportional cost relative to the part's base price (e.g. premium finishing, quality inspection tier).
// Level 2 equation
const PERCENTAGE = variable('Percentage price increase', 0.15) // 15%
const unitPrice = variable('unitPrice', round(processPricing.price * PERCENTAGE, 2))
done(unitPrice)processPricing.price is the unit price returned by the Level 1 equation for this part.
Template 3 - Geometry-based
Use when: cost depends on part size. Choose the right geometry metric:
| Cost driver | Use | Example |
|---|---|---|
| Surface treated | specification.area | Painting, plating, coating, blasting |
| Material consumed | specification.volume or shrinkWrapVolume | Resin coating, impregnation |
| Part weight | (volume / 1000) × density | Plating by gram, dyeing by mass |
// Level 2 equation — area-based example
const { area } = specification
const ratePerMm2 = variable('Rate per mm²', 0.002)
const MIN_CHARGE = variable('Minimum charge', 5.00)
const calculated = round(area * ratePerMm2, 2)
const unitPrice = variable('unitPrice', Math.max(MIN_CHARGE, calculated))
done(unitPrice)Using process equation data
If your post-process cost depends on something the Level 1 equation calculated (machine time, support volume, machine type), expose it via variable() at Level 1 and read it at Level 2:
// Level 1 (at the end, before done()):
const machineTimeHours = variable('machineTime', round(calculatedTime, 2))
done(unitPrice, machineTimeHours)// Level 2:
const printTime = processPricing.variables['machineTime'] // hours
const RATE = variable('Rate per hour', 3.00)
const unitPrice = variable('unitPrice', round(printTime * RATE, 2))
done(unitPrice)Rules for all post-process equations
- Always end with
done(unitPrice)- do not forget this - Always wrap the final price in
variable('unitPrice', ...)- this is the operator's escape hatch - Use
reviewRequiredwhen the post-process isn't available for this geometry, colour, or material:
const SUPPORTED_COLORS = ['Black', 'White', 'Grey']
const reviewRequired = !SUPPORTED_COLORS.includes(specification.color ?? '')
const unitPrice = variable('unitPrice', calculatedCost)
done({ price: unitPrice, reviewRequired }) // object form keeps workflow.duration- Never multiply by
requisition.quantity- Phasio does this automatically. Return the unit price for one part.
Last updated on
Process examples
Complete pricing equations for powder bed, FDM, large format FDM, SLA/DLP, metal LPBF, ceramics, CNC machining and vacuum casting, with the questions to answer before you build your own.
Cookbook
Copy-paste pricing snippets and complete starter equations for common manufacturing patterns. Find the pattern, copy the code, adjust the numbers.