System Design

What are the design metrics of embedded systems?

The main design metrics of embedded systems: unit cost, NRE cost, size, performance, power, flexibility, time-to-market, maintainability, correctness and safety.

On this page
  1. Short answer
  2. Each design metric explained
  3. The design metric competition
  4. Worked example: NRE vs unit cost
  5. Why time-to-market matters so much
  6. How metrics guide real design decisions

Short answer

A design metric is a measurable feature of a system’s implementation that designers try to optimise. The design metrics most commonly listed for embedded systems, following the widely used textbook Embedded System Design: A Unified Hardware/Software Introduction by Frank Vahid and Tony Givargis, are:

  • Unit cost: the cost to manufacture each copy of the system.
  • NRE cost (non-recurring engineering): the one-time cost of designing the system.
  • Size: the physical space taken up, and the amount of code or logic.
  • Performance: how fast the system responds or how much work it gets through.
  • Power: how much electrical power it uses, which affects battery life and heat.
  • Flexibility: how easily the system’s function can be changed without heavy redesign costs.
  • Time-to-prototype: how long it takes to build a working version.
  • Time-to-market: how long it takes to get a product to customers.
  • Maintainability: how easily the system can be changed or fixed after release.
  • Correctness: confidence that the system implements its function properly.
  • Safety: the likelihood that the system will not cause harm.

Many courses and engineers add reliability, security and energy (as distinct from power) to the list. The defining challenge is that these metrics compete with each other: improving one usually makes others worse.

Each design metric explained

Unit cost

Unit cost is the money spent to build each additional device, excluding design costs. It includes components, the circuit board, assembly, testing and packaging. At high production volumes, small savings per unit add up, which is why consumer products are often designed with very little spare capacity.

NRE cost

NRE cost is the one-time cost of designing the system: engineering time, tools, prototypes, certification and test equipment. Once the design is finished, any number of units can be built without paying it again. NRE matters most when production volumes are low, because it is shared across fewer units.

Size

Size has two meanings. Physical size covers the board area, enclosure volume and weight, which matters in wearables, drones and anything that must fit an existing space. Logical size covers the amount of code in software (bytes of flash and RAM) or the number of logic gates or cells in hardware. A smaller logical size can allow a cheaper chip.

Performance

Performance is usually measured in one of two ways:

  • Latency (response time): the time between an input and the system’s response, such as the time from a button press to a motor starting.
  • Throughput: the amount of work done per unit of time, such as samples processed per second.

In real-time embedded systems, the worst-case response time often matters more than the average, because the system must meet its deadlines every time.

Power and energy

Power is the rate at which the system uses energy. It determines heat output and cooling needs, and for battery-powered devices, together with how long the device runs, it sets battery life. Strictly, battery life depends on energy (power multiplied by time), which is why a device that runs fast and then sleeps can use less energy than one that runs slowly all the time. Our article on low-power embedded design covers the techniques used to improve this metric.

Flexibility

Flexibility is the ability to change what the system does without large NRE costs. Software running on a microcontroller is usually more flexible than custom hardware: changing a feature can mean a firmware update rather than a new chip. FPGAs sit in between. Flexibility is valuable when requirements are uncertain or a product family needs variants.

Time-to-prototype

Time-to-prototype is how long it takes to build a working version for testing and demonstration. It is often shorter than time-to-market, and shortening it lets teams find design problems and get user feedback earlier. Development boards and off-the-shelf modules are common ways to reduce it.

Time-to-market

Time-to-market is how long it takes to develop a product to the point where it can be sold. In many markets, being late is very costly, because competitors capture sales and the product’s selling window may be short. This is discussed further below.

Maintainability

Maintainability is how easily the system can be modified after release, especially by engineers who didn’t design it. Clear code structure, good documentation, a reliable firmware update mechanism and the use of components with long availability all improve it.

Correctness

Correctness is confidence that the system does what it is supposed to do. Designers gain it through reviews, testing, simulation and, in some cases, formal verification. It is closely tied to embedded testing and the validation activities described in our guide to testing and validating embedded software.

Safety

Safety is the probability that the system will not cause harm to people, property or the environment. It is critical in automotive, medical, aerospace and industrial systems, which are often developed to functional safety standards such as IEC 61508, ISO 26262, IEC 62304 or DO-178C.

Other metrics often added

  • Reliability: how long the system operates without failure, sometimes expressed as mean time between failures (MTBF).
  • Availability: the proportion of time the system is working when needed.
  • Security: resistance to attacks, unauthorised access and tampering, which is increasingly important for connected devices.
  • Energy per task: how much energy a specific operation consumes, often more useful than average power for battery devices.

The design metric competition

Design metrics pull against each other. A few typical tensions:

  • Performance vs power: a faster processor or higher clock speed usually draws more power.
  • Unit cost vs NRE: a highly optimised custom design can lower unit cost but takes more engineering effort.
  • Size vs cost: smaller packages and denser boards can cost more to make and assemble.
  • Flexibility vs performance and power: general-purpose software on a processor is flexible, but dedicated hardware can be faster and more efficient for a fixed task.
  • Time-to-market vs everything else: extra optimisation takes time, and time may be the scarcest resource.

Improving one metric often worsens another, so the designer’s job is to find a balance that fits the product. That balancing is a large part of hardware-software co-design, where deciding what to put in hardware and what in software changes almost every metric at once.

Worked example: NRE vs unit cost

The total cost of a production run is:

Total cost = NRE cost + (unit cost × number of units)

The cost per product is that total divided by the number of units, which is the NRE spread across each unit plus the unit cost.

Suppose you are choosing between two designs (the numbers are illustrative):

  • Design A: NRE of $20,000 and a unit cost of $10.
  • Design B: NRE of $100,000 and a unit cost of $4, because it uses a cheaper, more heavily optimised design.
Units built Design A cost per unit Design B cost per unit
1,000 $20 + $10 = $30.00 $100 + $4 = $104.00
10,000 $2 + $10 = $12.00 $10 + $4 = $14.00
100,000 $0.20 + $10 = $10.20 $1 + $4 = $5.00

At low volume, Design A is much cheaper. At high volume, Design B wins. The break-even point here is about 13,300 units (where $80,000 of extra NRE is recovered by $6 saved per unit). This is why the expected production volume is one of the first things to pin down in an embedded project.

Why time-to-market matters so much

Many products have a limited market window, the period during which they can sell well before newer products replace them. A product that arrives late may miss the peak of demand while competitors take the early sales. Textbook models of this effect suggest that even a modest delay can cost a disproportionately large share of a product’s lifetime revenue, especially when the market window is short.

This is one reason embedded teams often choose a slightly more expensive but familiar microcontroller, buy off-the-shelf modules rather than designing everything themselves, and reuse proven designs.

How metrics guide real design decisions

In practice, teams rarely optimise every metric. A sensible approach is to:

  1. Identify hard constraints. Some metrics are pass/fail: the device must fit the enclosure, meet its deadlines, pass certification and last a required time on its battery.
  2. Rank the remaining metrics. For a mass-market gadget, unit cost and time-to-market may lead. For a medical device, safety and correctness come first. For a research prototype, time-to-prototype and flexibility may matter most.
  3. Estimate production volume early, because it decides how NRE and unit cost should be traded.
  4. Measure, don’t guess. Profile performance, measure current draw and track memory use throughout the project.
  5. Revisit as you learn. Prototypes and tests often reveal that the original balance was wrong.

Choosing the processor is one of the earliest and most metric-heavy decisions; our guide on how to choose a microcontroller walks through it. For the bigger picture of how these metrics and constraints shape the whole project, see our introduction to embedded system design.

The complete guide to system design

Introduction to Embedded System Design: The Design Flow
Read the guide

Keep exploring

Guides from other topics

All topics →