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.
Phasio lets you define a pricing equation for any manufacturing process. This page works through complete process equations for the most common technologies. If your process isn't listed, use the AI prompt on the Pricing Guide to build one from scratch, or read Before you build first to think through your cost structure.
Each process section follows the same structure: why this process is unique → core methodology → numerical example → complete algorithm → when to use it.
| Process | Key metric | Primary cost driver |
|---|---|---|
| Powder bed (SLS and MJF) | shrinkWrapVolume | Volume in chamber |
| FDM filament extrusion | volume, area, convexHullVolume | Print time |
| Large format FDM | volume, area | Print time + material |
| SLA, DLP and LCM | volume, convexHullVolume | Resin + machine time |
| Metal LPBF (SLM and DMLS) | volume, convexHullVolume | Machine time (dominant) |
| Ceramics LCM | volume | Machine time (dominant), expensive material |
| CNC machining | minBoundingBoxVolume, volume | Machining time + stock |
| Vacuum casting | volume | Mould amortisation + casting |
Before you build
Before writing a single line of code, the quality of your equation depends entirely on how well you understand your own cost structure. This section is a thinking guide - not a checklist to tick off, but a set of questions that reveal where your pricing complexity actually lives.
The fastest path is the AI prompt in the Pricing Guide
It is designed to run exactly this interview for you - paste it into Claude or ChatGPT and it will ask the right questions, propose an equation, and iterate with you until it matches your real prices. Come back here if you want to think things through before that conversation.
1. What are your main cost drivers?
Start here. Most processes have one or two dominant costs - everything else is a rounding error until you get those right.
| Cost type | Ask yourself |
|---|---|
| Material | Do I sell material by weight, volume, or area? Is scrap/waste significant? |
| Machine time | Does a longer or larger part actually take more time on my machine? |
| Setup / amortisation | Is there a fixed cost per job (programming, fixturing, changeover) that I spread across quantity? |
| Labour | Is there significant manual work per part, or is it largely unattended? |
| Consumables | Resin, powder refresh, solvents, tooling wear - are these a material cost per part? |
If you're not sure, look at your last 10 jobs and ask: which line item on my cost sheet varies most part-to-part? That's your primary driver.
2. Do you have historical job data to calibrate against?
An equation built without calibration is a guess. Before going live, you need at least 3-5 real parts with known prices to validate against.
- Pull your last 10-20 jobs for this process
- For each: record the part dimensions, quantity, what you charged, and what it actually cost you
- After writing your equation, run those parts through it and compare - the first mismatch tells you which cost driver you've modelled wrong
If you don't have historical data yet, start with conservative rates and a reviewRequired gate on everything until you've built enough confidence to open up auto-approval.
3. What does your minimum price look like?
- What's the minimum you'd charge for a single part, regardless of how small it is?
- Is there a minimum per material, per batch, or per post-process?
- Is there a minimum order value for the whole cart?
All three can be set - minimum unit price in Level 1, minimum per material, per post-process, and order value in Level 3. Level 2 sees one part at a time, so a minimum per post-process across several parts needs Level 3, which reads specification.postProcessing[].price for every part.
4. Quantity: do you offer discounts, and what does the curve look like?
- At what quantity does the unit price start to drop?
- Does it drop smoothly or in steps? (Steps are easier to communicate, smooth curves better reflect real cost structure)
- Is there a floor - a point where the discount stops?
- Does your machine capacity affect this? (A process with 10 machines can take larger orders without surcharging; a single machine may need a lead time premium at high quantities)
5. What machines do you have, and how do you assign jobs to them?
- List your machines, their build volumes (X × Y × Z mm), and their running cost per hour
- How do you decide which machine a job goes to? Smallest that fits? Fastest available? Operator decision?
- What happens when a part is too large for all machines? (This should trigger
reviewRequired)
Machine selection logic is straightforward in the equation - but you need to know your machines before you can write it.
6. What material variables will your equation need?
This is a common reason equations misprice: the equation references material.variables['someKey'] but the material has no value for that key. Saving the equation does not check this. The equation reads undefined, the price becomes NaN, and Phasio stores a price of 0 with the review flag set.
Plan your material schema before you open the equation editor.
Keep material variables minimal
Only put values on the material that genuinely differ between materials - typically the raw material cost and density. Machine rates, setup costs, speed factors, and business rules should be hardcoded constants in the equation itself. Over-stuffing the material schema is one of the most common mistakes and makes equations hard to maintain.
A useful test: "Would I set this value differently for PA12 vs TPU vs Alumide?" If yes → material variable. If no → hardcode it.
The path in Phasio: Settings > Manufacturing > Processes > [your process] > Materials. Add the variable name under Material Schema, then set its value on each material under Pricing variables.
What belongs on the material:
| Key | Why it's per-material |
|---|---|
materialDensity | Determines part weight - genuinely differs (PA12 ≠ TPU ≠ steel) |
materialCostPerKg | Raw material price varies per material |
resinCostPerLiter | Resin price varies per resin type |
costPerCm3 | Powder bed cost rate per volume varies per material |
rawMaterialCostPerKg | CNC stock cost varies by alloy / grade |
7. What should trigger manual review?
Not every part should auto-price. Be explicit about your gates before building the equation:
| Trigger | Examples |
|---|---|
| Size | Part exceeds machine build volume |
| Geometry | Open mesh (non-watertight), extremely thin walls, very high material removal ratio |
| Material | Material not set up with the required variables |
| Quantity | Unusually high quantity that might require a dedicated run or custom agreement |
| Duration | Estimated print/machine time exceeds X hours |
| Customer | New account, unapproved customer, flagged for manual pricing |
| Price | Calculated price falls below your cost floor (equation probably wrong) |
8. What should operators be able to override per part line?
variable() exposes any value in the operator UI so your team can adjust it for each part line without touching the equation. Before building, decide:
- Which values should be overridable? (support volume, print time, unit price, machine assignment)
- Which values should be locked? (cost rates, margin - things only you should change)
As a rule: expose the outputs of cost calculations (print time, unit price) so operators can adjust the result. Lock the inputs (material costs) in material.variables where only admins can change them.
9. What lead times do you offer, and do they affect price?
- What lead time tiers have you configured in Phasio? (Economy, Standard, Express...)
- Does a faster lead time cost more? Does a slower one offer a discount?
- Does the lead time surcharge taper at high quantities? (A 100-part rush is easier to absorb than a 1-part rush)
10. Do you have customer-specific pricing?
- Are there accounts with negotiated rates on specific materials or processes?
- Should these be visible as discounts, or baked silently into the unit price?
See Business logic for implementation patterns.
11. What post-processes attach to this process?
- Which post-processes are available for this material/process combination?
- Are any of them priced as a percentage of the part price, or independently?
- Do any post-processes have minimum batch costs? (Dyeing, vapor smoothing, anodising often do)
Post-process pricing lives at Level 2 - but if the Level 1 equation needs to expose variables that Level 2 will read (e.g. print time for a UV curing step), decide that now and expose them via variable().
When you're ready
If you can answer most of the above, you have enough to build a working first equation. You don't need all the answers - use reviewRequired as a safety net for anything you're not confident about yet, and open up auto-approval as you gain confidence from real order data.
Go to the Pricing Guide and copy the AI prompt. Paste it into Claude or ChatGPT, answer its questions, and you'll have a working equation to paste into Phasio. The process sections below are there when you want to understand the methodology behind a specific process in depth.
Powder bed (SLS and MJF)
Why this process is unique
Powder bed processes (SLS, MJF, HSS) don't use support structures - the unfused powder supports the part during printing. This has two major pricing implications:
- Cost is driven by chamber volume occupied, not just part volume. A small dense part and a large hollow part with the same actual volume cost very differently.
- Build setup is expensive - depowdering, cake extraction, powder sieving, and material refresh are significant fixed costs per build. These must be amortised over all parts in the run.
The standard cost metric is shrinkWrapVolume - the tightest wrapping around the part including overhangs. It's the best proxy for how much of the chamber the part consumes.
Core methodology
Variable cost: shrinkWrapVolume × cost per cm³
Fixed cost: setup fee per build, divided by quantity ordered
Quantity discount: banded, reflecting better chamber utilisation and batch efficiency
Review gate: parts exceeding the chamber in any dimension
HP MJF 5200 Pro specifications (reference)
- Build volume: 380 × 284 × 380 mm
- Layer height: 0.08 mm
- Typical cycle: 8-12 hours per full build
Numerical example
Part: 50 × 50 × 100 mm bracket, shrinkWrapVolume = 210,000 mm³ (part has overhangs)
| Input | Value |
|---|---|
costPerCm3 | €0.18 |
setupCost | €80 |
| Quantity | 5 |
Calculation:
- Volume cost: (210,000 / 1,000) × 0.18 = €37.80
- Setup per part: 80 / 5 = €16.00
- Subtotal: €53.80
- Qty 5 discount (band from 5 units): ×0.97
- Unit price: €52.19
At qty 50: setup = €1.60/part, discount 17% (×0.83) → unit price €32.70. The volume cost is now 96% of the cost before the discount.
Complete algorithm
const { material, shrinkWrapVolume, length, width, height } = specification
const { quantity } = requisition
// Machine chamber limits — adapt to your printer
const CHAMBER_LENGTH = 380
const CHAMBER_WIDTH = 284
const CHAMBER_HEIGHT = 380
const costPerCm3 = material.variables['costPerCm3']
const setupCost = material.variables['setupCost']
// Variable cost: shrink wrap volume × rate.
// shrinkWrapVolume can be null: fall back to the bounding box volume, which overestimates.
const volumeCm3 = (shrinkWrapVolume ?? width * height * length) / 1000
const volumeCost = round(volumeCm3 * costPerCm3, 2)
// Fixed cost: setup amortised over order quantity
const setupPerPart = round(setupCost / quantity, 2)
const baseCost = volumeCost + setupPerPart
// Quantity discount: smaller batches pay more per part
const getDiscount = createBands({ 5: 0.97, 10: 0.93, 25: 0.88, 50: 0.83, 100: 0.78 }, 1.0)
const unitPrice = variable('unitPrice', round(baseCost * getDiscount(quantity), 2))
// Review gate: part exceeds chamber dimensions
const oversized = length > CHAMBER_LENGTH || width > CHAMBER_WIDTH || height > CHAMBER_HEIGHT
done({ price: unitPrice, reviewRequired: oversized })Material variables to create: costPerCm3, setupCost
When to use this
Use this model for any powder bed process: MJF, SLS, HSS, SAF. All share the same pricing structure.
Do not use for metal powder bed (LPBF) - print time dominates there and requires a time-based model.
You could also think of a packing algorithm to predict the usage of the build chamber at larger quantities.
FDM filament extrusion
Why this process is unique
FDM pricing is dominated by print time, not material cost. A structurally solid part uses similar material volume to the same part printed hollow, but they take very different amounts of machine time.
The key insight is to split the part into three regions that print at different speeds:
- Shell (outer walls): slow, many direction changes
- Infill: fast, long sweeping lines
- Supports: medium speed, low density
Cost = material consumed + machine time × rate
Core methodology
Shell volume: Math.min(volume, area × nozzle × walls) - bounded so thin parts don't produce negative infill
Infill volume: (volume - shellVolume) × infillDensity
Support volume: estimated from the convex hull gap, exposed via variable() for override
Print time: each region's volume ÷ volumetric flow rate, summed and multiplied by overhead
Shell penalty: parts heavy in shell features print slower than their volume suggests
Numerical example
Part: 40 × 40 × 80mm post, 20% infill, volume = 30,000 mm³, area = 14,400 mm²
| Parameter | Value |
|---|---|
| Nozzle diameter | 0.4 mm |
| Layer height | 0.2 mm |
| Wall count | 3 |
| Base speed | 60 mm/s |
| Wall speed factor | 0.5 |
| Infill speed factor | 1.0 |
| Machine rate | €6/h (Small desktop FFF, the first machine the part fits) |
materialCostPerKg | €28, materialDensity = 1.24 g/cm³ |
convexHullVolume | 30,000 mm³ (no support) |
minUnitPrice | €5 |
Shell volume: min(30,000, 14,400 × 0.4 × 3) = min(30,000, 17,280) = 17,280 mm³
Infill volume: (30,000 − 17,280) × 0.20 = 2,544 mm³
Wall time: 17,280 / (0.4 × 0.2 × 60 × 0.5) = 17,280 / 2.4 = 7,200 s
Infill time: 2,544 / (0.4 × 0.2 × 60 × 1.0) = 2,544 / 4.8 = 530 s
Shell penalty: 1 + 0.5 × (17,280 / (17,280 + 2,544 + 1))² = 1.38
Print time: (7,200 + 530) × 1.3 × 1.38 / 3600 = 3.85 hours
Material cost: (17,280 + 2,544 + 0 support) / 1,000 × 1.24 / 1,000 × 28 = €0.69
Machine cost: 3.85 × 6 = €23.10
Unit price (1 part, no discount): €23.79
Complete algorithm
const { material, width, height, length, volume, area, convexHullVolume, infill } = specification
const { quantity } = requisition
// --- Machine definitions ---
const MACHINES = [
{ name: 'Small desktop FFF', bed: { l: 256, w: 256, h: 256 }, costPerHour: 6 },
{ name: 'Medium desktop FFF', bed: { l: 300, w: 300, h: 300 }, costPerHour: 7 },
{ name: 'Big desktop FFF', bed: { l: 320, w: 320, h: 325 }, costPerHour: 9 },
]
function selectMachine() {
return MACHINES.find(m =>
length <= m.bed.l && width <= m.bed.w && height <= m.bed.h
) ?? MACHINES[MACHINES.length - 1]
}
// --- Constants ---
const NOZZLE_DIAMETER_MM = 0.4
const NUMBER_OF_WALLS = 3
const SUPPORT_INFILL = 0.2
const PRINT_TIME_OVERHEAD = 1.3
// --- Geometry ---
// Layer height in mm. Do not read it from precision: precision.value is a price multiplier.
const layerHeight = 0.20
const partInfill = infill?.value ?? 0.20
const shellVolume = Math.min(volume, area * NOZZLE_DIAMETER_MM * NUMBER_OF_WALLS)
const infillVolume = (volume - shellVolume) * partInfill
const hullGap = (convexHullVolume ?? volume) - volume // convexHullVolume can be null
const supportVolume = variable('supportVolume', round(hullGap * 0.10, 0))
// --- Material cost ---
const materialDensity = material.variables['materialDensity']
const materialCostPerKg = material.variables['materialCostPerKg']
const mainWeight = ((shellVolume + infillVolume) / 1000) * materialDensity / 1000
const supportWeight = ((supportVolume * SUPPORT_INFILL) / 1000) * materialDensity / 1000
const materialCost = round((mainWeight + supportWeight) * materialCostPerKg, 2)
// --- Print time ---
const baseSpeed = material.variables['baseSpeedNozzle']
const wallSpeedFactor = material.variables['wallSpeedFactor']
const infillSpeedFactor = material.variables['infillSpeedFactor']
const supportSpeedFactor = material.variables['supportSpeedFactor']
const wallTime = shellVolume / (NOZZLE_DIAMETER_MM * layerHeight * baseSpeed * wallSpeedFactor)
const infillTime = infillVolume / (NOZZLE_DIAMETER_MM * layerHeight * baseSpeed * infillSpeedFactor)
const supportTime = (supportVolume * SUPPORT_INFILL) / (NOZZLE_DIAMETER_MM * layerHeight * baseSpeed * supportSpeedFactor)
const shellPenalty = 1 + 0.5 * Math.pow(shellVolume / (shellVolume + infillVolume + 1), 2)
const printTimeHours = variable('printTime', round(
(wallTime + infillTime + supportTime) * PRINT_TIME_OVERHEAD * shellPenalty / 3600, 2
))
// --- Machine cost ---
// variable() only takes numbers, so expose the machine as its position in MACHINES.
// The operator can type another number to switch machine.
const machineNumber = variable('Machine (1 = Small, 2 = Medium, 3 = Big)', MACHINES.indexOf(selectMachine()) + 1)
const machine = MACHINES[machineNumber - 1] ?? selectMachine()
const machineCost = round(printTimeHours * machine.costPerHour, 2)
// --- Pricing ---
const hardwareCost = variable('Hardware cost', 0)
const getDiscount = createBands({ 10: 0.95, 50: 0.90, 100: 0.85, 250: 0.80 }, 1.0)
const baseCost = (materialCost + machineCost + hardwareCost) * getDiscount(quantity)
const MIN_PRICE = material.variables['minUnitPrice']
const unitPrice = variable('unitPrice', Math.max(MIN_PRICE, round(baseCost, 2)))
// --- Review gate ---
const largest = MACHINES[MACHINES.length - 1].bed
const oversized = length > largest.l || width > largest.w || height > largest.h
done(unitPrice, printTimeHours, oversized)Material variables: materialDensity, materialCostPerKg, baseSpeedNozzle, wallSpeedFactor, infillSpeedFactor, supportSpeedFactor, minUnitPrice
When to use this
All desktop and industrial FFF/FDM printers. Any extrusion process where print time is the main cost driver.
For very large parts (>500mm), use Large format FDM instead.
Large format FDM
Why this process is unique
Large format FDM (pellet extrusion, gantry systems, SCARA robots) differs from desktop FDM in three key ways:
- Nozzle diameter is much larger (2-10mm vs 0.4mm) - faster deposition, lower resolution
- Layer height is proportionally larger (1-5mm) - print times can still be long but fewer layers
- Material is sold by the kg or tonne (pellets), not by the spool - far cheaper per kg
The time-based FDM model still applies, but constants change significantly. Shell layer count is typically 2-3, infill is often 15-25%, and support fraction from the hull gap may need a higher estimate for complex geometries (sparse supports, large overhangs).
Core methodology
Same as standard FDM:
- Shell + infill + support volume split
- Print time = volume ÷ volumetric flow rate, summed by region
- Machine cost = time × cost per hour
- Material cost = mass × cost per kg
Key differences in the constants:
| Parameter | Desktop FDM | Large Format FDM |
|---|---|---|
| Nozzle diameter | 0.4 mm | 5-10 mm |
| Layer height | 0.1-0.3 mm | 2-5 mm |
| Wall speed factor | 0.4-0.6 | 0.5-0.7 |
| Material cost per kg | €20-80 | €3-20 (pellets) |
| Machine cost per hour | €5-15 | €40-150 |
Numerical example
Part: 600 × 400 × 300 mm enclosure panel, volume = 4,800,000 mm³ (hollow walls)
| Parameter | Value |
|---|---|
| Nozzle diameter | 8 mm |
| Layer height | 4 mm |
| Wall count | 2 |
| Base speed | 120 mm/s |
| Wall speed factor | 0.6 |
| Infill (15%) | 0.15 |
| Machine cost per hour | €80 |
| Material cost per kg | €8 (ABS pellets), density 1.04 g/cm³ |
Shell volume: min(4.8M, area × 8 × 2) - area depends on geometry Print time estimate: ~6 hours (large nozzle deposits fast) Machine cost: 6 × 80 = €480 Material cost: ~5 kg × 8 = €40 Unit price: ~€520 + overhead
Complete algorithm
const { material, width, height, length, volume, area, convexHullVolume, infill } = specification
const { quantity } = requisition
// Large format machine — adjust to your system
const MACHINE_BED_L = 2000
const MACHINE_BED_W = 1500
const MACHINE_BED_H = 1000
const NOZZLE_DIAMETER_MM = material.variables['nozzleDiameterMm'] // e.g. 8
const NUMBER_OF_WALLS = 2
const SUPPORT_INFILL = 0.15
const PRINT_TIME_OVERHEAD = 1.25
// Layer height in mm. Do not read it from precision: precision.value is a price multiplier.
const layerHeight = 4.0
const partInfill = infill?.value ?? 0.15
const shellVolume = Math.min(volume, area * NOZZLE_DIAMETER_MM * NUMBER_OF_WALLS)
const infillVolume = (volume - shellVolume) * partInfill
const hullGap = (convexHullVolume ?? volume) - volume // convexHullVolume can be null
const supportVolume = variable('supportVolume', round(hullGap * 0.15, 0))
const materialDensity = material.variables['materialDensity']
const materialCostPerKg = material.variables['materialCostPerKg']
const totalVolumeMm3 = shellVolume + infillVolume + supportVolume * SUPPORT_INFILL
const massKg = (totalVolumeMm3 / 1_000_000) * materialDensity
const materialCost = round(massKg * materialCostPerKg, 2)
const baseSpeed = material.variables['baseSpeedNozzle']
const wallSpeedFactor = material.variables['wallSpeedFactor']
const infillSpeedFactor = material.variables['infillSpeedFactor']
const supportSpeedFactor = material.variables['supportSpeedFactor']
const machineCostPerHour = material.variables['machineCostPerHour']
const wallTime = shellVolume / (NOZZLE_DIAMETER_MM * layerHeight * baseSpeed * wallSpeedFactor)
const infillTime = infillVolume / (NOZZLE_DIAMETER_MM * layerHeight * baseSpeed * infillSpeedFactor)
const supportTime = (supportVolume * SUPPORT_INFILL) / (NOZZLE_DIAMETER_MM * layerHeight * baseSpeed * supportSpeedFactor)
const shellPenalty = 1 + 0.3 * Math.pow(shellVolume / (shellVolume + infillVolume + 1), 2)
const printTimeHours = variable('printTime', round(
(wallTime + infillTime + supportTime) * PRINT_TIME_OVERHEAD * shellPenalty / 3600, 2
))
const machineCost = round(printTimeHours * machineCostPerHour, 2)
const baseCost = materialCost + machineCost
const unitPrice = variable('unitPrice', round(baseCost, 2))
const oversized = length > MACHINE_BED_L || width > MACHINE_BED_W || height > MACHINE_BED_H
done(unitPrice, printTimeHours, oversized)Material variables: nozzleDiameterMm, materialDensity, materialCostPerKg, baseSpeedNozzle, wallSpeedFactor, infillSpeedFactor, supportSpeedFactor, machineCostPerHour
When to use this
Pellet extrusion systems printing parts larger than ~400mm. Parts are typically structural, prototypes, tooling, moulds, or formwork - where surface finish is secondary to speed and size.
SLA, DLP and LCM
Why this process is unique
Vat photopolymerisation (SLA, DLP, LCD, LCM) cures liquid resin layer by layer using UV light. Cost has two components:
- Resin: sold by the litre, significantly more expensive than FDM filament
- Machine time: layer count × time per layer × cost per hour
Supports are mandatory for most prints. They consume resin and add post-processing time (removal, sanding). Unlike FDM, supports in vat processes are separate structures added by the slicer - estimate from the convex hull gap.
SLA vs DLP - the critical pricing distinction
SLA and DLP cure resin fundamentally differently. This changes how time per layer behaves and has direct consequences for pricing.
| SLA | DLP / MSLA / LCM | |
|---|---|---|
| How it works | Laser traces the contour and fill of each layer point by point | UV projector or masked screen exposes the entire layer simultaneously |
| Time per layer | Scales with cross-sectional area - more to scan = longer | Fixed exposure time regardless of layer area or part count |
| Packing more parts | Each additional part increases cross-section to scan, so each layer takes longer | Nearly free - same exposure time whether 1 or 10 parts fill the plate |
timePerLayer in your equation | Calibrate per typical part size, or calculate from area | Set as a fixed constant for your machine and resin |
For SLA: print time grows with both layer count and the amount the laser has to trace per layer. Nesting more parts on the build plate can reduce per-part machine cost, but only up to a point - each added part increases the cross-section to scan, making every layer slower. On large or dense plates the benefit of nesting shrinks significantly.
For DLP / MSLA / LCM: the projector flashes the entire layer at once. Packing more parts onto the plate does not increase time per layer at all - nesting is almost always a win.
Warning
The algorithm below uses a fixed timePerLayer - correct for DLP/MSLA/LCM. For SLA, see Adapting for SLA.
Core methodology
Resin volume: actual part volume + estimated support volume + waste
Print time: numberOfLayers × timePerLayer. The part is usually oriented at an angle (45°) to minimise layer count and support contact area.
Orientation effect: at 45°, the effective print height = longest dimension × cos(45°) ≈ longest × 0.707
Numerical example
Part: 50 × 30 × 80mm bracket, volume = 30,000 mm³, convexHullVolume = 35,000 mm³, area = 12,000 mm²
| Parameter | Value |
|---|---|
resinCostPerLiter | €95 |
machineCostPerH | €12 |
| Layer height | 0.06 mm |
| Time per layer | 25 s |
Resin volume:
- Part: 30,000 mm³
- Supports: (35,000 − 30,000) × 0.10 = 500 mm³
- Waste: 12,000 mm² × 0.05 = 600 mm³
- Total: 31,100 mm³ = 0.0311 L
- Resin cost: 0.0311 × 95 = €2.95
Print time:
- maxDim = 80mm, at 45°: height = 80 × 0.7071 = 56.57mm
- Layers: ceil(56.57 / 0.06) = 943
- Time: 943 × 25 / 3600 = 6.55 hours
- Machine cost: 6.55 × 12 = €78.60
Unit price (1 part): €81.55
Complete algorithm
const { material, width, height, length, volume, area, convexHullVolume } = specification
const { quantity } = requisition
// Chamber limits
const CHAMBER_LENGTH = 220
const CHAMBER_WIDTH = 125
const CHAMBER_HEIGHT = 200
const LAYER_HEIGHT_MM = 0.06
const resinCostPerLiter = material.variables['resinCostPerLiter']
const machineCostPerH = material.variables['machineCostPerH']
// Resin volume: part + supports + waste
const supportVolumeMm3 = ((convexHullVolume ?? volume) - volume) * 0.10 // convexHullVolume can be null
const wasteVolumeMm3 = area * 0.05
const totalVolumeLiters = (volume + supportVolumeMm3 + wasteVolumeMm3) / 1_000_000
const materialCost = round(totalVolumeLiters * resinCostPerLiter, 2)
// Print time: parts are tilted 45° to minimise Z height
const maxDimension = Math.max(width, height, length)
const heightAt45Deg = maxDimension * Math.cos(45 * (Math.PI / 180))
const numberOfLayers = Math.ceil(heightAt45Deg / LAYER_HEIGHT_MM)
const timePerLayer = variable('timePerLayer', 25) // seconds, override for different resins
const printTimeHours = variable('printTime', round(numberOfLayers * timePerLayer / 3600, 2))
const machineCost = round(printTimeHours * machineCostPerH, 2)
// Pricing
const getDiscount = createBands({ 5: 0.95, 10: 0.90, 20: 0.875, 40: 0.85, 80: 0.825 }, 1.0)
const baseCost = (materialCost + machineCost) * getDiscount(quantity)
const unitPrice = variable('unitPrice', round(baseCost, 2))
const oversized = length > CHAMBER_LENGTH || width > CHAMBER_WIDTH || height > CHAMBER_HEIGHT
done(unitPrice, printTimeHours, oversized)Material variables: resinCostPerLiter, machineCostPerH
Adapting for SLA
For SLA, replace the fixed timePerLayer with one that scales with cross-sectional area. The laser scans at a fixed speed, so more area = more time.
Estimating average cross-section:
The ratio volume / minBoundingBoxVolume tells you what fraction of the bounding box is actually solid. Apply that fill ratio to the XY footprint of the bounding box and you get the average cross-section the laser has to trace per layer:
avgCrossSection = (length × width) × (volume / minBoundingBoxVolume)
= volume / heightThis simplifies neatly: average cross-sectional area = total volume ÷ effective print height. No surface area involved - surface area is the outer skin, not the per-layer slice.
// Add minBoundingBoxVolume to the destructure at the top of the main algorithm.
// Average cross-section: fill ratio applied to XY bounding footprint
// Equivalent to volume / heightAt45Deg — derived from bbox fill ratio
const fillRatio = volume / (minBoundingBoxVolume ?? length * width * height) // can be null
const avgCrossSectionMm2 = length * width * fillRatio // = volume / height
// Laser scan speed in mm2/s — set as a material variable for your machine
const scanSpeedMm2PerSec = material.variables['scanSpeedMm2PerSec'] // e.g. 1000
const timePerLayerSLA = variable('timePerLayer', round(avgCrossSectionMm2 / scanSpeedMm2PerSec, 2))
const printTimeHours = variable('printTime', round(numberOfLayers * timePerLayerSLA / 3600, 2))For SLA you should also treat nesting conservatively: each additional part on the plate adds its cross-section to every shared layer, so packing many large parts can make the machine cost per part increase rather than decrease.
When to use this
All UV vat processes. For DLP / MSLA / LCM: use the main algorithm as-is with a fixed timePerLayer. For SLA: use the adapted version above with scanSpeedMm2PerSec as a material variable.
Metal LPBF (SLM and DMLS)
Why this process is unique
Laser Powder Bed Fusion (LPBF) - also called SLM, DMLS is expensive AM process to run. Cost is dominated almost entirely by machine time, not material.
Key characteristics:
- Machine cost per hour: €80-250+ (inert gas consumption, laser wear, maintenance)
- Layer heights: 0.02-0.06mm - far thinner than polymer processes
- Print speeds: much slower than MJF or FDM per cm³
- Supports are mandatory and made of metal - dense, slow to print, costly to remove
- Heat treatment (stress relief, HIP) is typically mandatory post-process
- Material is expensive: Ti-6Al-4V ~€300-500/kg, 316L ~€80-120/kg, Inconel ~€400+/kg
Despite high material costs, machine time typically accounts for 60-80% of a metal part's price.
Core methodology
Use a simplified time model based on build volume and laser scanning speed:
Print time = (layer count × area per layer) ÷ scan speed + overhead
Or, simpler and nearly as accurate for quoting:
Print time ≈ (shrinkWrapVolume + support volume) ÷ build rate
Where buildRate = mm³/hour of actual metal deposited (a material variable, calibrated per machine and material).
Numerical example
Part: 30 × 30 × 60 mm bracket, volume = 10,000 mm³, convexHullVolume = 13,000 mm³
| Parameter | Value |
|---|---|
| Material: 316L stainless steel | |
| Density | 7.9 g/cm³ |
| Material cost per kg | €100 |
buildRateMm3PerHour | 5,000 |
machineCostPerHour | €130 |
setupCost | €150 |
Support volume: (13,000 − 10,000) × 0.40 = 1,200 mm³ (dense metal supports) Print volume: 10,000 + 1,200 = 11,200 mm³ Print time: 11,200 / 5,000 = 2.24 hours Machine cost: 2.24 × 130 = €291.20 Material mass: (10,000 / 1,000) × 7.9 / 1,000 = 79g = 0.079 kg Material cost: 0.079 × 100 = €7.90 Setup (1 part): €150 Total: €449.10 - machine time is 65% of cost
Complete algorithm
const { material, volume, convexHullVolume, length, width, height } = specification
const { quantity } = requisition
// Chamber limits — adjust to your machine (e.g. EOS M290 = 250×250×325mm)
const CHAMBER_LENGTH = 250
const CHAMBER_WIDTH = 250
const CHAMBER_HEIGHT = 325
const buildRateMm3PerHour = material.variables['buildRateMm3PerHour']
const machineCostPerHour = material.variables['machineCostPerHour']
const setupCost = material.variables['setupCost']
const materialDensity = material.variables['materialDensity']
const materialCostPerKg = material.variables['materialCostPerKg']
// Support volume (metal supports are denser than FDM — use 35–45%)
const hullGap = (convexHullVolume ?? volume) - volume // convexHullVolume can be null
const supportVolume = variable('supportVolume', round(hullGap * 0.40, 0))
// Print time based on build rate
const printVolume = volume + supportVolume
const printTimeHours = variable('printTime', round(printVolume / buildRateMm3PerHour, 2))
const machineCost = round(printTimeHours * machineCostPerHour, 2)
// Material cost (part only, not support — support is removed)
// volume in mm³. density in g/cm³. 1 cm³ = 1000 mm³
const massGrams = (volume / 1000) * materialDensity
const materialCost = round((massGrams / 1000) * materialCostPerKg, 2)
// Setup amortised (typically one part per build for LPBF unless batch run)
const setupPerPart = round(setupCost / quantity, 2)
const baseCost = machineCost + materialCost + setupPerPart
const unitPrice = variable('unitPrice', round(baseCost, 2))
const oversized = length > CHAMBER_LENGTH || width > CHAMBER_WIDTH || height > CHAMBER_HEIGHT
// Also flag open mesh — geometry errors cause metal build failures
const reviewRequired = oversized || !revision.watertight
done(unitPrice, printTimeHours, reviewRequired)Material variables: buildRateMm3PerHour, machineCostPerHour, setupCost, materialDensity, materialCostPerKg
When to use this
All laser powder bed fusion of metals: SLM, DMLS, LPBF, DMP. Works for steel, titanium, aluminium, Inconel, copper. Adjust buildRateMm3PerHour and machineCostPerHour per alloy and machine.
Ceramics LCM
Why this process is unique
Lithography-based Ceramic Manufacturing (LCM, developed by Lithoz) is vat photopolymerisation with ceramic-loaded slurry instead of standard resin. After printing, parts undergo debinding and sintering - burning off the polymer binder and fusing the ceramic particles.
Key pricing characteristics:
- Material is expensive: zirconia slurry is €2,000-5,000+ per litre, but small parts use very little of it, so machine time usually dominates the price
- Parts shrink: ~20% linear shrinkage during sintering. Geometry should be scaled up before printing, but this is the operator's concern, not the equation's.
- Small parts: ceramic parts are typically small and intricate (dental, medical, industrial nozzles)
- Print time similar to SLA: layer-based exposure, fixed time per layer
- Sintering is a separate step: typically handled in post-process pricing, not Level 1
Core methodology
Same structure as SLA/DLP, but:
resinCostPerLiteris much higher (ceramic slurry price)- Support fraction from hull gap is smaller (ceramics parts often have fewer overhangs due to design constraints)
- Machine cost is usually the largest part of the price
Numerical example
Part: 10 × 8 × 15 mm dental crown, volume = 300 mm³, convexHullVolume = 500 mm³
| Parameter | Value |
|---|---|
slurryCostPerLiter | €3,200 |
machineCostPerH | €18 |
| Layer height | 0.025 mm |
| Time per layer | 30 s |
Resin volume: 300 mm³ + supports (500 − 300) × 0.05 = 310 mm³ = 0.00031 L
Material cost: 0.00031 × 3,200 = €0.99
Layers: tilted 45°, 15 × 0.7071 = 10.61 mm → ceil(10.61 / 0.025) = 425
Print time: 425 × 30 / 3600 = 3.54 hours
Machine cost: 3.54 × 18 = €63.72
Unit price (1 part): €64.71 - material is only 1.5% of cost at this scale
For larger parts (50mm+) material cost grows but machine time still dominates.
Complete algorithm
const { material, volume, area, convexHullVolume, length, width, height } = specification
const { quantity } = requisition
// Lithoz CeraFab S65 chamber: 76 × 43 × 150 mm
const CHAMBER_LENGTH = 76
const CHAMBER_WIDTH = 43
const CHAMBER_HEIGHT = 150
const LAYER_HEIGHT_MM = 0.025
const slurryCostPerLiter = material.variables['slurryCostPerLiter']
const machineCostPerH = material.variables['machineCostPerH']
// Material
const supportVolumeMm3 = ((convexHullVolume ?? volume) - volume) * 0.05 // fewer supports; hull can be null
const totalVolumeLiters = (volume + supportVolumeMm3) / 1_000_000
const materialCost = round(totalVolumeLiters * slurryCostPerLiter, 2)
// Print time
const maxDimension = Math.max(width, height, length)
const heightAt45Deg = maxDimension * Math.cos(45 * (Math.PI / 180))
const numberOfLayers = Math.ceil(heightAt45Deg / LAYER_HEIGHT_MM)
const timePerLayer = variable('timePerLayer', 30) // seconds
const printTimeHours = variable('printTime', round(numberOfLayers * timePerLayer / 3600, 2))
const machineCost = round(printTimeHours * machineCostPerH, 2)
// Pricing
const getDiscount = createBands({ 5: 0.95, 20: 0.90, 50: 0.85 }, 1.0)
const baseCost = (materialCost + machineCost) * getDiscount(quantity)
const unitPrice = variable('unitPrice', round(baseCost, 2))
const oversized = length > CHAMBER_LENGTH || width > CHAMBER_WIDTH || height > CHAMBER_HEIGHT
done(unitPrice, printTimeHours, oversized)Material variables: slurryCostPerLiter, machineCostPerH
When to use this
LCM (Lithoz), ceramic DLP, or any slurry-based photopolymerisation. Typical applications: dental crowns, implants, industrial nozzles, filtration media, cutting tools.
CNC machining
This equation is a starting point, not a production-ready solution
CNC pricing depends heavily on your specific situation: your machine inventory, past job data, material contracts, surface finish requirements, and GD&T callouts (tolerances, datums, fits). A part with a tight positional tolerance or a mirror-polished bore costs fundamentally more to machine than the geometry alone suggests. Calibrate the rates in this equation against real jobs before relying on it for live quoting.
Feature recognition
For parts uploaded as an exact CAD model (B-rep), Phasio recognises holes, pockets, and machining setups. Your equation reads them from revision.machining (holeCount, pocketCount, holes[], pockets[], setups, finishing, warnings) and sheet metal bends from revision.bending. Both are null for mesh uploads. revision.machining is also null for a CAD file with no solid body and for a part too complex to analyse. Phasio does not recognise threads, chamfers, or rotational symmetry. The equation in this section uses only the volume fields, so it also works for mesh uploads. See the reference for every field.
Hole counting changed in the 2026-10-30 release: a chamfered through hole is counted once, and a bore interrupted by a cross hole now counts as a hole. If your equation uses holeCount or holes[], a part that is analysed again can be quoted at a different price.
Milling vs. turning
This equation prices milling by default, but turning (lathe) can be switched on programmatically based on geometry. A cylindrical part has two cross-sectional dimensions that are approximately equal - if width ≈ height, the part is likely rotationally symmetric and turning pricing applies.
// Detect likely turned parts: cross-section is roughly circular
const crossSectionRatio = Math.min(width, height) / Math.max(width, height)
const isLikelyCylindrical = crossSectionRatio > 0.85Once a part is flagged as cylindrical, the stock and pricing logic changes:
- Raw stock: a bar rather than a block -
Math.PI * Math.pow(Math.max(width, height) / 2, 2) * length - Machining: dominated by turning speed, number of diameter steps, and facing passes rather than three-phase milling
- Complexity: driven by how many diameter changes, undercuts, and threading operations are visible in the geometry
We've had good results pricing turned parts using this geometry-based switching approach. The key is using the cylindrical detection as a gate: parts that pass it get turning logic, everything else gets the milling model below.
Rotational symmetry is not detected
Phasio does not detect rotational symmetry or threads, so this check still infers a turned part from the bounding box. Hole and pocket data is available in revision.machining for exact CAD models.
Why this process is unique
CNC is subtractive: you start from a block of raw stock and remove everything that isn't the part. Unlike additive processes, cost is not primarily about part volume - it's about how much you remove, and how hard that removal is.
Not all material removal is equal. Roughing through open space is fast. Working close to the finished surface requires smaller tools, slower feeds, and more passes. This suggests splitting the removed volume into three phases based on geometric complexity:
| Phase | Volume removed | Nature of work |
|---|---|---|
| Coarse | Block − convex hull | Bulk removal, large tooling, high MRR |
| Medium | Convex hull − shrink wrap | Intermediate features, recesses, overhangs |
| Fine | Shrink wrap − part volume | Surface finish, detailed features, toleranced geometry |
The convex hull is the coarse outer envelope of the part - all concave features are filled in. The shrink wrap follows the surface more tightly, capturing recesses but not sharp internal corners. Together they give you three geometrically-grounded milling volumes from fields Phasio already computes.
Factors geometry alone cannot capture - these require calibration or manual review:
- GD&T callouts: tight tolerances, datum schemes, press fits, true position
- Surface finish: Ra requirements, polishing, hard anodise, plating
- Multi-axis setups: 5-axis simultaneous, turn-mill, multiple fixturings
- Hard alloys: Inconel, titanium, hardened steel all reduce MRR significantly
Core methodology
Step 1 - Stock selection: filter your available block sizes to those that fit the part in any orientation, then pick the smallest. This determines raw material cost and the coarse milling volume.
Step 2 - Three milling phases: each phase uses a different cost-per-mm³ reflecting its MRR.
Why cost-per-mm³ rather than MRR × hourly rate
The equation uses direct cost-per-mm³ rates rather than MRR × hourly rate. The two are equivalent - e.g. 500 mm³/s at €72/hr = €0.00004/mm³. Volume rates are easier to calibrate from real job data.
Step 3 - Adjustments: precision multiplier (GD&T/tolerance level), quantity curve, minimum price floor.
Review gate: if the part doesn't fit any block, the equation calls done(0). A price of 0 sets reviewRequired automatically, so the customer cannot see the price or check out until you click Approve for Purchase on the quote. The equation also sets the review flag when convexHullVolume or shrinkWrapVolume is null, because the milling phases cannot be split without them.
Numerical example
Part: 70 × 35 × 35mm bracket, volume = 15,000 mm³, convexHullVolume = 25,000 mm³, shrinkWrapVolume = 18,000 mm³
Smallest fitting block: 75 × 75 × 75mm = 421,875 mm³
| Phase | Volume | Rate | Cost |
|---|---|---|---|
| Coarse | 421,875 − 25,000 = 396,875 mm³ | €0.00004/mm³ | €15.88 |
| Medium | 25,000 − 18,000 = 7,000 mm³ | €0.0003/mm³ | €2.10 |
| Fine | 18,000 − 15,000 = 3,000 mm³ | €0.001/mm³ | €3.00 |
| Total | €20.98 |
With a precision multiplier of 1.0 and quantity of 1 (multiplier 3× at single unit): €62.93. This is above the equation's default floor of €50 (Min price per part). Set the floor to match your cost base.
Complete algorithm
const { material, width, height, length, volume, convexHullVolume, shrinkWrapVolume, precision } = specification
const { quantity } = requisition
// Define your available raw stock sizes [x, y, z] in mm
// Add or remove blocks to match what your workshop actually carries
const blockSizes: [number, number, number][] = [
[25, 25, 25],
[50, 50, 50],
[75, 75, 75],
[100, 100, 100],
[150, 125, 125],
[150, 150, 150],
[200, 200, 200],
]
// Check if a part fits a block in any orientation (sorts both ascending)
function canFit(spec: [number, number, number], block: [number, number, number]): boolean {
const s = [...spec].sort((a, b) => a - b)
const b = [...block].sort((a, b) => a - b)
return s.every((d, i) => d <= b[i])
}
function blockVolume(b: [number, number, number]): number {
return b[0] * b[1] * b[2]
}
// Find the smallest block the part fits in
function findBlock(): [number, number, number] | null {
const fits = blockSizes.filter(b => canFit([width, height, length], b))
if (fits.length === 0) return null
return fits.reduce((smallest, b) => blockVolume(b) < blockVolume(smallest) ? b : smallest)
}
const bestBlock = findBlock()
// Cost rates per mm3 for each milling phase
// Calibrate these from your real job data
const coarseRate = variable('Coarse cost per mm3', 0.00004) // bulk removal
const mediumRate = variable('Medium cost per mm3', 0.0003) // intermediate features
const fineRate = variable('Fine cost per mm3', 0.001) // finishing and toleranced surfaces
const minPrice = variable('Min price per part', 50) // floor - adjust to your cost base
// Quantity multiplier: interpolates smoothly between tiers
// At qty=1 price is 3x the base; converges to 1x at qty=1000
function getQuantityMultiplier(qty: number): number {
const tiers: [number, number][] = [
[1, 3.0],
[10, 2.3],
[100, 1.9],
[250, 1.6],
[500, 1.4],
[750, 1.1],
[1000, 1.0],
]
if (qty <= 1) return tiers[0][1]
if (qty >= 1000) return tiers[tiers.length - 1][1]
for (let i = 0; i < tiers.length - 1; i++) {
const [lo, loM] = tiers[i]
const [hi, hiM] = tiers[i + 1]
if (qty >= lo && qty <= hi) {
const t = (qty - lo) / (hi - lo)
return loM + (hiM - loM) * t // linear interpolation
}
}
return tiers[0][1]
}
if (bestBlock) {
const rawBlockVolume = blockVolume(bestBlock)
// convexHullVolume and shrinkWrapVolume can be null. Fall back so the phases
// stay non-negative, and flag the part for review below.
const missingVolumes = convexHullVolume === null || shrinkWrapVolume === null
const wrapVolume = shrinkWrapVolume ?? volume
const hullVolume = convexHullVolume ?? wrapVolume
// Three milling phases
const coarseVolume = rawBlockVolume - hullVolume // bulk removal
const mediumVolume = hullVolume - wrapVolume // intermediate features
const fineVolume = wrapVolume - volume // finishing
const machiningCost = (coarseVolume * coarseRate)
+ (mediumVolume * mediumRate)
+ (fineVolume * fineRate)
// Precision multiplier: configure your precision settings in Phasio to return
// a value >= 1 (e.g. Standard = 1.0, Fine = 1.5, Ultra = 2.0)
const precisionMultiplier = precision?.value ?? 1
const qtyMultiplier = variable('Quantity multiplier', round(getQuantityMultiplier(quantity), 3))
const calculated = round(machiningCost * precisionMultiplier * qtyMultiplier, 2)
const finalPrice = variable('Final price', calculated < minPrice ? minPrice : calculated)
done({ price: finalPrice, reviewRequired: missingVolumes })
} else {
// Part doesn't fit any block - done(0) triggers reviewRequired automatically
done(0)
}Material variables: none required - all rates are exposed via variable() so the operator can override them per part line. Move rates to material.variables if they differ per material.
When to use this
3-axis and 5-axis CNC milling. Adjust the three cost rates to reflect your machine's actual MRR and hourly rate for each phase. Harder materials (Inconel, titanium) need lower MRRs - increase mediumRate and fineRate accordingly. Softer materials (aluminium, plastics) can use higher MRRs and lower rates.
Vacuum casting
Why this process is unique
Vacuum casting produces polyurethane parts from a silicone mould. The mould is made from a master pattern (typically SLA-printed). Cost has two distinct components that behave very differently with quantity:
- Mould cost: a one-time charge (or amortised over the mould's lifespan). Each silicone mould typically lasts 15-25 shots before degrading.
- Casting cost per part: polyurethane material + operator time + mixing, curing, and demoulding.
At low quantities (1-5), mould amortisation dominates. At high quantities (20+), you need a second mould and the per-part cost levels out.
Typical applications: functional prototypes, enclosures, medical devices, over-moulded parts.
Core methodology
Mould cost per part: mouldCost / min(quantity, mouldLifespan)
If quantity > mouldLifespan: additional moulds are needed. Each mouldLifespan parts uses one mould.
Casting cost: material volume × PU cost/litre + fixed operator time per cast
Numerical example
Part: 100 × 60 × 30mm housing, volume = 50,000 mm³
| Parameter | Value |
|---|---|
mouldCost | €600 |
mouldLifespan | 20 shots |
castingCostPerPart | €18 (PU material + labour) |
| Quantity | 5 |
Mould per part: 600 / 5 = €120
Casting cost: €18
Unit price: €138
At qty 20: mould = 600/20 = €30. Unit price = €48.
At qty 40: two moulds needed. Mould = 2 × 600 / 40 = €30. Same unit price. (Correctly handled by the formula below.)
Complete algorithm
const { material, volume, length, width, height } = specification
const { quantity } = requisition
const mouldCost = material.variables['mouldCost']
const mouldLifespan = material.variables['mouldLifespan'] // shots per mould
const castingCostPerPart = material.variables['castingCostPerPart']
// How many moulds are needed?
const numberOfMoulds = Math.ceil(quantity / mouldLifespan)
const totalMouldCost = numberOfMoulds * mouldCost
const mouldPerPart = round(totalMouldCost / quantity, 2)
const baseCost = mouldPerPart + castingCostPerPart
const unitPrice = variable('unitPrice', round(baseCost, 2))
// Flag parts that need master pattern creation (charged separately as setup)
const largePartFlag = Math.max(length, width, height) > 400
done({ price: unitPrice, reviewRequired: largePartFlag })Note: If you charge separately for the master pattern (SLA print), add that as a Level 3 line item or a separate process quote.
Material variables: mouldCost, mouldLifespan, castingCostPerPart
When to use this
Any silicone-moulded polyurethane casting process. Works for single-component and two-component PU. For injection moulding (steel tooling), the same structure applies but mouldCost is €5,000-200,000 and mouldLifespan is 10,000-100,000+.
Last updated on
Review-required gate
Flag a quote line from your pricing equation so the customer can't see its price or check out until you approve the quote.
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.