Skip to Content

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-processProcess equation input usedPrimary cost driver
Vapor smoothingPart volume, areaMachine time + solvent
DyeingPart volumeDye cost + batch utilisation
Shot peening and media blastingSurface areaMachine time
Thread insertsOperator-entered count, variable('Thread insert count', 0) in the post-process equationCount × rate
Creating a custom post-processVariesThree 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 quantity

Batch 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 run

Material 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:

  1. Dye cost: depends on colour - use a colour lookup
  2. 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 - reviewRequired for volume / 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 driverUseExample
Surface treatedspecification.areaPainting, plating, coating, blasting
Material consumedspecification.volume or shrinkWrapVolumeResin coating, impregnation
Part weight(volume / 1000) × densityPlating 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

  1. Always end with done(unitPrice) - do not forget this
  2. Always wrap the final price in variable('unitPrice', ...) - this is the operator's escape hatch
  3. Use reviewRequired when 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
  1. Never multiply by requisition.quantity - Phasio does this automatically. Return the unit price for one part.

Last updated on

On this page