The quote-to-production handoff is where a good sale quietly turns into a hard job.
Sales closes the order and moves on. The quote carried assumptions: a substitute material because the specified grade had a twelve-week lead time, a ship date that only works if the steel lands Tuesday, a tolerance someone eyeballed off a customer sketch, a finish the customer mentioned once on a call. A few of those assumptions made it onto the order. The rest live in an email thread, a marked-up drawing, or the estimator's head. Then the job hits the floor, and the people who have to build it start discovering what nobody checked.
If you run production or planning at a make-to-order shop, you know the tell. A job stops on its first day because the bill of materials calls for a part that was never ordered, or a drawing note fights the price the customer was quoted. Nobody was careless. The promise and the build just never sat in one place at the same time, with one person looking at both.
This guide is for the operations and engineering leads who own that moment, the handoff from a won quote to a released job. It is written to be useful even if you never call us, because the fix is mostly about how the work moves, not about a tool you have to buy.
What a clean handoff has to settle before anyone cuts metal
Strip the handoff down and it has one job: turn the promise your team sold into something the floor can actually build, and do it while the gaps are still questions instead of rework. A good handoff answers a few things before material moves:
- What did we actually promise this customer, on the order and on the call?
- Which of the quote's assumptions change what the job costs, when it ships, or how it gets built?
- Is the bill of materials, the routing, the material, and the capacity real yet, or still assumed?
The point is not to slow sales down or bolt on a sign-off nobody reads. It is to catch the vague assumption while it is still a question, before it becomes a stoppage on the floor and a margin surprise in the month-end review. On a make-to-order job, the assumptions are the product. Every quote is a small bet about material, method, and time, and the handoff is where you find out whether the bet was any good.
A quick test
Pick one job that stalled after release last month. Can you see, in one place, what was promised, which assumption broke it, who owned that assumption, and what the floor was told? If reconstructing that takes three phone calls and a scroll through someone's inbox, the handoff is happening in people's heads, and it will keep costing you the same way next month.
Walk the handoff the way it moves today
On most make-to-order floors, the handoff is not one moment. It is a dozen small ones, spread across people who rarely sit in the same room:
- Sales wins the order and marks it closed in the CRM or quoting tool. The commercial promise, the price, the date, and any verbal commitments live there, some written down and some not.
- The order drops to engineering or estimating to turn into a build. Someone opens the drawing pack and the quote notes and tries to reconstruct what was intended.
- Engineering releases or edits the bill of materials and the routing, sometimes reusing an old one that is close but not identical to this job.
- Purchasing reads the BOM and starts buying, discovering along the way which materials that were quoted as in stock are not, and which have moved out on lead time.
- Planning drops the job into the schedule against a capacity picture that quietly assumes approvals and materials nobody has confirmed.
- Quality inherits tolerances and finishes it never saw at quote time, and finds out at first-article inspection whether the price covered them.
- The floor starts the job, and whatever nobody checked turns into a stoppage, an expedite, or a number that does not match the quote.
The shape is reasonable. The problem is the seams. Each person picks up a piece, does their bit competently, and hands the next person a set of assumptions they cannot see. Nobody owns the single moment where the promise and the build have to agree, so the disagreements surface one at a time, on the floor, when they are most expensive to fix.
Where the handoff quietly loses time
The breakdowns are predictable. They look a little different on every job, but the underlying causes repeat.
The promise is scattered before the job starts
The commercial promise sits in the CRM or the quoting sheet. The technical detail sits in the drawings and the CAD files. The parts sit in the ERP, or they do not exist yet. Supplier lead times sit in someone's inbox. Each piece has a home, but no one place holds the whole job, so the first real act of the handoff is a scavenger hunt.
Assumptions never get written down as assumptions
An estimator quotes a substitute grade, a nominal tolerance, a standard finish, because that is how the job usually runs. Those are reasonable calls. The trouble is they get recorded, if at all, as facts rather than as bets that still need confirming. By the time the job is released, no one can tell which numbers were verified and which were an experienced guess that happened to look the same on paper.
Checking happens late and in parallel
Because nobody owns the moment of agreement, the checking scatters. Purchasing expedites a material that was quoted as on hand. Planning holds a slot that depends on an approval nobody has chased. Quality catches a tolerance the price never accounted for. Each is small on its own. Together they are why customer dates slip and why the job lands over cost.
The BOM and routing are assumed, not confirmed
Reusing a near-identical BOM from a similar job is fast, and most of the time it is fine. The risk is the delta nobody checked: the one changed dimension, the extra operation, the different fastener that the copied routing does not include. A BOM that is 95 percent right still stops the job at the 5 percent, usually at the worst moment.
No one owns the release itself
Ask who is accountable for a job being genuinely ready to run, and the honest answer at many shops is that responsibility is shared, which means it belongs to no one. Sales assumes engineering caught it. Engineering assumes purchasing flagged it. Planning assumes the order would not have been released if something were wrong. The release becomes a status the job drifts into rather than a decision someone makes.
What "the floor can build this" actually looks like
You do not need a new system for this. The first useful build is a single job-release check that sits between the won quote and the released job and makes the gaps visible while someone can still act on them. A workable first version does three things:
- Pulls the commercial promise, the technical assumptions, and the customer's stated requirements into one view of the job.
- Marks each thing the floor depends on, the BOM, the routing, the material, the capacity, the quality requirements, and the approvals, as confirmed, missing, or still assumed.
- Sends every open item to the person who can close it, with the job it belongs to attached.
That is the difference between a checklist and a real handoff. A checklist says what should be true. This shows what is actually confirmed, what is still a guess, and who is holding the answer. It does not have to be elaborate. On day one it can be a shared sheet with a status column, as long as one person is responsible for it turning green before the job is released.
Map what was promised before you touch a single system
If you fix one thing first, fix the map. Before any automation, write down what the floor needs to know for a job, where that knowledge lives today, who is responsible for confirming it, and what "confirmed" actually means for that line. A spreadsheet is enough to start.
| What the floor needs to know | Where it lives today | Who confirms it | What "confirmed" means here |
|---|---|---|---|
| The commercial promise | CRM, quoting tool, the salesperson's notes, the customer call | Sales | Price, ship date, and any verbal commitment are written on the order, not remembered |
| Customer requirements | Drawings, specs, purchase order terms, emailed clarifications | Engineering | Every dimension, tolerance, finish, and standard is pulled out of the documents and reconciled with the quote |
| Material and BOM | ERP, the quoted BOM, supplier quotes | Engineering and purchasing | Every line exists in the ERP, is quoted or on hand, and matches the material the price assumed |
| Routing and capacity | ERP or MES routing, the capacity plan | Production planning | The routing matches this job's operations and a real slot exists, with any condition named |
| Tolerances and quality | Drawings, the quality system, prior first-article records | Quality | The inspection plan matches what was drawn and what was priced |
| Approvals and changes | Engineering-change records, customer sign-offs | Engineering | Any open change or customer approval the build depends on is closed or flagged as a hold |
The map is not the deliverable. It is what makes the deliverable trustworthy. Once every line has a known home, an owner, and a clear meaning of "confirmed," you have something stable to build the check on, and later to attach automation to.
The one artifact worth building first: a job-release check
With the map in hand, the check itself is small. For each job, it takes the things the floor depends on and marks each one honestly, then names what was found and who has to clear it. The value is in the honesty of the status column, not the length of the list.
| What the floor depends on | Status | What we found | Who clears it |
|---|---|---|---|
| BOM and routing | Blocked | Quote assumes a substitute material that is not set up in the ERP | Engineering |
| Customer requirement | Needs a decision | Drawing note conflicts with the quoted tolerance | Sales and quality |
| Material | At risk | Bar stock quoted as on hand is committed to another job | Purchasing |
| Capacity | Ready, with one condition | Planner holds the slot if the material lands by Friday | Production planning |
Read down that column and the job tells you the truth about itself. Two items are genuinely open, one is a live risk, and one is fine as long as a date holds. That is a job you can decide about. A green tick on a checklist would have hidden all four.
Keep the promise and the verified fact in separate fields
If there is one thing to design in from the start, it is the line between what was promised and what has been verified. Keep them as separate fields, never the same one. The whole failure you are fixing comes from treating an assumption as a fact, so the data itself should refuse to let the two blur together.
In practice this means the quoted material and the confirmed material are different entries, and the check compares them. The quoted lead time and the supplier's committed lead time sit side by side. The tolerance the customer drew and the tolerance the price assumed are both visible. When they match, the line goes green on its own. When they do not, you have found a gap while it is still cheap to close. A system that only stores one number for each of these can never show you the disagreement, which is the exact thing you need to see.
Send each open item to the person who can close it
A gap only helps you if it reaches the one person who can close it. When the handoff is informal, that person usually finds out last, once the job is already on the floor and the customer date is fixed.
So tie each open item to an owner and a plain status, and hold the release while anything the floor depends on is still a guess. Engineering clears the substitute material. Sales and quality reconcile the tolerance against the price the customer accepted. Purchasing confirms the bar stock or finds more. Planning locks the slot once the steel is booked. None of this is exotic. It just has to happen before release instead of during the build, and one person has to be able to say the job is ready and mean it.
A worked example: 50 jobs a month at a custom fabricator
Say a custom metal fabricator quoting around 50 jobs a month keeps losing the first day of a job to problems that were baked in at quote time. The example below is invented to show the shape of the fix, not a benchmark to plan against, but the failures are the ordinary ones most make-to-order shops will recognize.
One order comes in: a batch of welded frames, quoted at a good margin, promised in four weeks. On the old handoff, engineering copies the BOM from a similar frame, purchasing starts buying, and planning books week three. On day one of the build, three things surface at once. The quoted plate grade was substituted at estimate time and never set up in the ERP, so purchasing has been buying the wrong material. The customer's drawing calls for a flatness tolerance tighter than the standard the price assumed, which means an extra machining step. And the powder-coat color the customer confirmed by email never made it onto the order. The job stops, the frames wait, and the four-week promise is already gone.
Now run the same order through a job-release check before it is released. The same three gaps appear, but they appear as open items with owners, days before anyone cuts plate.
| Assumption in the quote | What the check surfaced | What it would have cost on the floor |
|---|---|---|
| Standard plate grade, in stock | Estimator substituted a grade never set up in the ERP; purchasing is buying the wrong item | Rework or a full material re-buy, plus a week of lead time |
| Standard flatness tolerance | Drawing calls for a tighter tolerance than the price assumed | An unplanned machining step, margin gone, and a possible reject at inspection |
| Finish to be confirmed | Customer confirmed the color by email, but it is not on the order | Frames sit finished-but-wrong, or wait uncoated for a color nobody logged |
None of these are dramatic on their own. The point is that all three were knowable before the job ran, and the difference between a good month and a bad one is whether they surface at release or at the saw. The check does not make the decisions. It just puts the three questions in front of the people who can answer them while there is still time.
Where AI helps, and where it has to stop
Once the check exists and the fields are clear, AI can take the manual assembly off your team. It reads well in a few specific places:
- Turning the quote notes and call history into a plain statement of what was promised, so the promise is legible instead of buried.
- Pulling requirements, dimensions, tolerances, finishes, and standards out of customer drawings and purchase orders so nothing hides in an attachment.
- Comparing what the quote assumed against what the job-release fields say, and flagging the mismatches for a person to judge.
Where it has to stop is judgment. AI drafts the job packet, extracts the specs, and checks one document against another. It does not decide that a job is manufacturable, sign off a tolerance, change what the customer was promised, or commit a date. Those stay with your team. If a model ever smooths over its own uncertainty to make the check look tidy, it is doing harm, not work. The useful version surfaces the gap and shows its source; a named person still approves the build.
Where an engineer's judgment stays
The reason to keep AI on the extract-and-check side of the line is that the decisions on the other side are exactly the ones that make you a manufacturer rather than a document processor. Human judgment still owns:
- Whether the job can actually be built as drawn, on your equipment, to that tolerance, in that time.
- Whether a substitution or a method change is acceptable, and whether the customer needs to be told.
- What the customer was really promised when the drawing, the order, and the call disagree.
- Whether a flagged gap is a genuine blocker or a non-issue this particular job can absorb.
A good check protects that judgment instead of replacing it. It clears away the copying, the searching, and the version-chasing so the engineer's attention lands on the calls that actually need an engineer.
The data and systems this reaches into
The handoff usually touches more systems than people expect: the CRM or quoting tool, the ERP, the BOM and routing data, the drawings and CAD or document library, supplier quotes, the capacity plan, the quality and inspection records, and engineering-change history. You do not connect all of it at once, and you should not try.
Most shops already run some mix of a quoting tool, an ERP such as Epicor, NetSuite, Global Shop, Fishbowl, or SAP, a CAD and drawing library such as SolidWorks, and a quality system, with a scheduling or MES layer on top. The workflow does not need a new platform to sit above all of that. It needs the few connections that make the check trustworthy for the jobs that keep stopping, and a clear handoff between systems so the trail from quoted number to released job is traceable. Start with the sources behind your most common stoppage, prove the check on those, and widen only when it is paying back.
Set a sequence that catches gaps before release
The check works best as a short, ordered sequence between the won order and the released job, with an owner at each stage and a clear condition for moving on. It does not add meetings. It just moves the discovery of gaps from the floor back to the desk.
| Stage | What happens | Who owns it | What must be true to move on |
|---|---|---|---|
| Order won | The commercial promise, price, date, and any verbal commitments are captured on the order | Sales | Nothing about the promise lives only in someone's memory or inbox |
| Requirements pulled | Specs, tolerances, finishes, and standards are extracted from the drawings and reconciled with the quote | Engineering | Every requirement is written down and any conflict with the quote is flagged |
| Build confirmed | BOM and routing are checked line by line, not copied blind; substitutions are made explicit | Engineering and purchasing | Every part exists, is quoted or on hand, and matches the priced material |
| Slot and quality set | Capacity is booked against real material dates and the inspection plan matches the drawing | Planning and quality | Any condition on the slot is named and owned |
| Released | One person confirms the job is ready and clears it to the floor | Whoever owns release | Nothing the floor depends on is still marked assumed |
The sequence is deliberately short. The goal is not more process. It is to stop discovering material problems, spec conflicts, and missing approvals after the schedule is already committed and the customer date is already promised.
What tells you it is working
Take one kind of work first. Pick the product family or the customer where the floor keeps finding problems after the sale, follow those recent jobs through the check, and get them clean before you widen it. Trying to cover every job on day one is how these efforts stall.
You will know it is paying back in numbers you already track. Fewer jobs stop on their first day for a missing assumption. Purchasing expedites less because materials are confirmed before release, not during the build. The gap between the quoted cost and the actual cost gets smaller, and the month-end margin surprises get less frequent. Those are the signs to watch, not how many boxes the check has or how full it looks.
Common traps
A few things reliably turn this from a fix into more overhead.
Making it a form nobody reads
If the check is longer than the job needs, people work around it and it becomes theater. Keep it to the handful of things that actually stop jobs on your floor, and cut any line that has never once caught a problem.
Letting the promise stay in free text
If the commercial promise lives in loose notes while the verified data lives in fields, no one can compare them, and comparison is the entire point. The promise has to be captured in a form the check can read against the build.
Buying more planning software first
If your team is already finding gaps after release, the missing piece is the handoff, not another scheduling module. New software on top of a broken handoff just gives the same assumptions a nicer interface.
Trusting a copied BOM
Reusing a near-identical BOM is fine as long as someone confirms the delta for this job. The moment "close enough" becomes the default, the check is only as good as the last job it was copied from.
How Ubisar would implement this workflow
In week one, we pick one quote-to-release flow with you and follow the recent jobs where production found a missing assumption after the sale. The first thing we build is the job-release check itself: the promise, the technical assumptions, the customer requirements, and a confirmed-or-missing status for the BOM, the routing, the material, the capacity, the quality plan, and the approvals, each with an owner.
In weeks two and three, we connect only the CRM or quote sheet, the ERP, the BOM, the routing, the drawings, the supplier quotes, the capacity plan, and the quality data needed to make that check trustworthy, and we add AI where it saves manual work: summarizing quote notes, pulling requirements from customer documents, and flagging where assumptions and job fields disagree. Manufacturability and commercial commitments still need a person's approval. By week four, sales, engineering, production, purchasing, and quality can run real jobs through the check before release, and you decide from what you see whether to keep going or narrow it.
If jobs are reaching your floor with assumptions nobody checked, this is the workflow to start with. It sits inside our monthly implementation service, and it connects naturally to the rest of the manufacturing and industrial work: the production schedule variance workflow, shop-floor data capture, and inventory and batch visibility. Tell us the one handoff that keeps surprising you, and we will walk you through what month one would look like on it.