Skip to main content
Back to Curriculum
Module: Capstone & Career Portfolio•Lesson 83•40 min read

Hardware and Physical Products: PM Beyond Software

Lesson 83: Hardware and Physical Products: PM Beyond Software

Every framework this curriculum has built so far assumes a specific, usually unstated property of the product being managed: that it can be changed after it reaches the user. A software bug discovered after launch can typically be fixed with a deployment that reaches every user within hours or days. A poorly calibrated recommendation algorithm can be retrained. A confusing onboarding flow can be redesigned and shipped the same week. This lesson addresses what happens when that assumption fails entirely — when the product is physical, and a mistake discovered after a critical point in its development can no longer be fixed remotely at all, because the flawed version has already been manufactured, shipped, and is sitting in a customer's home.

A PM moving from software to hardware for the first time tends to underestimate just how differently risk and iteration work in a physical product context. Software's iteration loop assumes continuous deployment is always available as a safety net; hardware's iteration loop has genuine, irreversible commitment points, after which a design flaw is no longer a bug to patch but a manufactured reality that must be lived with, recalled, or replaced at enormous cost. This is not merely "software but slower" — it is a fundamentally different risk profile requiring fundamentally different discipline, especially around the specific question of what, if anything, can still be changed remotely after a physical unit has shipped.

This lesson introduces the Commitment Curve, this lesson's core mental model, to give you a structured way to reason about where your product currently sits on the path from freely changeable to permanently fixed, and what that position should mean for how carefully you validate decisions before making them.

Learning Objectives

  1. 1

    Explain why hardware product development carries a fundamentally different risk profile than software, centered on irreversibility rather than continuous iteration.

  2. 2

    Apply the Commitment Curve to identify how much a specific hardware decision would cost to reverse at its current stage of development.

  3. 3

    Identify the role firmware and over-the-air (OTA) update capability plays in preserving some post-shipment flexibility for an otherwise fixed physical product.

  4. 4

    Explain why hardware validation and testing rigor must scale with proximity to an irreversible commitment point.

  5. 5

    Evaluate a hardware product decision for whether it accounts for the specific commitment stage it currently occupies.

This lesson assumes the Leverage Stack from Lesson 61, since a hardware product's firmware update mechanism functions analogously to a Layer 2 Developer Surface requiring its own stability promise, and the Sunset Runway and dependency-aware migration discipline from Lesson 68, since a hardware recall shares important structural similarities with a large-scale, high-stakes migration.

Why Hardware's Risk Profile Differs Fundamentally from Software's

Software product development, across nearly every framework in this curriculum, implicitly assumes that a mistake discovered after launch can be corrected through a subsequent deployment, typically at a cost proportional to the size of the fix rather than the number of users affected. This assumption underlies concepts as varied as the A/B testing rigor from Module 5 and the migration discipline from Lesson 68 — even a large-scale software migration, however costly and disruptive, remains fundamentally a matter of coordinating a change that is still technically possible to make. Hardware development breaks this assumption at specific, identifiable points in its lifecycle. Once a product design has been committed to tooling — the expensive, custom manufacturing equipment specific to a particular design — changing that design requires re-tooling, at a cost and timeline that can run into the months and into significant capital expenditure. Once units have been manufactured and shipped to customers, a flaw that cannot be addressed through a firmware update is no longer a bug; it is a defect that exists in every physical unit already in a customer's possession, correctable only through an expensive and reputationally damaging recall or replacement program.

The Commitment Curve

This lesson introduces the Commitment Curve, illustrating how the cost of reversing a hardware decision increases sharply and non-linearly as a product moves through its development stages:

Process diagram showing flow: Concept(cheap to change) → Prototype(moderate cost to change) → Tooling Commitment(expensive, slow to change) → Mass Production(very expensive, slow to change) → Shipped to Customers(often impossible to change without a recall)

Concept
(cheap to change)

Prototype
(moderate cost to change)

Tooling Commitment
(expensive, slow to change)

Mass Production
(very expensive, slow to change)

Shipped to Customers
(often impossible to change without a recall)

The Commitment Curve's core discipline is recognizing that the appropriate level of validation rigor for any given decision should scale with proximity to these commitment points, rather than remaining constant throughout development. A design assumption that would be reasonable to test quickly and cheaply at the Concept or Prototype stage becomes an entirely different category of risk once the same assumption is embedded in a Tooling Commitment, since an error discovered after tooling has been committed can no longer be corrected through further iteration on the same design — it requires either accepting the flaw, or paying the very high cost of re-tooling. This is precisely why hardware product teams typically invest disproportionately in validation, user testing, and design review before crossing the Tooling Commitment threshold, compared to the validation rigor a software team might apply before an equivalent-seeming decision, since a software team retains the ability to iterate further even after a decision has technically shipped.

Firmware and OTA Updates as Preserved Flexibility

Firmware — the embedded software running on a physical device — represents one of the few mechanisms available to preserve genuine post-shipment flexibility for an otherwise fixed hardware product. A device with over-the-air (OTA) update capability can have its behavior meaningfully changed after it has already shipped to customers, correcting certain categories of flaws (a software bug in the device's control logic, a suboptimal default configuration) without requiring a physical recall, in a way directly analogous to the Layer 2 Developer Surface concept from Lesson 61 — the firmware update mechanism is, in effect, its own promise to customers about what can and cannot be corrected after purchase, and that promise should be designed deliberately rather than assumed. Critically, however, OTA update capability can only correct flaws in the firmware, not in the physical hardware itself — a defective sensor, an undersized battery, or a structurally weak physical component cannot be fixed through a software update regardless of how sophisticated the device's update mechanism is, meaning firmware flexibility, while valuable, does not eliminate the fundamental irreversibility the Commitment Curve describes for genuinely physical design decisions.

Why Validation Rigor Must Scale with Commitment Proximity

A specific and costly hardware product management mistake is applying uniform validation rigor throughout development, rather than deliberately intensifying scrutiny as a design decision approaches an irreversible commitment point. A hardware team that treats every design review with the same level of urgency, regardless of whether the decision under review is still cheaply reversible or is about to be locked in through tooling commitment, risks either wasting excessive validation effort on decisions that could be iterated on cheaply later, or, more dangerously, failing to apply sufficient scrutiny to a decision immediately preceding an expensive, irreversible commitment.

Common Mistakes to Avoid

✕

Applying software-style "ship and iterate" thinking to genuinely physical design decisions

A physical design flaw discovered after tooling commitment or mass production cannot be patched the way a software bug can, and treating hardware iteration as equivalent to software iteration underestimates this risk severely.

✕

Assuming firmware update capability solves all post-shipment risk

OTA updates can only correct flaws in embedded software, not in physical hardware components, and conflating the two creates false confidence about what can actually be fixed after shipment.

✕

Applying uniform validation rigor throughout hardware development, rather than intensifying scrutiny as a decision approaches an irreversible commitment point

This risks insufficient validation immediately before the most expensive, hardest-to-reverse decisions.

✕

Underestimating the cost and timeline of re-tooling relative to a software rollback

A hardware team accustomed to software's typically fast, cheap correction cycle can badly misjudge how long and how expensive a hardware correction genuinely is.

✕

Failing to design firmware update capability into a physical product from the outset

Retrofitting OTA update capability into a device not originally designed to support it is far more difficult than building it in from the start, echoing the same architectural-decision-early principle established for regulatory and privacy requirements in Lessons 81 and 82.

Ready to test your product judgment?

Take the interactive practice quiz for Lesson 83 and build your skill radar dashboard.