Set up a multi-stage co-manufacturing chain

Plenty of products aren't made in one place. A hot-sauce brand might send jalapeños, vinegar and garlic to a co-packer who cooks and blends them, truck the bulk sauce to a bottling partner for filling and pasteurizing, and land the finished cases at a 3PL. Three vendors, two hand-offs, one product — and you own the goods the entire way.

Chains like that rarely start life as chains. They start as a recipe you already have, made in one step, that outgrew a single facility. So that's where this guide starts too: with an ordinary recipe, and the decision to split it.

One vendor, not a chain?

If a single contract manufacturer does your whole build, you don't need a chain — see Manufacture with a contract manufacturer, which covers activating a contractor, getting components to their site, and receiving outsourced runs. This guide builds on those ideas.

Before you begin

• You need manufacturing and purchasing read-write access.
• The finished good should already exist as a product, with a live recipe. Chains reference products you already sell.
• Each outside vendor must exist as a supplier. You can flag one as a contractor inside the builder, or ahead of time on Manufacturing → Contractors — where you can also save their default tolling rate so it fills in wherever that contractor appears.
• The ingredients your first stage consumes should already be at the first stage's site, with batch numbers. The cleanest way is a purchase order shipped straight to the contractor's site warehouse and received with lot numbers.

The idea: a stage is a product

There is no "chain" record in SKU.io. A stage is simply a product with its own recipe, and the chain is worked out by following those recipes: start at the finished good, and any component that is itself made is the stage before it.

That sounds like a technicality, and it has three consequences you'll feel:

• The chain can never disagree with the recipes, because it's derived from them rather than stored alongside them.
• Each stage is a real product you can open, price, count and order — not a row inside something bigger.
• Every stage carries its own vendor terms, so an order raised months later already knows who makes it and what they charge.

Split an existing recipe

Open the product and look at the line under its stock figures — it states how the product is made. When it's made in one step, the offer to split it across vendors sits right there.

Before splitting, it's worth looking at the recipe you're about to divide.

Ingredients are rarely bought in the unit you cook with. Peppers arrive by the case and go in by the ounce; vinegar is bought by the gallon and measured by the litre. Each line states the quantity in its working unit and the conversion back to what you purchase, so the recipe reads the way the kitchen works while costing stays anchored to what you actually paid.

1. On the product, click Split across vendors.

   The builder opens with the recipe already loaded — the finished good, the unit it's measured in, and every ingredient with its cost. Nothing is retyped, and the cost estimate is already priced so you can compare the split against what you have today.

   

2. Set up stage 1 — the vendor who works on the raw ingredients.

   • Contractor — pick the co-packer. If they aren't a contractor yet, activate them without leaving the page.
   • Service fee — per-unit or flat, with the small toggle. Per-unit is the usual tolling arrangement, and a contractor's saved default rate fills in automatically.
   • Cost basis — leave Toll when the vendor only processes goods you own. Choose Supplier price + components when they add materials of their own. Both carry a short explanation you can hover.
   • Work-in-progress SKU — the storable intermediate this stage produces, named for you from the finished good. Its lots are what tie stage 1's ingredients to stage 2's output.
   • Expected yield % — what survives the stage. Cooking loses water, so enter what's left.

   Watch the materials figure when you enter a yield: it goes up. To finish with a pound you have to start with more than a pound, and that arithmetic follows the chain from here on.

   

3. Set up stage 2 the same way. Stages after the first also get an Input / output unit for hand-offs that aren't one-to-one, and an Inbound freight flag when a freight vendor bills you for the middle-mile leg.

4. Add anything you supply to a later stage.

   A later stage works on what the stage before it made — that input is added for you and shown as a fixed line. But it can also consume goods you supply straight to that vendor. Packaging is the everyday case: you buy bottles from your own supplier, ship them to the bottler, and the bottler never owns them.

   

   Only list what you own

   Materials the vendor supplies themselves — their labels, cartons and cases — are covered by what they charge you, either inside the tolling fee or through the Supplier price + components basis. Listing them here would put stock on your books that you can never count or reconcile.

5. Check the cost basis on each stage. Toll is the industry word for the arrangement where you own the materials the whole way and the vendor invoices only for the work — wherever it appears, there's an explanation next to it.

   

6. Decide what happens to the recipe you started from. It is superseded by default — archived, with its draft orders moved onto the chain. You can instead keep both, leaving the original live for runs you still do in one step.

7. Click Create chain, and read the summary before confirming.

   

   It separates two very different things:

   	What it means
   Permanently	The stage recipes and the intermediate product. This is the part that changes how the product is made, from now on.
   This run only	Draft production orders, if you asked for them. Optional, and off unless you tick Start production now.

   You only split once. From then on, running it again just means ordering the finished good.

What you end up with

Piece	What it is
A work-in-progress product per hand-off	The intermediate in transit between vendors. Named from the finished good, lot-tracked, never sellable, stocked in the chain's unit.
A recipe per stage	Stage 1 turns ingredients into the intermediate. Stage 2 turns the intermediate — plus anything you supply — into the finished good.
Vendor terms on each stage's product	Who makes it, on what basis, at what rate. This is what later orders read.
The original recipe, archived	Kept, not deleted, so history still resolves.

Read the chain back

On the finished good, How this is made states the whole chain: every stage, its vendor, their rate, and the yield. It isn't stored anywhere — it's derived from the recipes each time you look.

Open any stage and you land on an ordinary product page, which names its own maker and terms. That's the model working as intended: there's no chain object to maintain, only products that reference each other.

Order the chain

To produce it, order the finished good — nothing else.

1. Go to Manufacturing → Manufacturing Orders and click New Manufacturing Order.

2. Pick the finished good. The form fills in who makes it and on what basis, because the product carries those terms — you don't restate the arrangement every time you want a batch. The rate itself is applied when you receive, from the same terms.

   

3. Enter the quantity and create the draft.

The stage that supplies it is raised at the same time, for more than you asked for — divided by that stage's expected yield, so it starts enough to finish what you need. Everything raised is a draft, so nothing reaches a vendor until you confirm it.

Ordinary recipes are unaffected

This only happens for products made by a contractor. A normal multi-level recipe — a sub-assembly you've always made in-house — creates exactly one order, as it always has.

Each outsourced stage raises its own purchase order to that vendor, carrying your goods (costed when you receive them) and a manufacturing service fee. That's the shape of a toll arrangement: the vendor is paid to process, not to sell you a product.

When the vendor ships

Each outsourced stage works exactly like a single outsourced order: receiving the contractor's shipment is recording production. The receipt books that stage's output, consumes what the contractor used from your stock at their site, and prices the batch. The mechanics — partial receipts, consumption overrides, reversals — are the same as the single-vendor flow, and are covered in Manufacture with a contract manufacturer.

Three things are specific to a chain:

• The service fee computes itself from the rate the order resolved. Leave Service fee for this receipt empty and the caption does the invoice math against the quantity you're receiving. The rate it uses is the most specific one available: a rate typed on the order wins, then the rate saved on the stage's own product, and only then the contractor's blanket default. That order matters because a co-packer quotes per item — one rate for your hot sauce, a different one for the salsa they also make for you. Type an amount only to override it, when the vendor's invoice disagrees and you're taking their number.
• The middle-mile freight belongs to the receipt. When a freight vendor bills you for moving goods between two stages, add it with Add inbound freight for this stage at the receiving stage. It becomes a cost line on that stage's purchase order and flows into the received goods' landed cost — part of what the inventory is worth, not an expense of the period.
• Each hand-off is a lot. The batch you enter when receiving a stage is what ties that stage's inputs to the next stage's output, which is what makes a trace resolve across the whole chain rather than stopping at the vendor boundary.

Keep traceability intact

Every hand-off is a lot, which is the reason to model production this way at all. A finished batch traces back through the intermediate's batch to the ingredient lots that went into it — across both vendors — and forward from a recalled ingredient lot to the customers who received it. That trace is only possible because each stage records its own batch.

If a stage is lot-tracked but something it consumes isn't, the recipe says so on the page itself — naming the component and offering to turn tracking on for it. That gap is where a trace would stop dead. In this example every component is already tracked, so no warning appears.

A gap you can see is worth more than a total that looks complete, so fix these before you run the chain in anger rather than after a recall question arrives. Tracing itself is done from Manufacturing → Lots → Genealogy, in either direction.

What a finished unit costs

Open the finished good's manufacturing order. Its cost breakdown adds up everything the chain actually did:

Piece	Where it came from
Materials	The intermediate consumed — which itself carries the earlier stage's ingredients and fee
Service fee	Each stage's tolling rate × the quantity received from that vendor
Landed cost	The receipt's share of any inter-stage freight

Divide by the quantity received and that's your true unit cost, with every input traceable to a vendor, a lot, and a receipt. Because the materials figure rolls up from the stage before it, the finished number already contains every fee paid along the chain — you never add them up yourself.

Next steps

• Manufacture with a contract manufacturer — the single-vendor flow in depth: activating contractors, buying components to their site, partial receipts, consumption overrides, reversals.
• Create a recipe (BOM) — everything about recipes outside the chain builder, including per-line scrap, optional components, and operations.
• Build with a manufacturing order — confirming, issuing, recording production and closing.
• Set contractors' default tolling rates on Manufacturing → Contractors so every future chain and order prices itself.