A WooCommerce order with variable products, rebuilt line by line as a Xero quote
When a quote request arrives from a WooCommerce store, a Make scenario fetches the order, finds the customer in Xero or creates them, and rebuilds every order line, with the variation and options the customer chose, into the line format of one Xero quote. It is about 22 modules and is currently switched off.
Where this applies
Any business that sells configurable or made-to-order products through WooCommerce and quotes or bills them in Xero: furniture, joinery, signage and other goods with options.
- nested iterators: lines, variations, options
- 3
- modules in the scenario
- ~22
- routes: existing and new contact
- 2
The problem
A made-to-order product is not one SKU. The customer picks a size, a material and options on the website, and WooCommerce stores those choices as a variation and as metadata on each order line. A quote that shows only the product name leaves the team to look the choices up in the store before anyone can price or build it.
Xero's quote wants a flat list of lines, each with its own description, quantity and price. The work is turning WooCommerce's nested order (lines, each with a variation, each with its own metadata) into that list, for one quote per order, without losing an option along the way.
What we built
An instant trigger, then the whole order
A WooCommerce event starts the scenario the moment a quote request is placed, and the next module fetches the full order, so every later step works from the complete record rather than from the event's summary.
Find the contact, or create it
The scenario searches Xero's contacts for the customer. A router then takes one of two routes: an existing contact goes straight on to the lines, and a new customer is created in Xero first, with an error handler on that step that skips the bundle rather than stopping the scenario.
Three iterators, nested
One iterator walks the order's line items, a second walks each line's variation, and a third walks its metadata, which is where the customer's chosen options live. A text aggregator joins what the inner iterators find, so each quote line can carry the options that were chosen.
Lines built in Xero's shape
JSON modules create and parse each line in the structure Xero's quote expects, and an array aggregator collects the lines into one array, so the Create Quote module runs once per order with every line on it, not once per line. Both routes, new and existing contact, end in the same line-building chain and the same Create Quote step.
The wider order flow
Beyond this audited scenario, the order flow we built for this business also carries Stripe payments, the customer's region, tax per line and line descriptions into Xero. That wider scope is our own account of the build; the audit covers only the quote scenario described above, so it is not set out module by module here.
The outcome
Created on 8 July 2025 and last edited on 8 October 2025, as one scenario of about 22 modules.
It is currently switched off and has no runs in the audit's history window, so this page describes a design rather than a volume.
Where it stops
It is switched off and has no run history in the window the audit read, so nothing about its volume is claimed. The line-building chain is repeated on both contact routes, so a change to how a line is built has to be made twice. A new contact whose creation fails is skipped, and the scenario has no alert of its own, so that quote request would need to be spotted in Make's history. A second scenario in the account, an HTTP stub, is not described.
Built with
- Make.com
- WooCommerce
- Xero
Patterns used
- Nested iterators
- Find or create contact
- Lines built as JSON
- Array aggregator into one quote
Page copy drafted with AI assistance. Skofi is accountable for it. Editorial policy
Have something shaped like this?
If any part of the above resembles a problem you are living with, a short call is the fastest way to find out whether it is the same problem underneath.
What happens on the call
- 15 minutes, no deck
- We map the process on the call
- A written scope, or an honest no