Executive summary
Six answers constrain the partition more than any datasheet
Every electronic system that senses, decides, communicates and acts has to be partitioned: which function lives in analogue, which in digital logic, which in firmware on a processor, which in a standard part and which in custom silicon, and where the trust boundary between them goes. Teams usually make that decision by starting from a part they know. We make it by starting from six questions about the system, because the answers constrain the partition far more tightly than any component choice, and because they are the questions a customer can answer on day one.
The six questions are: how fast must it react; what powers it; how is it connected; how long will it live in the field; what happens if it is compromised; and how many will you make per year. This guide takes each in turn and sets out what the answer changes across the four stages we partition every system into: sense, compute, connect and act. It then shows how the answers interact, because the interesting decisions happen where two answers pull in different directions.
The same six questions drive the interactive configurator on our system architecture page and the architecture brief you can download from it. That tool gives a starting point for a conversation, not a design. This guide explains the reasoning behind it so that you can disagree with it in detail.
Why these six
Cost, size and temperature are outcomes. These six are causes.
A reasonable objection is that the list leaves out the things customers care about most: unit cost, board area, operating temperature, certification. They are left out on purpose. Each of them is sized by the partition rather than deciding it. Unit cost at a given volume follows from how much is custom silicon and how much is a standard part. Board area follows from how many parts there are and how much is integrated. Temperature rating follows from where the device will live, which the connectivity and field-life answers already imply. Certification follows from the consequence-of-compromise answer and the sector.
The six questions are the ones whose answers force a different partition rather than a different size of the same partition. Reaction time decides whether timing is a hardware property. Power source decides the energy per decision. Connectivity decides what can be depended on and where the trust boundary leaves your hardware. Field life decides what must be changeable in service. Consequence of compromise decides how much of the architecture is security architecture. Volume decides whether custom silicon can ever pay. Change any one of them by a category and the right partition changes; change the unit cost target by 20 percent and it usually does not.
They are also the questions a customer can answer on the first day without a study. Nobody knows the unit cost of a system that has not been partitioned. Everybody knows whether it runs on a battery.
Question one
How fast must it react? Seconds, milliseconds or microseconds
Reaction time is the first question because it decides whether timing is a software property or a hardware property. In the seconds regime, a standard processor running an operating system reacts fast enough, timing variation of tens of milliseconds is invisible, and supervisory control in software is the right answer. We would tell you at this stage that you may not need custom hardware.
In the milliseconds regime, the answer splits. Deterministic firmware on a real-time core can close a control loop at kilohertz rates, but a general-purpose operating system cannot be relied on for a worst case, and protection functions must be handled in hardware so that a software stall cannot propagate. An FPGA system-on-chip, a processor beside programmable fabric, puts firmware where it can be and hardware where it must be. This is the regime of IEC 61850 protection messaging, where transmission-class trip messages have 3 ms and distribution-class trips 10 ms, and of 3GPP cyber-physical control requirements at 5 to 100 ms.
In the microseconds regime, the control loop itself must be in fabric or silicon, immune to software timing. Sampled Values at 4 kHz or more, field-oriented motor control at 100 kHz switching, and RF control loops all live here. Compute moves to FPGA fabric, or to an ASIC with a hardened datapath once the design is proven and the volume pays for it. Sensing moves to a custom mixed-signal front end, because the converter, its clocking and the analogue path have to be designed against one noise and timing budget rather than assembled from parts with independent specifications.
The question to answer precisely is not the loop rate but the worst-case reaction time you can tolerate and the consequence of missing it once. A system that must react in 100 microseconds at the 99.9999th percentile is a different system from one that must react in 100 microseconds on average.
Question two
What powers it? Mains, battery or harvested
The power source sets the energy budget, and the energy budget sets how much computation per decision you can afford. On mains power the budget is thermal rather than energetic: the question is how much heat the enclosure can shed, which still matters in a sealed substation cabinet at 55 degrees, but it does not force the architecture.
On battery the budget is energy per decision and per day. Compute choices tilt toward duty cycling, low-power microcontrollers with accelerators, and moving inference closer to the sensor so that less data is moved, because moving data costs more energy than processing it. Sensing tilts toward converters that can be put to sleep and woken.
Harvested power inverts the design. The energy budget sets the sample rate, not the other way round. Sensing becomes an ultra-low-power chain with duty-cycled converters. Compute at low volume is a careful microcontroller choice; at high volume, inference in fixed custom silicon is the only way to fit inside a harvested budget, because a general-purpose part spends most of its energy on flexibility you are not using. This is one of the two places in the checklist where volume and another answer combine to force an ASIC.
For power stages and actuation, the source also decides topology and device technology. Gallium nitride switching lets a power stage run faster and cooler, but as we argue elsewhere on this site, GaN is not the product; the switching, layout, sensing and control have to be designed together or the device advantage is lost in the surrounding circuit.
Question three
How is it connected? Not at all, private 5G, or industrial Ethernet
Connectivity decides what the system can depend on. A system that is not connected, or whose connection is incidental, makes every decision on site and nothing depends on a network being up. That is the most robust posture and the most constraining, because the compute has to be sufficient locally.
Private 5G puts an operational technology bridge at the boundary. 3GPP defines a stand-alone non-public network as one operated by the organisation itself without relying on public network functions, which is the model that matters for critical traffic. The partition consequence is that the device at the boundary must process the OT protocol deterministically and hold the security boundary, because it is the point where a safety-relevant message leaves hardware you control and enters a radio. Deterministic processing at that boundary, rather than a modem behind an industrial PC, is the pattern we are developing in GRID-5G.
Industrial Ethernet with precision time changes what timing means. With IEEE 1588 Precision Time Protocol and hardware timestamping in the physical layer, time becomes a property every node shares rather than an average each one measures. Sampled Values in IEC 61850 depend on it. The partition consequence is that timestamping must be in hardware, which usually means an FPGA or a PHY with hardware timestamp support, and that the time distribution is itself a safety-relevant function to be designed and verified.
The question hidden inside this one is what happens when the connection fails. A connected system should be designed so that the answer is "it keeps working on local decisions until the connection returns", and that answer decides how much compute has to live at the edge.
Question four
How long in the field? Five years, or fifteen and more
Field life is the question most often skipped and the one that hurts most later. A five-year product can use a standard update path and a standard parts plan. A fifteen-year or longer product, which is the normal case for substations, rail, aerospace and most infrastructure, must be designed around three things that will change while it is in service: the parts, the threats and the cryptography.
Parts availability is a planning problem. A long-life design uses parts with stated longevity programmes where it can, designs second sources into the board where it cannot, and keeps the functions most likely to be orphaned by a vendor in programmable logic where they can be ported. An FPGA design that is delivered as source with a reproducible build is portable in a way that a closed system-on-chip is not.
Cryptographic agility is an architecture problem. NIST published its first three post-quantum cryptography standards on 13 August 2024: FIPS 203 (ML-KEM) for key encapsulation, FIPS 204 (ML-DSA) and FIPS 205 (SLH-DSA) for digital signatures, and advised administrators to start integrating them immediately because full integration will take time. A device shipped in 2027 with a fifteen-year life will spend most of that life in a world where its original signature scheme is considered weak. So the secure boot chain and the update mechanism have to be designed to accept new algorithms and larger keys, which has consequences for key storage size, boot time and the hardware root of trust, and those consequences have to be in the partition on day one.
A field update path is both. It means signed updates for firmware and for programmable logic, a recovery path if an update fails in a cabinet nobody will visit for a year, and an honest statement in the design of which functions can never be updated and therefore must be right at shipment.
Question five
What if it is compromised? Inconvenient, or a safety or national impact
Consequence of compromise decides how much of the architecture is security architecture. If compromise is inconvenient, secure boot and signed updates are a reasonable baseline and the rest is good software practice. If compromise has a safety or national impact, security crosses all four stages and becomes a partitioning constraint in its own right.
The first consequence is isolation. Critical control functions are separated from less trusted code by hardware, not by convention: a protection function in fabric that a compromised processor cannot alter, a control loop whose outputs are bounded in hardware regardless of what the firmware commands. The second is a hardware root of trust, so that the boot chain, the keys and the update verification do not depend on software that might itself be compromised. The third is memory safety, because the majority of serious exploitable defects in systems software are memory safety errors, and a device that cannot be patched quickly in the field should not be relying on code review alone to prevent them.
That is why our direction for high-consequence systems is CHERI. CHERI, Capability Hardware Enhanced RISC Instructions, is a joint research project of SRI International and the University of Cambridge that revisits fundamental hardware and software design choices to enforce memory and pointer boundaries in the processor. Arm's experimental Morello board, supported by the UK Digital Security by Design programme, has been available to researchers since late 2021, and the CHERI Alliance, of which Novomorphic is a full member, exists to bring the approach into production. Applied to a RISC-V control processor, CHERI means that a software defect cannot become an escalation across a trust boundary. For the partition, it means choosing a processor and toolchain with a route to capability hardware, and designing the firmware so that compartments map onto the trust boundaries the system actually has.
The NCSC Cyber Assessment Framework is the right vocabulary for this conversation with a UK infrastructure operator. Its four objectives, managing security risk, protecting against cyber attack, detecting cyber security events and minimising the impact of incidents, each have a hardware consequence, and a device partition that cannot be mapped onto them will struggle through assurance.
Question six
How many per year? Hundreds, or tens of thousands
Volume decides whether custom silicon can ever pay for itself, and it decides it late. An ASIC costs a fixed sum in design, verification, masks and qualification before the first part ships, and then a small sum per part. An FPGA costs little up front and a larger sum per part. At hundreds of units a year, the FPGA is almost always the product, and a design programme should end with an FPGA-based assembly and a migration assessment that says so. At tens of thousands, the arithmetic can favour an ASIC, provided the function is stable enough to fix in silicon.
That proviso is the point. Volume alone does not justify a tape-out; volume plus a function that has stopped changing does. So our route to an ASIC always runs through an FPGA proof-of-concept whose test report and migration assessment say which blocks are stable and which are not. A system at tens of thousands of units with microsecond reaction time gets an ASIC with a hardened datapath, proven on FPGA first and then fixed in silicon for cost and power. A system at tens of thousands with millisecond reaction time is prototyped on fabric now and migrates when the volume pays. A system at tens of thousands on harvested power goes to custom low-power silicon because nothing else fits the energy budget.
Volume also decides who the customer is for the design. At hundreds, the design is for you and the FPGA source is the deliverable. At tens of thousands, the design is for a production line, and design for test, yield and qualification enter the partition from the start.
Putting it together
What each answer moves, stage by stage
| Criterion | Sense | Compute | Connect | Act |
|---|---|---|---|---|
| MicrosecondsTiming is a hardware property. | Custom mixed-signal front end | Fabric or hardened ASIC datapath | Hardware timestamping | Hardware control loop |
| MillisecondsFirmware where it can be, hardware where it must be. | Budgeted standard converters | FPGA SoC, or ASIC at volume | Deterministic OT bridge | Real-time firmware loop, protection in hardware |
| SecondsForgiving. You may not need custom hardware. | Standard converters | Standard processor | Any | Supervisory software control |
| Harvested powerThe energy budget sets the sample rate. | Duty-cycled ultra-low-power chain | MCU plus accelerator, or custom silicon at volume | Local first | Minimal actuation |
| Fifteen years or moreParts, threats and cryptography will all change in service. | Second-sourced parts | Portable source, reproducible build | Agile cryptography in the boundary device | Protected update, recovery path |
| Safety or national consequenceSecurity becomes a partitioning constraint. | Integrity-checked inputs | Root of trust, partitioned, CHERI direction | Boundary device holds the trust boundary | Hardware-bounded outputs |
Microseconds
Timing is a hardware property.
- Sense
- Custom mixed-signal front end
- Compute
- Fabric or hardened ASIC datapath
- Connect
- Hardware timestamping
- Act
- Hardware control loop
Milliseconds
Firmware where it can be, hardware where it must be.
- Sense
- Budgeted standard converters
- Compute
- FPGA SoC, or ASIC at volume
- Connect
- Deterministic OT bridge
- Act
- Real-time firmware loop, protection in hardware
Seconds
Forgiving. You may not need custom hardware.
- Sense
- Standard converters
- Compute
- Standard processor
- Connect
- Any
- Act
- Supervisory software control
Harvested power
The energy budget sets the sample rate.
- Sense
- Duty-cycled ultra-low-power chain
- Compute
- MCU plus accelerator, or custom silicon at volume
- Connect
- Local first
- Act
- Minimal actuation
Fifteen years or more
Parts, threats and cryptography will all change in service.
- Sense
- Second-sourced parts
- Compute
- Portable source, reproducible build
- Connect
- Agile cryptography in the boundary device
- Act
- Protected update, recovery path
Safety or national consequence
Security becomes a partitioning constraint.
- Sense
- Integrity-checked inputs
- Compute
- Root of trust, partitioned, CHERI direction
- Connect
- Boundary device holds the trust boundary
- Act
- Hardware-bounded outputs
Each cell is a default, not a rule. Where two answers disagree, the stricter one wins at that stage, and the engagement spends its time on exactly those cells.
Where answers collide
The interesting decisions are where two answers disagree
Microseconds at low volume
The reaction time wants silicon; the volume cannot pay for it. The answer is FPGA fabric, which is deterministic, parallel and in hardware without a tape-out. The FPGA may well be the final product.
Harvested power at high volume
The energy budget rules out a general-purpose part; the volume makes custom silicon viable. This is the clearest case for a low-power ASIC, and it still goes through an FPGA or emulation stage to prove the algorithm first.
Long life with private 5G
The device will outlive the radio generation it ships with. The boundary device must be radio-agnostic at its OT side and updateable at its network side, and the cryptography must be agile across the life.
High consequence with firmware control
A millisecond loop in firmware is fine until compromise matters. Then protection moves to hardware, the processor gets a root of trust and compartments, and the firmware is designed so that a defect stays inside its compartment.
Worked example one
A substation edge device: milliseconds, mains, private 5G, twenty years, national consequence, hundreds
Take the device Novomorphic is developing in GRID-5G, the edge platform between substation IEDs and a private 5G network, and run it through the six questions. Reaction time: milliseconds, with microsecond timestamps for Sampled Values, since IEC 61850 distribution-class protection has 10 ms and the device must consume as little of that as possible, predictably. Power: mains, from the substation auxiliary supply, but inside a sealed enclosure with a hard thermal budget. Connectivity: private 5G at the boundary, with industrial Ethernet and precision time on the substation side. Field life: fifteen years or more. Consequence of compromise: national, since the device sits on critical national infrastructure. Volume: hundreds to low thousands across a DNO estate.
The matrix gives the partition almost directly. Sense: standard converters and PHYs with hardware timestamping, budgeted at architecture. Compute: FPGA fabric for the IEC 61850 protocol engine and the precision time handling, so the message path never touches a software scheduler, with a processor beside it for management, the anomaly-detection model and the network stack. Connect: the device is the OT bridge, so it holds the trust boundary between the hardware it controls and the radio it does not, and its network side is designed to be replaced when the radio generation changes. Act: there is little actuation, but the outputs that exist, GOOSE publication toward protection devices, are bounded in hardware so that a compromised processor cannot forge a trip.
The security row reads: hardware root of trust, partitioned control, signed updates for both firmware and bitstream, and a processor choice with a route to CHERI. The lifecycle row reads: post-quantum-ready key storage in the boot chain, second-sourced parts, a reproducible FPGA build, and a recovery path for a failed update in a cabinet no one will visit for a year. Volume at hundreds says the FPGA is the product; the programme's migration assessment at the end of the bench phase will say whether any block has earned its way into silicon.
The timing figures in this example are the standards' requirements, not results from the device. GRID-5G is designed to test the reasoning through hardware-in-the-loop trials at PNDC.
This example describes a design in development, not a product.
Worked example two
A harvested sensor node: seconds, harvested, local, five years, inconvenient, tens of thousands
Now a very different system: a condition-monitoring node on rotating machinery, powered by a vibration harvester, reporting a health score every few minutes over a short-range link, in a factory where a false alarm costs an hour and a compromise costs an embarrassing email. Reaction time: seconds. Power: harvested. Connectivity: local, with an opportunistic uplink. Field life: five years, the life of the bearing it watches. Consequence of compromise: inconvenient. Volume: tens of thousands a year.
Here the harvested answer and the volume answer combine, and they win. Sense: a duty-cycled ultra-low-power front end where the energy budget sets the sample rate, not the other way round. Compute: at tens of thousands of units on a harvested budget, inference in fixed low-power silicon is the only partition that fits, because a general-purpose microcontroller spends most of its energy on flexibility this node never uses. Connect: local first, with the uplink treated as a bonus, so the node must be useful with no network at all. Act: none beyond a status indication. The security row is the baseline, secure boot and signed update, and the lifecycle row is the short one.
The route is the long one, workshop to design programme, because the answer is an ASIC. But the proof-of-concept step is not skipped: the inference algorithm and the front end are proven on an FPGA or an emulation platform with real vibration data before any silicon is committed, and the migration assessment establishes the energy per inference that justifies the tape-out. The two examples share a method and almost nothing else, which is the point of the checklist.
Behind each question
The follow-up we ask when the first answer comes too easily
Reaction time
At what percentile, and what happens the one time in a million you miss it? A loop that can tolerate an occasional late sample is a different system from one that trips a breaker.
Power
What is the thermal path, and who owns the enclosure? Mains power inside a sealed box at 55 degrees is a budget, not a free resource.
Connectivity
What does the system do during a four-hour network outage? If the answer is "nothing useful", the compute is in the wrong place.
Field life
Which parts in your current design have a stated longevity programme, and what is your signature algorithm plan for 2035? Silence on either is a finding.
Consequence
Who, outside your company, would be harmed by a compromise, and which regulator would ask you about it? The answer decides whether security is a feature or a constraint.
Volume
Over what period, and how confident are you? A tape-out justified by year-three volumes that never arrive is the most expensive mistake on this list.
Across all four
Security and lifecycle are rows, not columns
Security and lifecycle do not belong to one stage. They run across sense, compute, connect and act, and the partition has to carry them through every boundary. For a system with a safety or national consequence the row reads: hardware root of trust, partitioned control, signed update, CHERI direction. For a system where compromise is inconvenient: secure boot and signed update as a baseline. For a long field life: post-quantum-ready keys, a planned parts availability path and a field update path. For a short one: a standard update path and parts plan.
Writing them as rows is a discipline. It forces the question "and how does this stage honour the security row" at every boundary, which is where most security architectures leak: a secure processor beside a converter whose configuration can be rewritten by anyone on the bus, or a signed firmware image beside a programmable logic image that is not.
What follows
The sensible route depends on where the answers land
Workshop
Always. Six answers in a room with the engineers who would do the work, and a written partitioning opinion within a week. If the answers are seconds, mains and inconvenient, the route may stop here with the advice that you do not need us.
Feasibility
When the envelope is tight or the technology choice is open. Budgets allocated across stages, assumptions exposed, costed route.
FPGA proof-of-concept
When the compute belongs in fabric, or silicon is a possibility. Hardware, test report, migration assessment. At hundreds of units this is often the final step.
Design programme
When volume and a stable function justify silicon, or when an integration-ready hardware and firmware assembly is the product. Gates at each phase, and you can stop at any of them.
The interactive configurator on the system architecture page applies these same rules and produces a one-page brief. It is a starting point for a conversation, not a design. Real partitioning comes from your numbers.
Existing designs
Running the checklist backwards over a design you already have
The checklist is written for a new system, but most of the systems we see already exist in some form: a product that has outgrown its processor, a prototype that works on the bench and fails in the field, a design inherited with a team that has left. The six questions work in reverse. Answer them for the system as it is deployed, not as it was specified, and then read the matrix row by row against what was built.
The gaps are usually in the same places. A millisecond system with protection in firmware, because the reaction-time answer was written down as an average and the worst case was never tested. A device specified for fifteen years with a single-sourced system-on-chip and a signature scheme fixed in a boot ROM, because the field-life answer was never asked. A connected system that does nothing useful when the network is down, because connectivity was treated as a feature rather than a dependency. A high-consequence device with a secure processor beside a converter that anyone on the bus can reconfigure, because the security row was drawn through one stage and not across four.
A backwards run produces a short list of mismatches between the answers and the partition, and for each one a judgement: live with it, mitigate it in firmware, or re-partition. That list is the agenda for a workshop on an existing design, and it is often shorter and more decisive than the list for a new one, because the field has already answered several of the questions for you.
Limits
What the checklist does not do
- The checklist gives a defensible first partition from six answers a customer can give on day one, and it names the cells where the engineering effort should go
Not included
It does not size anything. It does not replace a timing budget, a power budget or a noise budget with real numbers. It does not know your supply chain, your certification regime or your installed base. Every default in the matrix above has been overturned by a real constraint at least once, and the engagement exists to find yours.
