The controller prototype sits on the VP of Engineering’s desk, next to a second one, one board revision newer. The external team that wrote the firmware for eight months has just finished its contract. The repository has been handed over, and so has the documentation. The first in-house build fails: a different compiler version, a missing linker script, a path to the microcontroller vendor’s library that only ever existed on one of the vendor engineers’ laptops. The test rig used to check every release is in the vendor’s lab, in another country. The key used to sign firmware images is there too.

On paper the company has everything: code, rights, documents. In practice it cannot ship a fix. And since 11 September 2026, when the reporting obligations of the EU Cyber Resilience Act started to apply, that inability has stopped being only an operational problem for anyone selling devices in Europe.

This article is for engineering leaders at companies that build devices: controllers, sensors, medical devices, industrial and consumer electronics. It defends one position that some readers will disagree with: outsourcing embedded software does not take away control because someone else writes the code. It takes control away when, together with the code, you hand over the test rig, the build toolchain, the signing keys and the release decision. Writing firmware can be outsourced. Those four things cannot.

Why is outsourcing firmware different from outsourcing a web application?

Because a bug in a web application is fixed in an hour, while a bug in firmware is sometimes fixed only at the next service visit. Even devices with over-the-air updates have limits: slow links, batteries, maintenance windows at the customer’s site, and the risk that a failed update turns the device into a brick. That changes the economics of quality. In a web project you accept that some defects will surface in production. In an embedded project, every defect that surfaces in the field costs many times more than the same defect caught on the bench.

The second difference is hardware. Embedded software runs on a specific microcontroller, with a specific power design, specific sensors and a specific board revision. An external team cannot work without access to that hardware, and prototypes tend to be few, expensive and changing during the project. Hardware logistics becomes part of vendor management, something that simply does not exist when you outsource a web application.

The third difference is product lifetime. A web application lives a few years and is constantly rewritten. An industrial controller, a meter or a medical device runs at the customer’s site for ten years or more. Throughout that time someone has to be able to build the firmware from the same code, with the same compiler, and ship a security fix. If that capability exists only at the vendor, your product depends on the vendor for longer than any contract lasts.

The fourth difference is regulation. Many device categories are subject to standards that describe not just the product but also the process used to build it: who reviews the code, how requirements trace to tests, which tools can be trusted. When you outsource the work, those requirements do not disappear. They pass to the vendor, but responsibility for meeting them stays with the manufacturer.

These four differences lead to a conclusion that runs through the rest of this article: in embedded, receiving the code is not enough. You must keep the ability to turn that code into a verified, signed product.

What can you hand to a vendor, and what should you keep?

Firmware is not a single block. It consists of layers that differ in risk, in how much product knowledge they require and in how hard they are to take back later. The table below shows a split that works as a starting point for vendor discussions.

ElementOutsource?Why
Peripheral drivers, board support package (BSP)YesWell-defined scope, general microcontroller knowledge, easy to accept on hardware
RTOS port, integration of communication stacksYesNeeds experience the company often lacks, and the result is easy to verify
Application layer, device logicYes, collaborativelyContains product knowledge, so needs a requirements owner on your side
Bootloader and update mechanismYes, with acceptance by your teamA defect here can permanently damage devices in the field
Test automation, system testingYesA good fit for external testers, provided the rig belongs to you
System requirements and architectureNo, support onlyThis is the definition of the product; a vendor can help but should not own it
Build toolchain, tool versionsNoWithout it you cannot ship a fix after the contract ends
HIL test rigNoIt is your acceptance and independent verification point
Signing keys and update infrastructureNoWhoever holds the keys decides what runs on devices
Release decision, vulnerability handlingNoThe manufacturer’s responsibility, including legally

The left half of the table is work. The right half is control. A good engagement hands the vendor as much work as possible and not one piece of control. A bad engagement does the opposite: the company keeps minor tasks, and the vendor takes over everything that decides the product, because “it was faster that way”.

Pay attention to the bootloader row. It is something you can outsource, but you cannot accept it on the strength of a report. The update mechanism must pass power-loss tests at every stage of writing, corrupted-image tests and rollback tests. Your team runs them, or a team whose work you can watch on your own rig. A bootloader that fails after devices have shipped is one of the most expensive defects in the industry, because fixing it requires physical access to every unit.

Which engagement model should you choose: turnkey project, vendor team or specialists in your team?

There are three basic models on the market, and each has different consequences for control.

Fixed-price turnkey project. The vendor receives a specification and delivers finished firmware. The model is tempting because the budget is predictable. In embedded, though, it has two weaknesses. First, a device specification is almost never stable: board revisions, component suppliers and EMC test results all change during the project. Every change becomes a change request, and the contract turns into a negotiation. Second, in this model the vendor naturally keeps everything it considers its know-how, including the build environment and the test rigs. You receive an outcome, not a capability.

A vendor team working on your behalf. The vendor provides a whole team with its own lead, billed on time and materials or a monthly subscription. It offers flexibility when scope changes and lets you benefit from a team that has worked together before. Control depends on the rules you set: does the code live in your repository, does the build run in your CI system, do the tests run on your rig?

Specialists in your own team (staff augmentation). External engineers join your team, work in your tools and follow your processes, and you direct their work. This is the model in which control is easiest to keep, because everything is created on your side from the start. It does require someone on your side to lead the team technically: a firmware architect or lead who sets priorities and accepts the work.

Which model is best? It depends on whether you have a firmware lead in-house. If you do, specialists in your team are usually the safest option and the cheapest to take back. If you do not, you need either a vendor team that comes with a lead, or first one person who takes that role inside your company. A turnkey project makes sense for well-defined, self-contained pieces: a driver for a specific sensor, a port of a communication stack, a production tool for flashing devices on the line.

If you choose specialists in your team, the terms that actually affect risk are worth knowing. For staff augmentation ARDURA offers a two-week replacement guarantee, a replacement within five business days if someone leaves during the engagement, and a 30-day notice period. Senior developer rates are about EUR 335-485 per day. To be straightforward about it, ARDURA does not run a dedicated embedded practice: we provide specialists to client teams, and we check the availability of a specific profile, for example a C++ developer with real-time systems experience, for every request.

Why must the test rig and the build toolchain stay on your side?

This is the central claim of the article, so it is worth taking apart.

The build toolchain is everything that turns source code into a firmware image: a compiler in a specific version, linker scripts, the microcontroller vendor’s libraries, configuration code generators, signing tools, build scripts. In embedded, the compiler version matters in ways web developers often underestimate. A different version can optimise code differently, change the image size so it no longer fits in flash, or alter the timing in interrupt handling. Firmware built with a different toolchain is formally a different product that needs to be tested again.

The practical test is simple: can someone from your team, on a clean machine or in a container, in your CI system, build from the repository exactly the image the vendor delivered as a release? Ideally bit for bit, or at least with a documented difference such as a timestamp. If the answer is no, you do not have a product. You have a binary and some code that may or may not describe it. Run this test after the first month of the engagement, not after it ends.

The HIL test rig (hardware-in-the-loop) is a setup where the real device runs against a simulated environment: signal generators, sensor emulators, loads, network simulation, controlled power supplies. It is where you check, repeatably and in near-real conditions, that the firmware does what it should. When work is outsourced, the HIL rig plays a role nothing else can fill: it is your independent acceptance point. The vendor can report that tests pass. You check it yourself, on your own hardware, automatically for every release.

If the HIL rig belongs to the vendor and sits in its lab, you accept work based on its report. This is not an accusation of dishonesty. It is a matter of design: the person who does the work and the person who checks it should not share only one measuring instrument.

Does this mean the vendor cannot have its own rig? It can, and often should, so that its engineers do not queue for yours. The point is that the acceptance rig, where the decision to accept a release is made, is yours, and the tests running on it live in your repository. A copy of the rig at the vendor is a working tool. The original on your side is a control tool.

Signing keys are the third element. Devices with secure boot accept only images signed with the right key. Whoever holds the private key decides what can be installed on every device in the field. That key belongs in a hardware security module or key management service on your side, and signing should be a step in your release process, triggered by your people. The vendor gets development keys for prototypes, never production keys.

The release decision is the fourth element and the only non-technical one. A firmware release that goes to customers is approved by someone in your company, based on results from your rig. This is not a formality: under the Cyber Resilience Act, it is the manufacturer who answers for what has been placed on the market.

How should device testing be organised, from host tests to the HIL rig?

Embedded testing has several levels, and when work is outsourced each can be done by a different party. It is worth knowing who owns which level and where the automation runs.

Unit tests on the host. Logic that does not depend directly on hardware, such as sensor data processing, state machines and protocols, can be compiled and tested on an ordinary computer with the hardware layer stubbed out. These are the fastest and cheapest tests, so they should cover as much code as possible. Writing them belongs to whoever writes the code, including an external team. Their results should be visible in your CI on every merge.

Simulation (SIL) and emulator tests. The whole firmware, or a large part of it, runs in a processor emulator or a system model. This lets you test module integration without physical hardware and in parallel on many machines. It is particularly useful when prototypes are scarce and the team is large.

Hardware tests (HIL). A real device, a simulated environment, automated scenarios. This is where timing problems, interrupts, power consumption, behaviour under supply disturbances and interaction with real peripherals show up. It is the level at which the acceptance decision is made.

System, environmental and certification tests. Electromagnetic compatibility testing, temperature tests, tests in the customer’s target environment, testing at an accredited lab. These are usually run by the manufacturer or an external lab, not the firmware vendor. Their results come back to the firmware team as defects, though, so the contract should state how quickly the vendor responds to defects found at this stage.

Two principles matter for control. First, the higher a test sits in this pyramid, the more it should belong to you. The vendor can write and maintain unit tests. HIL scenarios and acceptance criteria should be yours, even if the vendor helps write them. Second, every level must be automated and triggered from your CI. A test that runs manually on a vendor engineer’s desk does not exist from the manufacturer’s point of view, because it cannot be repeated after the contract ends.

Hardware tests are expensive, so they cannot cover everything. Risk-based testing works well here: the most HIL scenarios go to the functions whose failure in the field would be the most expensive or dangerous, such as updates, power-loss handling and safety functions. Less critical functions can rely mainly on host and simulation tests.

Testing is also where external specialists deliver results fastest. A test automation engineer who builds a framework for HIL scenarios, or a system tester who prepares and executes a test plan, does not need months to learn the domain. When it makes sense to bring such people in and when to build the skills in-house is discussed in our article on in-house QA versus outsourced testing, and the scope of our services is on the software testing services page.

What does the Cyber Resilience Act change in a firmware contract from 11 September 2026?

Yesterday, 11 September 2026, the first hard obligations of Regulation (EU) 2024/2847, the Cyber Resilience Act, started to apply. Article 14 requires manufacturers of products with digital elements to report actively exploited vulnerabilities and severe incidents affecting product security. The remaining requirements, including the essential cybersecurity requirements and CE marking based on them, apply from 11 December 2027. A full walk-through of the regulation belongs in a separate article. Here we care about one thing: how the reporting obligation affects outsourcing firmware. If you are a US or UK manufacturer, this applies to you as soon as your devices are made available on the EU market.

The deadlines are short. After becoming aware of an actively exploited vulnerability, a manufacturer has 24 hours for an early warning, 72 hours for a notification with the information available, and 14 days after a corrective or mitigating measure becomes available for a final report. For severe incidents, the final report is due within one month of the notification. Reports go through the single reporting platform operated by ENISA to the CSIRT acting as coordinator in the member state of the manufacturer’s main establishment. According to law firm analyses, the obligation does not depend on when the product was placed on the market, so it also covers devices sold before 11 September 2026. The manufacturer should also inform users about the vulnerability and mitigations without undue delay.

What does this mean for the vendor contract? The obligation sits with the manufacturer. It cannot be passed to a subcontractor, but it can be missed if the subcontractor does not respond in time. A firmware vendor contract should therefore contain at least five elements.

Response time for vulnerability reports. Measured in hours, not business days, with on-call cover over weekends if your product requires it. A vendor that answers a report on Monday will not help you meet a 24-hour deadline that started on Saturday.

A duty to inform you. If the vendor learns of a vulnerability in a component it uses in your firmware, such as a network stack or a cryptographic library, it must tell you immediately, not at the next sprint review.

An up-to-date software bill of materials (SBOM). Without it you cannot check within an hour whether a newly announced vulnerability affects your devices. The SBOM should be generated automatically for every release in your build pipeline, not prepared manually by the vendor on request. What an SBOM is and how to maintain one is covered in our article on SBOM in 2026.

The ability to ship a fix without the vendor. If the vendor does not respond, has gone, or the contract has ended, your team must be able to build, test and sign a fix. This brings us back to the previous section: the toolchain, the HIL rig and the keys on your side are no longer just good practice but a condition for meeting the deadlines.

The support period. From December 2027 manufacturers will have to provide security updates throughout a declared support period, which the regulation sets as a rule at a minimum of five years, unless the product’s expected use time is shorter. A firmware contract signed today will be running during that period, so it is worth deciding now who will ship fixes, and on what terms, for years after development ends.

The practical conclusion for an engineering leader: review your current firmware vendor contracts against these five points. If any is missing, an amendment is cheaper than the first time the 24-hour clock is running and the person who knows the relevant module is on holiday at the vendor.

When do industry standards change the scope of the engagement?

Functional safety and cybersecurity standards affect an engagement only when they apply to your product. There is no point adding them to every contract “just in case”, because each one raises process cost. When they do apply, though, they must be in scope from day one, because adding them later means reconstructing documentation nobody kept. For medical devices, the process is covered in software as a medical device under IEC 62304 and the MDR.

ISO 26262 (automotive). The functional safety standard for electrical and electronic systems in road vehicles. Two things matter when outsourcing. The first is the development interface agreement (DIA), which defines who is responsible for which work products in distributed development. Without it, nobody knows who runs the safety analysis, who does verification and who does confirmation. The second is tool qualification: the standard requires an assessment of how far the tools used to build and verify software can be trusted. If the vendor uses its own tools, their assessment must be part of the documentation too. Alongside functional safety, automotive also has ISO/SAE 21434 for cybersecurity and UN Regulation No. 155, which requires vehicle manufacturers to run a cybersecurity management system that extends to suppliers.

IEC 62443 (industrial automation). A family of standards for the security of industrial automation and control systems. For product suppliers the key part is 4-1, which sets requirements for a secure development process: from defining security requirements, through design and implementation (including coding guidelines), verification and validation, to managing defects, patches and product end of life. The standard explicitly covers firmware. If your process follows IEC 62443-4-1, a vendor writing part of the firmware must work to the same rules, and you must be able to show that it does.

IEC 62304 (medical devices). The software lifecycle standard for medical device software, with safety classes A, B and C that determine the required documentation and verification. It is recognised in the EU under the MDR and by the US FDA. When outsourcing, note that it also covers software of unknown provenance (SOUP), so every component the vendor uses must be identified and assessed. If you build medical device software, specialists with MDR and IEC 62304 experience are described on our healthcare IT staffing page.

IEC 61508 (general functional safety). The base standard from which the sector standards derive, with safety integrity levels (SIL). It applies to many industrial devices that have no sector-specific standard.

MISRA C and MISRA C++ (coding guidelines). Not formal standards, but sets of rules for writing C and C++ that safety standards often require or recommend. The latest edition for C is MISRA C:2025, published in March 2025; for C++ it is MISRA C++:2023, which covers the language up to C++17. Three things matter when outsourcing: which edition applies to the project, which static analysis tool checks compliance, and how deviations from the rules are documented. Deviations are allowed, but each must be justified and approved. The contract should say who approves them: the vendor or you.

What these standards have in common is that they describe a process, and the process must be documented. So when outsourcing software covered by a standard, do not ask the vendor whether it “knows” the standard. Ask which work products it will deliver (verification plan, requirements traceability matrix, static analysis reports, review records) and in what format. That is the test that separates an experienced vendor from a vendor with a good website.

Standards also tend to assume a particular development model, with a clear path from requirements through design to verification at each level. How the V-model and its variants combine with iterative work is compared in our article on software development models.

Which vendor skills should you check, and how do you verify them before signing?

Embedded is an area where the gap between claims and skills is particularly wide, because the keywords on a CV (C, C++, RTOS, microcontrollers) look identical for someone who wrote a driver from scratch and someone who once changed a configuration in an existing project.

A technical interview should test things that cannot be learned from documentation in a week. How would the candidate design communication between an interrupt and an RTOS task so that no data is lost and the system does not block? How do they hunt a bug that appears once every few hours of device operation? How do they check stack and memory usage? Which tools do they use to debug on hardware: a JTAG or SWD debugger, a logic analyser, an oscilloscope? What would they do if the firmware image stopped fitting in flash two weeks before release?

Code review is a good test. Give the candidate or vendor team a piece of real code from your project (nothing secret) or a prepared snippet with a few hidden defects: a race between an interrupt and the main loop, a missing volatile, a buffer overflow, incorrect error handling from a peripheral. An experienced embedded engineer will find most of them in half an hour and explain why they are dangerous. Someone who knows C only from applications will comment on code style but miss the problems.

A paid pilot is the second test. Instead of signing a one-year contract, commission a well-defined task lasting a few weeks: a driver for a particular sensor, a library port, automation of one group of HIL tests. Acceptance criteria: code in your repository, builds in your CI, tests passing on your rig, documentation that lets another person continue. The pilot shows not only skills but also whether the vendor accepts your control rules. If during the pilot it pushes to work in its own repository and on its own rig, a long contract will not be different.

The third test concerns process, if the product is covered by a standard. Ask for sample, anonymised work products from earlier projects: a verification plan, a static analysis report, a MISRA deviation record. A vendor that genuinely worked in such a process has them to hand. A vendor that does not know it will start by asking what exactly you mean.

When choosing a staffing vendor, also ask the organisational questions: how quickly it delivers candidates, what happens if a specialist does not work out or leaves, how long the notice period is. In embedded this matters more than in web projects, because onboarding a new person onto specific hardware takes longer. Team turnover that is barely visible in a web application can stop firmware work for weeks. ARDURA’s specialist retention is 99% and its Clutch rating is 5.0/5 from 8 reviews, but whichever vendor you talk to, ask for these figures directly and request reference contacts.

How do you hand over hardware, prototypes and documentation so the external team is not left waiting?

The most common cause of delay in outsourced embedded projects is not technical. It is a team waiting for a prototype, a new board revision, an answer from the hardware engineer, or documentation for a part that has just changed.

A few rules shorten those stalls considerably.

A prototype plan alongside the work plan. How many units the external team needs, in which revision, by when. Prototypes break, so plan spares. If boards are expensive or unavailable, invest in microcontroller evaluation boards on which drivers can be developed before the target hardware arrives. When the team works across borders, factor in shipping times and customs paperwork for hardware, which can easily add a week or two per shipment.

Remote access to the rig. A HIL rig on your side does not mean the external team can use it only through you. A rig with remotely switchable power, network access to the debugger and a camera on the device display lets the team run tests on its own, while you keep control of the hardware, configuration and results. This reconciles two needs that at first look contradictory.

A hardware revision log. Every board revision with a list of changes that affect firmware: a different pin, a different part, a resistor value that changes a measurement. The firmware team learns about changes from the log, not from a bug that only appears on new units.

Documentation that lives in the repository. Hardware interface descriptions, memory maps and flashing procedures kept alongside the code in versioned files. Documentation in emails and on the vendor’s shared drives disappears with the contract.

One person responsible for the link between hardware and firmware. In many companies hardware engineers and firmware developers collaborate informally, sitting next to each other. When an external team writes the firmware, that informal collaboration disappears and needs to be replaced by something explicit: a regular meeting, a channel with a clear owner, a review of hardware changes.

These rules are simple, but they are worth writing down before the engagement starts. The first weeks of an embedded project with an external team decide whether the team is productive in month two or month five.

What should the contract cover: code rights, tools, keys and post-release support?

A contract for embedded software must cover more than a typical software development contract, because the product lives longer and the dependency chain is more complex.

Rights to the code and work products. Assignment of rights to the source code, but also to build scripts, tool configurations, test scenarios, documentation and helper tools the vendor wrote for the project. Without the latter, the code may turn out to be useless. Rules differ by jurisdiction: in the US, work by contractors is not automatically “work made for hire” and needs an explicit written assignment; several EU countries require the specific fields of use to be listed. A generic “all rights” clause may not be enough. How rights transfer works when you engage external specialists is covered in our article on who owns the code in staff augmentation.

Third-party components. The RTOS, communication stacks, cryptographic libraries, the microcontroller vendor’s libraries. Each has its own licence, and some carry commercial licences tied to a company rather than a project. The contract should require commercial licences to be bought in your name and open source components to be identified with their licences in the SBOM. A copyleft component introduced without your knowledge is a legal problem in a product sold for years.

Tools and their licences. Compilers certified for functional safety, static analysis tools, debuggers, test rig software. If the vendor bought them in its own name, after the contract ends you will not be able to build the firmware in the same configuration. Agree which tools you must own and from when.

Keys and update infrastructure. A clause stating that production keys are generated and held by the manufacturer and that the vendor has no access to them. A clause on development keys and their revocation when the engagement ends.

Vulnerability and incident handling. The five elements from the Cyber Resilience Act section: response time, duty to inform, SBOM, ability to ship a fix without the vendor, support period.

Post-release support and an exit plan. Who fixes defects after development ends, how fast and at what cost. How knowledge transfer works at the end: how many weeks, which materials, and which test confirms that your team can build, test and release the firmware on its own. How to secure knowledge, access and code before a specialist’s last day is described in our article on offboarding a contract specialist. In embedded, hardware (prototypes and rigs at the vendor) and development keys join that list.

With specialists in your team, many of these clauses are simpler, because everything is created in your systems from the start. That does not remove the need for clauses on rights and components, which apply to every form of engagement.

How do you measure progress and quality when you cannot see the team’s daily work?

Status reports in embedded projects can mislead. “Driver 90% done” may mean it runs on an evaluation board but nobody has started it on the target revision. It is better to measure things that can be checked automatically on your side.

Build results from a clean repository. Daily or per-change builds in your CI, with the tool versions recorded. If the build breaks, you know the same day, not at handover.

Test results at every level. The number and result of unit tests, simulation results, and HIL scenario results for each release. The trend matters most: is the number of passing HIL scenarios growing in step with features?

Resource budgets. Flash and RAM usage, peak stack usage, execution time of critical tasks, current draw in sleep modes. In embedded these are the indicators that can block a release, and they grow quietly. If they are measured on every build, the team sees an overrun immediately.

Coding rule violations. The number of static analysis violations, for example of MISRA rules, and the number of approved deviations. A rising count of new violations signals that quality is slipping under deadline pressure.

Defects found outside the team. How many defects your team finds on the acceptance rig, in system tests and at customers, compared with what the vendor finds itself. If most defects surface only on your side, the vendor’s tests are not doing their job.

All these indicators share one feature: they come from your systems, not from the vendor’s report. That is another reason why the build toolchain and the test rig must be on your side. Without them you have nowhere to get the data that would let you judge progress independently.

What does a checklist look like before outsourcing firmware?

The list below collects the decisions from the whole article, in the order in which they are worth making. Each item is a question that should have a concrete answer before you sign.

AreaControl questionGood answer
Engagement modelWho leads firmware technically on our side?A named firmware lead or architect
ScopeWhich layers do we outsource and which stay with us?A split matching the table: work outside, control inside
RepositoryWhere does the code live from day one?In our repository, with access for the vendor
Build toolchainCan we build a release without the vendor?Yes, in our CI, with recorded tool versions, verified after the first month
Acceptance rigWhere is the decision to accept a release made?On our HIL rig, with tests in our repository
KeysWho holds the production keys?Only us, in an HSM or key management service
StandardsWhich standards apply and which work products will we receive?A list of standards, editions and documents in the contract scope
VulnerabilitiesHow fast does the vendor respond, and do we get an SBOM for every release?Response time in hours, SBOM generated automatically
Components and licencesWho buys licences, and in whose name?Commercial licences in our name, open source in the SBOM
HardwareHow many prototypes, when, with what spares?A prototype plan aligned with the work plan
Support and exitWho ships fixes after development ends?A clause covering support for the product’s lifetime and a knowledge transfer plan
PilotHave we tested the vendor on a small task?A paid pilot accepted on our terms

The list does not need to be complete before you start talking to a vendor. Many answers are best worked out together. It does need to be complete before you sign anything longer than a pilot.

What are the key takeaways for an engineering leader?

Outsourcing embedded software is neither an exotic risk nor an ordinary development contract. It is a decision that requires separating work from control. The work, meaning drivers, RTOS integration, the application layer and test automation, can and often should be outsourced, because embedded skills are scarce and slow to build. Control, meaning the requirements, the toolchain, the acceptance rig, the keys and the release decision, has to stay with you.

Remember six things. First, check after the first month that your team can build from the repository the same release the vendor delivered. Second, the HIL rig where acceptance is decided must be yours, even if the vendor has its own copy. Third, production keys never leave your company. Fourth, since 11 September 2026 the contract must let you meet the Cyber Resilience Act reporting deadlines: response times in hours, an SBOM for every release and the ability to ship a fix without the vendor. Fifth, put industry standards into scope only when they apply to the product, but then from day one and with a list of work products. Sixth, start with a paid pilot that tests not only skills but also whether the vendor accepts your rules.

If you have a firmware lead in-house and need hands in their team, the simplest route is to add external specialists to your team through staff augmentation: developers, testers, test automation and CI engineers who work in your tools and on your rig. Tell us which profile you are looking for and which standards apply to your product. We will check whether we have a specialist with that experience and tell you plainly before you spend time on interviews.