Request a firmware review
Menu

Outsource firmware or hire: how hardware startups decide

Reader question: Should our startup hire its first firmware engineer, use a contractor or firm, or combine both, and what must we own whichever route we take?

Micrograph-style illustration of fungal threads wrapped around a fine plant root, with the fungal threads tinted amber.

Hire your first firmware engineer when firmware is what makes your product different and will need steady work for years. Outsource firmware development to a contractor or a firm when the work has a clear end, such as board bring-up, an update pipeline or factory programming, or when a date arrives before a hire could be productive. You can also combine the two: outside help builds the pieces that are done once while they recruit, then hands over. On every route, you must end up holding a signed copyright assignment for commissioned code, the repositories, the build environment, the signing keys, the provisioning scripts and the documentation.

That last list matters more than the staffing choice. Under US copyright law, software commissioned from a contractor is not a “work made for hire” by default, so the code belongs to whoever wrote it until a signed document says otherwise. Under the EU Cyber Resilience Act, the company that sells the product under its own name is the manufacturer, even when someone else designed and developed it.

A note on who is writing. Fumbar is a Denver firm that writes embedded firmware for hardware startups and builds the over-the-air update path that keeps it improving after devices ship. We sell one of the routes compared here, so we have given the case for hiring at least as much space as the case for outside help, and every question at the end applies to us too. Nothing here is legal advice.

Three routes, and what each one buys

You can get firmware written in three ways: hire an employee, engage an individual contractor, or engage a firm. A fourth, the combined route, uses outside help for a defined period while you recruit, then hands the work to your own engineer.

  • Employee. A person on your payroll whose work you direct. Code they write as part of the job belongs to the company, and you pay salary, benefits and payroll taxes whether the month is busy or quiet.
  • Individual contractor. A self-employed engineer who bills by the hour or by the deliverable. You get one person’s skills and one person’s availability.
  • Firm. A consultancy or product development company that sells engineering time or fixed-scope projects. You get several people, a process and some redundancy, with more coordination and a higher hourly cost than a single contractor.
  • Staff augmentation. A firm’s engineers working inside your team under your direction. Treat it like a hire when you think about knowledge, and like a contract when you think about ownership.

“Firmware” for a connected product is not one job. It is several pieces of work with different shapes, and the shape is a better guide to who should do each piece than any general rule about outsourcing.

Piece of work Shape When it happens
Board bring-up Bounded, repeats with each board revision Each time new boards arrive
Application firmware: sensing, radio link, power management Continuous For the life of the product
Bootloader, flash layout and update path Bounded, hard to change once units ship Before the first production run
Signing keys and release process Set up once, used at every release Before the first signed release
Factory test firmware and provisioning Bounded, revisited when the line changes Before the first production run
Maintenance and security releases Continuous For the whole support period

Continuous work leans toward a hire. Bounded work with a clear finish leans toward outside help. Every connected product has some of each, which is why the combined route exists.

When hiring your first firmware engineer is the better call

Hire when the firmware is the core of what your product does differently, when the feature work has no end date, and when someone must know the code well enough to answer for it at short notice for years. In our view, if two of those three are true, a hire is the right first move, even if outside help fills gaps.

The firmware is the product

If what customers pay for lives in the firmware, the knowledge is the asset. That might be a sensing algorithm, a motor control loop, or a power budget that gives a battery life competitors cannot match. Every month an outside engineer spends learning it is learning that leaves when the contract ends.

An employee’s understanding compounds inside the company. Their code, written as part of the job, belongs to the company without a separate transfer, and their judgment about the next feature is shaped by everything they learned building the last one.

The work never ends

Some products need firmware releases every month or two: new sensor modes, features the app team asked for, support for a new gateway. Continuous feature work fits a salary better than a contract, because re-explaining context to an outside team at every milestone has a cost that never shows on an invoice.

A quick test: write the next 12 months of firmware work as a list. If most lines are features rather than one-time infrastructure, you are describing a job, not a project.

Hardware and firmware change together

During engineering and design validation testing (EVT and DVT), board revisions can arrive in quick succession, and many bugs sit on the line between hardware and code. An engineer at the bench beside your hardware engineer, with the board and the oscilloscope in hand, closes those loops in an afternoon. Remote outside help can do this work too, but someone has to ship boards back and forth, and detail gets lost in writing.

Someone must answer for the code for years

Firmware support periods are long. The Zephyr Project maintains each Long Term Support release “for approximately 5 years after it was released” (Zephyr releases, checked November 2026). FreeRTOS LTS libraries receive security updates and critical bug fixes for two years, and the 202604 LTS libraries are listed as supported until April 30, 2028 (FreeRTOS-LTS).

Regulation stretches that further. For products in scope of the EU Cyber Resilience Act, the support period “shall be at least five years” unless the product is expected to be used for less time (Regulation (EU) 2024/2847, Article 13(8)). Since September 11, 2026, Article 14 has also required an early warning within 24 hours of a manufacturer becoming aware of an actively exploited vulnerability.

An employee who knows the code is the most direct way to have someone answerable for that long. A firm can do it under a sustaining agreement, but only if the agreement says so.

What hiring costs you besides salary

  • Time to start. We know of no reliable public figure for how long a firmware search takes. Budget from your own recruiting pipeline, then add time for the new engineer to learn your boards.
  • One person is a single point of failure. If your only firmware engineer leaves, the knowledge leaves too, unless it was written down. Hiring does not remove the need for documentation; it only changes who writes it.
  • The first hire must cover everything. Bring-up, drivers, the RTOS, the radio stack, the bootloader, security, factory programming and releases. Few engineers are strong in all of them, so hire for your core and plan outside help for the edges.
  • Evaluation is hard without firmware skills on the team. Ask an experienced firmware engineer you trust to join the technical interview, or set a short exercise on your own hardware.

When outsourcing firmware development is the better call

Use outside help when the work has a defined end, when a date arrives before a hire could be productive, or when the job needs a specialty you will use once or twice per product. Outside help also fits when one overloaded engineer needs the bounded pieces taken off their desk.

Bounded pieces of work

Bring-up of a new board revision, the update pipeline (bootloader, flash layout, signing in CI, rollback tests), factory test firmware and device provisioning, and test firmware for a radio certification lab all have a clear finish. Each is done once or rarely per product, and each needs knowledge a first hire may not have yet. Paying for it as a project avoids hiring for a skill you will next need in two years.

A date you cannot move

A pilot with a paying customer, a contract manufacturer’s production slot or a certification lab booking may land before you could hire and onboard someone. In that case outside help is the only way to have firmware on the date. Be honest about whether the date is real, because a firm hired for speed still needs time to learn your product.

A review before decisions harden

Some firmware decisions are hard or risky to change after units ship: the bootloader, the flash layout, and the public key the bootloader trusts. A short outside review of the schematics, code and update plan before the first production run is cheap insurance, whoever writes the firmware afterward. Our article on moving from prototype code to production firmware covers which of those decisions to settle first.

Contractor or firm

An individual contractor means less coordination and a direct line to the person writing your code. The risks are one person’s availability, their other clients and the absence of any process behind them. A firm gives you several people, internal review, and continuity if one engineer leaves. The cost is overhead per hour and the risk that the people assigned to you change. With either, ask exactly who will write your code.

What outside help costs you besides the invoice

  • Knowledge leaves at the end unless it is written down, recorded and taught to someone on your side.
  • Incentives differ by contract type. Time-and-materials work pays for hours, not outcomes. Fixed-scope work moves estimate risk to the firm but makes every change a negotiation.
  • Your priorities compete. An outside team serves several products, so your urgent bug may wait behind someone else’s.
  • Ownership does not move by itself. The next chapters explain why, and what to collect.

Comparing the routes on time, continuity, cost and knowledge

No route wins on every criterion. Hiring wins on continuity and knowledge once the person is in place, outside help wins on time to start and on cost visibility for bounded work, and the combined route pays two cost lines for a while to get both.

CriterionHire an employeeIndividual contractorFirmCombined route
Time to first production firmwareRecruiting time, then ramp-up on your boardsStarts when the contract is signed, if the person is freeStarts when the contract is signed; several people can work in parallelOutside work starts at once while recruiting runs alongside
ContinuityStrong while the person stays; weak if they leave without notesDepends on one person's availabilitySurvives one engineer leaving, if the firm documentsBuilt in, if the handover is a real step with a release
Cost visibilityFixed monthly cost; output variesHourly bills; the total depends on estimatesFixed price per deliverable, or hourlyTwo cost lines for a defined period
Knowledge riskHeld in one head unless written downLeaves with the contractorHeld by the firm unless handed overMoves to your hire through a planned handover
Best fitCore, continuous firmware workSmall, bounded tasks with an owner on your sideBounded projects, specialist pieces, fixed datesStartups that need firmware before they can hire
Figure 1. Four routes to production firmware compared on the criteria used in this article. Fumbar's judgement from the definitions above, not survey or market data.

Time to first production firmware

A hire produces nothing until the search ends and the new engineer has learned your boards, toolchain and product. Outside help can usually start as soon as a contract is signed, but it also has to learn your product, so the first weeks are slower than the invoice suggests. The combined route runs both clocks at once.

Put every quote in months of a hire

Cost is easier to compare once both routes are in the same unit. The federal occupation list has no firmware engineer title, so the nearest occupation with BLS wage data is software developers, whose median annual wage was $135,980 in May 2025, and $136,330 in manufacturing (BLS Occupational Outlook Handbook, May 2025 data, checked November 2026).

Salary is not the whole cost. In June 2026, wages and salaries were 69.2% of employer compensation costs for private industry workers in professional and related occupations, with benefits making up the other 30.8% (BLS Employer Costs for Employee Compensation, Table 4, released September 9, 2026). Dividing the median wage by that share gives a rough loaded cost of about $196,500 a year, or about $16,400 a month.

That is an approximation: it uses a national median, an average benefit share across professional jobs, and leaves out recruiting costs, equity, equipment and the months before the hire is productive. It is still a useful yardstick. Divide any outside quote by about $16,400 to express it in months of a hire, then ask whether your hire would finish the same work in that many months, alongside everything else on their list.

For example, suppose a fixed-scope quote for an update pipeline comes to three months of a hire. If your hire would need four months to learn and build it, the quote is cheaper. If the work is a feature your hire will extend every quarter, the hire is still the better owner, whatever the arithmetic says.

Continuity and knowledge risk

Every route has a “what if this person disappears” problem. The cure is the same on all of them: documents in the repository that change with the code, recorded walkthroughs, runbooks that someone other than the author has followed, and a release shipped by a second person. Our page on documentation and onboarding lists the documents we write for that reason.

The combined route: build outside, hire inside, hand over

The combined route uses outside help for the pieces done once, recruits in parallel, and ends with a planned handover in which your new engineer ships a release unaided. It costs more for a few months and reduces the risk that the code outlives the people who understand it.

Week 12345678 After launch Firmware review Bring-up, Rev C Application firmware Update pipeline Field trial, v1.0.0 Maintenance releases First firmware hire Team handover 40 probes, 4 gateways 1.0.2, 1.1.0 pairing Outside team Startup's field trial New hire Handover signed off
Figure 2. The combined route in the site's fictional example: outside work on the bounded pieces, a field trial in week 8, then maintenance releases while the first firmware hire pairs with the outside team. Fictional example data from the Loamwick example project; the weeks after launch are not to scale.

The route works best as a sequence with named steps:

  1. Review first. Have someone read the board, the code and the update plan, and sort the work into bounded and continuous pieces.
  2. Build the bounded pieces in your repository. The outside team writes the bootloader setup, update path, factory programming and first application firmware, while your founders own product decisions.
  3. Start recruiting once the architecture is settled. The hire then inherits decisions with written reasons, rather than arriving in the middle of a debate. If you can, involve a finalist in one architecture review so they can object early.
  4. Pair the hire on real work. A bug fix, then a small feature, then a clean build from a fresh checkout, then a release candidate through CI.
  5. Finish with a supervised release. The new engineer tags, builds, signs and rolls out one release while the outside team watches without touching.
  6. Close the accounts. Sign off the handover checklist and remove outside access from every system. Keep outside help afterward only for named specialist pieces or scheduled maintenance releases, if you want it at all.

Example (fictional). Loamwick is a two-founder Denver startup with one contract hardware engineer, building the LW-1 soil probe. A firmware review happens in week 1, Rev C boards are brought up in weeks 1 and 2, application firmware is written in weeks 2 to 6, and the update pipeline is built in weeks 4 to 6. The field trial of 40 probes and 4 gateways starts in week 8 on v1.0.0. After the first maintenance release, v1.0.2, version 1.1.0 fixes moisture readings that drifted upward after 30 days in wet clay and goes out in waves of 4, 12 and 24 probes with 48 hours between waves. Near the end, Loamwick hires its first firmware engineer, who pairs on the release process and then ships a release while the outside team watches. The engagement ends with a team handover. The full story is in the example project.

Plan against two failure modes. The first is a handover that is only a meeting, after which the new hire discovers the build only works on the contractor’s laptop. The second is an outside team that makes choices the hire would not have made, with no written reasons. A supervised release prevents the first, and written decision records prevent the second.

Who owns the code: work made for hire and written assignments

Code an employee writes as part of the job belongs to the company. Code a contractor or firm writes belongs to its author until a signed written document transfers it, because commissioned software is not one of the categories US law allows to be labeled a work made for hire.

What the statute says

The Copyright Act defines a “work made for hire” in 17 U.S.C. 101 as either “a work prepared by an employee within the scope of his or her employment” or a work “specially ordered or commissioned” in one of nine listed uses, “if the parties expressly agree in a written instrument signed by them”. The nine are a contribution to a collective work, part of a motion picture or other audiovisual work, a translation, a supplementary work, a compilation, an instructional text, a test, answer material for a test, and an atlas. Firmware written to order is not on that list.

The Copyright Office’s Circular 30 sets out four conditions a commissioned work must meet: it falls in one of the nine categories, there is a written agreement, the agreement expressly says the work is made for hire, and all parties sign it. “If a work fails to satisfy any of these requirements, it is not a work made for hire.”

When a work is not made for hire, 17 U.S.C. 201(a) applies: copyright “vests initially in the author or authors of the work.” Moving it to your company then needs a transfer, and under 17 U.S.C. 204(a) a transfer “is not valid unless” it is in writing and signed by the owner of the rights. A contract for commissioned firmware therefore needs an express, signed assignment of copyright. A work-made-for-hire clause on its own may not do what founders expect.

Employees, founders and code written before the company

For employees, Circular 30 notes that the Supreme Court reads “employee” and “scope of employment” in light of the general common law of agency. Code written on the job, on company equipment, as part of the engineer’s normal work is the clear case. Weekend projects and code written before the job started are less clear.

Founders deserve a separate check. Firmware a founder wrote before the company existed, or before becoming its employee, was not written within the scope of employment by that company. Ask your lawyer whether each founder has signed an assignment that covers it.

Example (fictional). Ridgeline Instruments, a fictional robotics startup, runs prototype firmware that one founder wrote as a side project before incorporating. A contractor later added the motor driver code under a statement of work that called the deliverables “work made for hire” but contained no assignment. When Ridgeline’s lawyer prepares for a funding round, she asks for two documents: an assignment from the founder covering the pre-company code, and an assignment from the contractor covering the motor driver. Both are easy to sign while everyone is still friendly, and much harder later.

Patents, reused code and open source

Copyright covers the code as written. An invention inside it, such as a new way to filter a sensor signal, is a patent matter, and under 35 U.S.C. 261 patents and applications “shall be assignable in law by an instrument in writing.” An invention assignment clause in employment and contractor agreements covers this; check that yours has one.

Firms and contractors may bring code they wrote before your project, such as drivers, build scripts or test harnesses. Expect a license to that background code rather than ownership, unless the agreement says otherwise. Check that the license is perpetual, irrevocable, free of royalties, allows modification, and survives a sale of your company.

No contract can assign code the contractor does not own. Open-source components and chip vendor SDKs stay under their own licenses, so ask for a list of every third-party component with its license and version, and keep it current with each release.

These are US rules. A contractor in another country may be subject to different copyright and employment law, so get local advice before you sign. This chapter describes the statute and the Copyright Office’s guidance; it is not legal advice.

Owning the copyright is not the same as being able to build, sign and ship the firmware. You also need the repositories with their history, a build that works from a fresh checkout, the signing keys, the update and cloud accounts, the factory provisioning material and the documentation, all held in your company’s name.

Item Why it matters How to check it is yours
Source repositories with full history History explains why the code is the way it is They sit in your organization, and outside people are members you can remove
Build environment Code you cannot build is code you cannot fix Someone new builds from a fresh checkout with the written instructions and pinned compiler and SDK versions
CI pipeline Releases that depend on one laptop stop when its owner leaves It runs under your account and your billing
Production signing keys Whoever holds the private key decides what every unit will run The key was created in your cloud key service or hardware security module
Update service and cloud accounts They are the only path to devices already in the field Your company is the account owner and holds the admin roles
Factory provisioning scripts and records They give each unit its identity and credentials Scripts are in your repository; credentials and unit records are in your accounts
Vendor tools and SDK licenses Some are licensed to a company or a named user Licenses and portal accounts are registered to your company
Documentation Architecture, release runbook, hardware notes and open issues Someone who did not write it has followed it successfully
Test fixtures and hardware-in-the-loop rigs Tests that only run on someone else’s bench are not your tests The rig and its scripts are at your site or on their way

The signing key deserves its own line in every contract. MCUboot, an open-source bootloader for microcontrollers, ships with a development key for testing. Its imgtool documentation warns that because “this private key is widely distributed, it should never be used for production.” The production key should be created in an account your company controls, by a named person, with a written record. Our article on firmware signing key management covers storage, rotation and what to do if a key is lost.

The free handover checklist turns this table into 15 items in four groups (code and builds, documents, keys and accounts, people) that both sides sign off. It works for a firm leaving, a contractor leaving, or an employee changing roles.

Regulation follows the name on the product

Outsourcing firmware does not outsource legal duties. Under the EU Cyber Resilience Act, the manufacturer is the company that markets the product under its own name, even when others designed and developed it, and that company carries the support, update and reporting obligations.

The CRA’s definition of manufacturer

Article 3(13) of Regulation (EU) 2024/2847 defines a manufacturer as a person “who develops or manufactures products with digital elements or has products with digital elements designed, developed or manufactured, and markets them under its name or trademark”. Article 13(16) requires the manufacturer’s name or trademark and contact details on the product, its packaging or an accompanying document. If your logo is on the box, the duties are yours, whoever wrote the code.

The duties that outlast any contract

The obligations that matter most for staffing are the long ones:

  • Support period. At least five years, unless the product is expected to be used for less time (Article 13(8)).
  • Security updates stay available. Each one remains available for at least 10 years after it is issued, or for the rest of the support period if that is longer (Article 13(9)).
  • Technical documentation. Kept for at least 10 years after the product is placed on the market, or for the support period if that is longer (Article 13(13)).
  • Reporting. Since September 11, 2026, an early warning within 24 hours of becoming aware of an actively exploited vulnerability, and a fuller notification within 72 hours (Article 14).

The CRA entered into force on December 10, 2024, and its main obligations apply from December 11, 2027, according to the European Commission’s CRA page (checked November 2026). Whichever route you choose, write down who will produce security fixes for five years and who can be reached within 24 hours. Our guide to what the Cyber Resilience Act requires of device startups covers scope, timelines and reporting in detail.

A US reference for contracts: the SSDF

In the US, NIST’s Secure Software Development Framework, SP 800-218 version 1.1 (February 2022), is a practical checklist for agreements with outside developers. As of November 2026, its Revision 1 (SSDF version 1.2) is listed only as an initial public draft from December 17, 2025. Four tasks in version 1.1 map directly onto an outsourcing contract:

  1. PO.1.3: communicate security requirements to third parties that provide software components, for example by including them in “software contracts, and other agreements with third parties”.
  2. PO.2.1: define roles and responsibilities across the development life cycle; the practice it belongs to covers everyone “inside and outside of the organization” who takes part.
  3. PS.1.1: store all forms of code “based on the principle of least privilege”, so access can be granted and removed.
  4. PS.3.1: securely archive the files and integrity data “to be retained for each software release”.

None of this is legal advice. It shows where the law and NIST’s framework put the responsibility, which is with you.

Writing the agreement and running the work

A firmware agreement should define what done means, put code and keys in your accounts from the first day, transfer ownership in writing, and say how the work ends. Running the work well then comes down to written status, reviewed changes and an exit you have rehearsed.

Terms to put in writing

  1. Scope and acceptance. List the deliverables and the tests that define done for each, such as a release candidate that passes the agreed tests on the agreed board revision.
  2. Where the work lives. Code goes into your repository from the first commit, under your organization, with access you can revoke.
  3. Ownership. An express assignment of copyright in everything written for you, an invention assignment, and a license to any background code with the terms listed above.
  4. Third-party code. A rule that every open-source or vendor component is recorded with its license before it is merged.
  5. Keys and accounts. Production keys, update services and cloud accounts created in your name, with outside people holding only the roles they need.
  6. Reporting. A written status every week and a report after every release.
  7. Support. Who fixes security bugs during and after the engagement, how quickly they respond, and for how long.
  8. Exit. Notice periods, the handover deliverables, a supervised release, access removal and a follow-up period for questions.

The firmware requirements worksheet is a useful starting point for the scope and acceptance terms, because it forces the requirements to be testable.

If you engage an individual contractor

The IRS says evidence of control and independence falls into three categories: behavioral, financial and type of relationship. Its relationship questions include “Will the relationship continue and is the work performed a key aspect of the business?” (IRS, page last reviewed May 19, 2026). A contractor who works full time, on your schedule, on your core product, for an open-ended period may look more like an employee. Ask an accountant or lawyer before that arrangement settles in.

Running the work week to week

Ask for a short written status every week: what was done, what was measured, what is blocked and what is next. Have every change reviewed, by your own engineer if you have one, or by a second outside engineer if you do not. And rehearse the exit early: once a quarter, have someone outside the team build and flash the firmware from the written instructions. Our method page shows how we structure status reports and releases.

Questions to ask any firm, Fumbar included

Ask questions whose answers you can check: where the code and keys live, who writes the code, what you receive at the end, and how the engagement ends. Vague answers to any of these are a reason to keep looking.

For a firm or contractor

  1. Will the code be in our repository from the first commit, and can we see the history at any time?
  2. Who exactly will write the code, and what happens if that person leaves your firm?
  3. Where will the production signing key be created, and will you ever hold the only copy?
  4. Does the agreement assign copyright in writing, and what background code are you licensing to us instead?
  5. How do you record third-party and open-source components and their licenses?
  6. What will we receive at the end, item by item?
  7. How do you prove the update path works: interrupted downloads, power loss during the swap, wrong keys, rollback?
  8. What does your weekly status contain, and may we see a blank template?
  9. How does the engagement end, and will our engineer ship a release before you leave?
  10. If a vulnerability is found two years after launch, who fixes it and under what agreement?

For a candidate first hire

  1. Which parts of a product’s firmware have you owned from bring-up to field release?
  2. How have you updated devices that were already in customers’ hands?
  3. How do you keep a build reproducible after the person who set it up leaves?
  4. What would you want to see in our repository in your first week?
  5. Which parts of our firmware would you want outside help with, and why?

Our answers, for the record

Fumbar’s engagements work like this: code lives in your repository from the first day; production keys are created in your account and we never hold the only copy; one named technical lead writes a weekly status in plain English; and a handover ends with your engineer shipping a release while we watch. You receive the source code, build instructions, signing setup and documentation, and the ownership and licensing terms are set out in each agreement. The engagement types page lists what each kind of engagement delivers and how it ends.

What to do this week

You can make most of this decision in a week of evenings, with a list, a lawyer’s half hour and an honest look at your next twelve months.

  • List the next 12 months of firmware work and mark each line bounded or continuous, and core or not core. Continuous core work is a job description.
  • Check ownership today. Find the signed assignments from every founder and contractor who has written code. If any are missing, get them signed now.
  • Inventory keys and accounts. Confirm that repositories, CI, signing keys, update services and vendor portals are in the company’s name.
  • Write down your support period and who will produce security fixes for it.
  • Decide the route and, if it includes outside help, the date and the release that will mark the handover.

If you are a seed or Series A team going from prototype boards to a first production run, our page for hardware startups covers the decisions that come with that step. If you want an outside read before you choose, request a firmware review: we read the schematics, the code and the update plan, and you receive a written plan you can use with us, with another firm or with your own hire.

Facing this decision on a real device?

If this article describes a choice in front of you, a firmware review puts it in writing for your board, your code and your update plan.

Request a firmware review

Or email sales@fumbar.com, or call (720) 675-4202.