PricingBlogLog in
roboticsBOM managementmulti-level BOMPLMhardware startupactuatorsfirmware

Robotics BOM Management: One Structure, Five Levels Deep

By · · 7 min read

Robotics BOM Management: One Structure, Five Levels Deep

TL;DR

A robot's BOM is deeper than almost any other hardware product's: robot, arm, actuator module, joint driver board, firmware. The actuator module is the real unit of reuse, appearing several times in one arm and again in the next product, so it should exist once as its own subassembly with its own part number and be referenced by quantity, never copied row by row. Built actuators are subassemblies with their own long-lead parts, usually the gearbox. Every joint driver board carries its own firmware, so firmware belongs under each actuator, not once at the top. Keep one multi-level structure and a change to a shared module shows you every robot it touches; keep flat lists and you find out on the line.

A robot isn't one product with a BOM. It's a dozen small products bolted together, and your spreadsheet only knows about one of them.

There's a lot of money betting that you'll figure that out. This year London's Humanoid raised a $152M Series A with Bosch lined up to manufacture its wheeled robots. In October, Foundry Robotics raised $100M to build an autonomous assembly factory. On November 12, SoftBank led a $500M round in Agile Robots. Every one of those robots reaches a factory floor as a bill of materials, and a robot's is one of the deepest in hardware.

The rest of this post uses one example. It's a composite, not any one company's robot: a mobile manipulator, a six-axis arm on a wheeled base, built by a startup of about fifteen people.

A Robot BOM Is Five Levels Deep Before You Count Screws

Here's the top of that robot's structure:

RBT-100  Mobile manipulator                    rev B
├── BASE-100  Mobile base                       rev A
│   ├── DRV-01  Wheel drive module              qty 2
│   ├── BAT-01  Battery pack                    qty 1
│   └── PCBA-MAIN  Main controller board        rev D
│       └── FW-MAIN  Main controller firmware   2.3.0
└── ARM-6  Six-axis arm                         rev B
    ├── ACT-L  Large actuator module  rev C     qty 3
    ├── ACT-S  Small actuator module  rev B     qty 3
    ├── LNK-1..4  Machined links                qty 1 each
    └── GRP-01  Gripper                         rev A

ACT-L  Large actuator module                    rev C
├── MTR-L  Frameless BLDC motor                 qty 1
├── GBX-L  Strain wave gearbox, 100:1           qty 1
├── ENC-A  Absolute encoder                     qty 1
├── BRG-L  Crossed roller bearing               qty 1
├── HSG-L  Machined housing                     rev C
└── PCBA-JD  Joint driver board                 rev E
    └── FW-JD  Joint driver firmware            1.8.2

Count the levels from the robot down to the firmware on a joint driver board: robot, arm, actuator, board, firmware. That's five, and the fasteners, connectors, and harnesses haven't shown up yet.

A spreadsheet can hold every part on that tree. What it can't hold is the tree. Indent a row and you've made a formatting choice, not a parent-child relationship, and the first sort by part number throws it away.

The Actuator Module Is Your Real Product

Look at ACT-L. It appears three times in the arm, at joints one through three. If you also sell a fixed arm cell for bench work, it appears three more times there.

The tempting move is to paste its contents into the arm's BOM three times, once per joint. That works until rev D of the module swaps the bearing. Now you have three copies to update in this arm, three more in the arm cell, and no record of which ones you missed.

Model the module once instead. ACT-L gets its own part number, its own BOM, and its own revision. The arm references it as one line at quantity three. When the module changes, it changes in one place, and every assembly that references it picks up the change. That's also why actuator modules should get internal part numbers, not descriptive names: "large actuator" is a description, ACT-L rev C is a thing you can build.

Buy the Servo or Build the Joint

Not every joint needs this. If your gripper wrist uses a purchased smart servo, that servo is one line: a manufacturer, a part number, a price, a lead time. Its internals are the vendor's problem.

A joint you build is different. Its children are a motor, a gearbox, an encoder, a bearing, a housing, and a driver board, from as many as six suppliers. Each of those has its own lead time, and the gearbox is usually the longest. Precision strain wave and cycloidal reducers come from a short list of makers, so a single-source gearbox can set the date of your whole build. That's a triage decision about single-sourcing risk, and you can't make it if the gearbox is buried in row 214 of a flat list instead of sitting under the module it gates.

The decision to buy or build a joint is a product-structure decision. A bought joint is a leaf. A built joint is a branch with its own supply chain.

Seven Boards, Seven Firmware Questions

An IoT device usually has one board and one firmware image; the hard part there is keeping the mechanical, electrical, and firmware records in sync. A robot multiplies that problem. Our example has a main controller, six joint driver boards, and probably a battery management board that the battery vendor flashes for you.

That's at least seven processors and three firmware images, and each one ships on specific hardware. So firmware goes where the board is: FW-JD 1.8.2 under PCBA-JD, inside each actuator, and FW-MAIN under the main controller in the base. One "Firmware" line at the top of the robot can't tell your CM which image goes on which of seven boards. The case for treating firmware as a versioned BOM line applies here seven times.

It also catches a robotics-specific failure: a joint driver on firmware 1.7 sitting next to five on 1.8.2, all inside one arm. Calibration tables and motor gains often live in firmware. A mixed arm will run, and it will run badly.

Change the Gearbox Once, Change Every Robot

Say testing shows joint two runs out of torque with a full payload, so the team moves GBX-L from 100:1 to 120:1. That's not a part swap. Joint speed drops, the joint driver firmware needs new gains, and the module's output torque and its mounting may change. ACT-L goes to rev D.

Now the real question: which products does that touch? With one structure, the answer is mechanical: every assembly that references ACT-L rev C. That's the arm, the robot that contains the arm, and the arm cell you forgot was using the same module. With copied flat lists, the answer is whatever the engineer remembers.

This is where an ECO earns its keep. A minimum viable ECO names the changed item, the new revision, and what it affects. On a robot, "what it affects" is a list of parent assemblies, and only a multi-level structure can produce it reliably.

What Bosch Actually Receives

A tier-1 contract manufacturer doesn't build a robot from the top down. It builds actuator modules on one line, tests them, and kits them into arms on another. The structure you keep is the structure your CM builds from: each module with its own BOM, its own revision, its own firmware image, and its own test.

Hand over one flattened list and the CM's engineers will rebuild that tree themselves, slowly, with their own guesses about where the boundaries are. Hand over the tree and their routings follow your modules. The rest of the package is the same as for any product; the CM handoff checklist covers assembly instructions, labels, and test procedures.

You don't need Teamcenter for this. You need sub-BOMs that reference each other, revisions on every level, and firmware as a line item. oroForge holds a top-level BOM plus sub-BOMs for every subassembly, and its import step nests subassemblies from your spreadsheets and STEP files instead of leaving them flat. See pricing for what a team your size would pay.

Frequently Asked Questions

How many levels does a robotics BOM need?
Usually four to five before you count fasteners: the robot, its major assemblies such as the arm and the base, the actuator modules inside them, the joint driver boards inside each actuator, and the firmware on each board. A flat list can hold the parts, but it loses which parts belong to which module.
How should a robotics startup handle actuators that repeat across joints?
Give the actuator module its own part number and its own BOM, then reference it from the arm with a quantity. An arm with three identical large joints carries one line for the large actuator module at quantity three, not three copies of its contents that can drift apart.
Should a purchased servo and a custom-built actuator be modeled the same way?
No. A purchased servo is a single line item with a manufacturer part number. A built actuator is a subassembly whose children include the motor, gearbox, encoder, bearings, housing, and driver board, and its gearbox is often the longest-lead part in the robot.
Where does firmware go in a robot BOM?
Under each board that runs it. A robot with six joint driver boards and a main controller has at least two firmware images, the joint driver firmware and the main controller firmware, and each belongs as a versioned line under the board it ships on rather than as one firmware line at the top of the robot.
Why does a shared actuator module make engineering changes harder?
Because a change to the module changes every product that uses it. If the module exists once in a multi-level structure, the affected robots are the assemblies that reference it; if it was copied into several flat lists, someone has to find every copy by hand before the ECO is safe to release.

Ready to manage BOMs without the enterprise overhead?

Free plan available. No sales call. Up and running in minutes.

David Orozco Cosio

Co-Founder, oroForge

MIT engineer with 10+ years building hardware products across IoT, robotics, and medical devices.