The hire looked excellent on paper and the reference calls were warm. Eleven weeks later we had a device that worked on a bench and failed intermittently in a warm room, two board revisions chasing a fault that turned out to be in software, and an engineer who had genuinely never had to make something survive a year on a battery. Nobody had been dishonest. Our interview had tested whether he could write C, and the job required something else entirely. This is the screen I use now, and the first step is the one that would have saved all eleven weeks.
Step 1: Write the Constraint, Not the Stack
Almost every firmware job description in this market is a list: a chip family, a real time operating system, two or three wireless protocols, a debugger. That list attracts people who match keywords and tells you nothing about whether they can solve your problem, because in this discipline the stack is the easy part to learn and the constraint is the hard part to have lived with.
So write the constraint. There are usually four or five that bind a product, and you probably know which one is yours: a power budget that has to deliver a stated battery life, a memory ceiling on a part you chose for unit cost, a real time deadline measured in microseconds, a certification target, or a bill of materials that cannot move. One sentence naming yours will do more for your shortlist than a paragraph of acronyms.
The test for whether you have written it honestly: could a candidate disagree with it. “Experience with low power design” is not a constraint, it is a category. “The device has to run eighteen months on a coin cell while waking for a reading every ten minutes, and we are currently getting nine” is a constraint. Engineers who have solved that read the second version and recognise their own last two years. They do not read the first version at all.
Our expert take
The reason this matters more in firmware than in web hiring is the shape of the pool. When there are three thousand plausible backend candidates in the market, a vague description is inefficient but survivable, because volume compensates. When there are perhaps a few dozen people in Singapore who have shipped a certified low power device, a vague description does not produce a worse shortlist, it produces no shortlist. Specificity is the entire sourcing strategy at this end of the market.
Step 2: Separate Firmware From Hardware and From the App
The second failure is scope. A connected product needs three distinguishable skill sets: somebody who designs and brings up the board, somebody who writes the firmware that runs on it, and somebody who builds the phone or web application that talks to it. Job descriptions routinely ask for all three, usually because the company genuinely needs all three and has budget for one.
The people who can do two of the three well exist and are worth paying for. The people who can do all three at a level you would stake a product on are rare enough that building a hiring plan around finding one is not a plan. More importantly, the merged role has no success condition: at the end of the quarter, was this person supposed to have a working board, stable firmware, or a shipped app.
Decide which risk is largest and hire against that, then name what you are buying differently. In our experience the most common correct answer for a first hire on a connected product is firmware, with board design contracted to a specialist and the companion application built by the team you already have. If you are sizing the whole build rather than one role, our guides to building an IoT platform in Singapore and what an IoT platform costs to build cover how those three workstreams interact, and our embedded systems hiring page covers the role profiles.
Step 3: Screen Debugging Method, Not Language Syntax
Firmware interviews that test C syntax select for people who revised. The work is not writing code, it is finding out why a system that should work does not, usually with very little visibility into what it is doing.
So ask for the hardest bug they have found, and then stay quiet long enough for them to tell it properly. I am listening for four things. What made it hard, which should involve either nondeterminism or an invisible boundary between software and the physical world. How they narrowed it, which should involve instrumentation, bisection and a deliberate attempt to make the fault reproducible before trying to fix it. What tools they reached for, which at this layer means a logic analyser, an oscilloscope, a current probe, a debugger that halts without changing timing, sometimes a thermal chamber. And the moment they stopped trusting an assumption, which is the part that only happens to people who have actually been there.
The clearest negative signal is a candidate whose hardest bug was a logic error in application code. That is not a criticism of them, it is evidence about which layer they have worked at. The second clearest is somebody who describes a fix without ever describing a measurement, because at this level a fix you cannot measure is a coincidence you have not caught yet.
Step 4: Test Interrupt and Concurrency Reasoning
This one is a whiteboard exercise and takes ten minutes. Describe a shared buffer: an interrupt service routine writes sensor readings into it, the main loop reads them out and sends them somewhere. Ask what goes wrong.
There is a lot to find, and the order in which a candidate finds it is informative. A read that spans an update produces a torn value, so you need atomicity or a design that avoids the need for it. The compiler may cache a variable in a register and never observe the interrupt’s write, which is what volatile is for and also what volatile is not sufficient for. A multi-byte value on an eight bit part is not atomic at all. Disabling interrupts around the read is correct and has a cost measured in missed events, which is a trade-off to state rather than a fix to apply silently. A ring buffer with a single producer and a single consumer avoids most of this, and knowing why is the mark of someone who has designed rather than copied.
Candidates who have done real time work also tend to raise what you did not ask: how long the handler runs, what else it blocks, whether priority inversion is possible, and whether the main loop can starve. You are not looking for every item on this list. You are looking for whether they reason about it as a system with a time dimension, or as code that executes in the order it is written.
Our expert take
We keep this question even when the panel is not deeply embedded, because the answers sort themselves. A candidate who talks about torn reads, compiler reordering and the cost of disabling interrupts is unmistakably different from one who suggests adding a mutex and moving on, even to an interviewer who could not have produced the strong answer themselves. The usual objection is that this is textbook material and therefore revisable. In practice the textbook answer stops at volatile, and everything past that point comes from having shipped something that failed once a week in the field.
Step 5: Check Field Update and Recovery Discipline
Here is the question I would keep if I could keep only one. A device is already in a customer’s hands, somewhere you cannot reach. It is halfway through an over the air firmware update when power is lost. What happens, and what does recovery look like.
The strong answer arrives as a sequence of precautions, and it usually leads with the failure rather than the happy path. A dual bank layout, so the image being written is never the image currently running. Verification of the new image, by checksum or signature, before anything switches. An explicit, atomic commit of which bank is active. A watchdog, and a rollback that triggers if the new image fails to check in. A bootloader that is deliberately small, deliberately boring, and updated almost never, because the bootloader is the one thing that cannot be recovered remotely. And then the honest part: a frank statement of what remains unrecoverable, and what that implies for warranty and support.
Candidates who have only built prototypes and demonstrators describe the update working. It is not that they are careless, it is that they have never had the conversation where somebody asks how many units are bricked. If your product is going into the field, this question is the difference between a hire who costs you a sprint and a hire who costs you a recall.
Step 6: Set a Take-Home That Fits on a Desk
Firmware take-homes are logistically awkward, which is why most teams skip assessment entirely and over-weight the interview. There are two workable options.
If you can ship hardware, send a commodity development board and a two hour task with a measurable outcome: read a sensor at a fixed interval, sleep between readings, report the current draw you achieved and how you measured it. The deliverable you actually care about is the measurement and the reasoning, not whether the code is elegant. An engineer who reports an honest figure with the method and the uncertainty is telling you how they will report a schedule.
If you cannot ship hardware, which is common and reasonable, use a written design response instead. Give the real constraint from step 1 and ask for one page: the approach, the three things they would measure first, and what they would need from you before committing to a number. Score the stated unknowns above the proposed solution. In our experience the strongest responses are the ones that refuse to commit to a figure and explain precisely what would make the commitment possible, which is also what the first month of the job looks like.
| Step | What you are testing | Strong signal | Decline signal |
|---|---|---|---|
| 1. Constraint | Your clarity, not theirs | A candidate could disagree with it | A list of chips and protocols |
| 2. Scope split | Whether the role is fillable | One workstream, named trade-offs | Board plus firmware plus app |
| 3. Debugging | Method under low visibility | Instrumentation before fixing | Hardest bug was a logic error |
| 4. Concurrency | Reasoning with a time dimension | Torn reads, reordering, cost of masking | Add a mutex and move on |
| 5. Field update | Whether they have shipped | Leads with the failure path | Describes the update succeeding |
| 6. Take-home | Honest measurement | Reports method and uncertainty | A number with no method |
| 7. First 90 days | Whether the role can function | A bring-up milestone met | Blocked on hardware all quarter |
Not sure whether you need firmware or hardware first
Tell us what your device has to do and whether the board exists yet, and we will tell you honestly which of the three workstreams is your real bottleneck.
Start the conversationStep 7: Measure the First 90 Days Against the Bring-Up
Before the start date, write down two things the hire is expected to have done by day ninety. For firmware these are almost always one bring-up milestone and one measurement: the sensor path reading reliably on the current board revision, and a documented power figure with the method that produced it.
Write them down because the alternative is a review conversation in which everyone has a different memory of what the quarter was for. Hardware schedules slip for reasons that have nothing to do with your new engineer, and without a written milestone that slippage silently becomes a performance question about the wrong person.
If nothing has moved at ninety days, diagnose before you judge, because there are two very different causes. Either the screen was wrong, which is recoverable if you act now rather than at the annual review. Or the hardware schedule is the actual blocker and your firmware engineer has spent a quarter waiting for a board, in which case the fix is procurement and planning, and the worst available response is to question the hire. The second cause is more common than the first, and it is the reason the milestone should be written jointly with whoever owns the hardware timeline.
Where This Method Stops
Three limits, stated plainly.
- Screening is not the bottleneck, sourcing is. This method makes your few conversations count, and it does not create candidates. For a role this thin, expect to work referrals, hardware communities and people currently employed at companies winding down a product line, and expect the search to take longer than a comparable backend hire.
- Not every connected product needs this hire. If you are building a product around an off the shelf module with a vendor SDK, and your differentiation is in the application, an experienced application engineer plus vendor support may carry you to market. The threshold where dedicated firmware pays for itself is custom hardware, a hard power or timing constraint, or a certification target.
- It does not fix a hardware schedule. The most common reason a firmware hire looks unproductive is that the board is late. If your hardware timeline is uncertain, hire later or scope the first ninety days around a development board rather than the real product, and say so at offer stage rather than discovering it together in month two.
Frequently Asked Questions
Why is an embedded firmware engineer so much harder to hire than a backend engineer in Singapore?
Should I hire a firmware engineer or an electronics engineer who can code?
Can this role be done remotely or does it have to be onsite?
What single interview question gives the most signal if I only have time for one?
Run this screen on a real shortlist
We help Singapore employers scope embedded roles against the constraint that is actually binding, and we will tell you when an application engineer plus vendor support is the better answer.
Get startedRelated reading: Embedded systems engineers · Building an IoT platform in Singapore · What an IoT platform costs
