Subassembly Build Planner: Explode Your BOM Into the Right Build Order
Turn a multi-level bill of materials and your on-hand stock into a sequenced build-and-buy plan that hits a finished-goods target — with a planner approving the sequence before any work orders or POs go out.
A web tool where you import a multi-level BOM and on-hand counts, set a finished-goods target, and the tool explodes demand level by level, computes what to build versus buy, flags shortages and broken BOMs, a planner reviews and approves the sequence, and it exports a clean build-order CSV plus a shortage/buy list.
Before you start
- A Supabase account (free)
- A Vercel account (free)
- A Resend account (free)
- A multi-level BOM export (CSV/sheet)
- Component and subassembly on-hand quantities
- Your finished-goods demand (what to build, how many)
- Claude Code or any AI coding agent
The problem this kills
You have a finished-goods target — build 250 of the cabinet, ship 80 of the pump assembly — and a bill of materials that goes three or four levels deep. Each finished good is made of subassemblies, which are made of smaller subassemblies, which are made of components. Some of those subassemblies are already sitting on a shelf. Some components are short. And the only way to know what to build first, what to build next, and what to put on a purchase request is to sit down with a spreadsheet and do the explosion by hand.
It is slow, it is error-prone, and it is fragile. Miss that you already have 40 of a subassembly in stock and you build 40 you didn't need. Miss a shortage two levels down and the line stops halfway through the day. Get the build order wrong and people are assembling a top-level unit before its subassembly even exists. And the spreadsheet that holds it all together breaks the moment someone reorders a column. You do not need to be a developer to fix this.
What you'll build
A simple internal web tool. You import three things: your multi-level BOM (parent, child, quantity-per), your on-hand quantities for components and subassemblies, and your finished-goods demand (which top-level items, how many). The tool walks the BOM from the top down, multiplying out the quantity needed at every level, then nets against what you already have on hand — respecting existing subassembly stock so you never build what's already sitting there. It works out, level by level, what you need to build (you have the components) versus what you need to buy (you're short), and it puts everything in the correct build sequence so lower-level subassemblies come before the parents that consume them. It catches the things that wreck a manual explosion: circular BOMs (A needs B needs A), missing child parts, and negative or impossible quantities. Your planner opens the proposed build sequence and buy list, reviews it, fixes anything, and clicks Approve. Only then does the tool generate the final build-order CSV and shortage/buy list — ready to drop into work orders or purchase requests.
What's inside the Implementation Plan
The downloadable plan is a step-by-step file you paste into an AI coding agent. It opens by interviewing you about your business — how your BOMs are structured and named, what your part/SKU conventions look like, where on-hand lives, how deep your assemblies go, your typical and peak run sizes, your build-vs-buy and lead-time rules, and the messy exceptions like phantom assemblies and substitute parts — and then it tailors the data model, the explosion logic, and every later step to your answers. This is not a generic template; the agent reflects a short spec back to you and waits for your thumbs-up before it builds anything. From there it walks the agent through importing the BOM and on-hand, the multi-level explosion, the net-and-classify (build vs buy) by level, the cycle/validity checks, the planner review-and-approve screen, and the CSV exports — each step with a ready-to-copy prompt. There's also a fallback so you can build the whole thing today even with no API to your ERP.
The governance it includes (this is the point)
This drives real production decisions, so it ships with the controls an operations team needs: login so only your team can use it, row-level security so you only ever see your own organization's BOMs and stock, a complete audit trail of who ran which plan and who reviewed and approved it and when, a hard human-approval gate so no build order or buy list leaves the tool until a planner signs off, and duplicate guards keyed on the BOM node plus the plan run so the same node can't be planned twice and the same plan can't be committed twice. Invalid and circular BOMs are flagged and block approval instead of silently producing a nonsense plan.
Who it's for
Production planners, kitting and assembly supervisors, and purchasing leads who own the "what do we build first, and what are we short" question and are tired of rebuilding the same multi-level explosion in a spreadsheet for every run. If you can describe how your BOMs nest and how you decide build versus buy, you can build this.
You've got this — start with the plan, paste the first prompt, answer the interview, and you'll see your first sequenced build plan take shape the same afternoon.