Useful Resources

First-hand experiences

This is from talking with a friend that has recently gone through a 5 months long interviews with many companies, mostly embedded role.

Fist, even for embedded roles, a lot of companies still require Leetcode, especially traditional “web companies” like Meta, Google, etc. However, this is not true for all the companies, many companies do so-called “practical programming”, for embedded, especially on C/C++ (Some even ask for assembly!!).

Leetcode

Mostly focus on easy/medium questions

Practical C/C++ coding:

  • Design a Ring buffer (memory barrier). – And what are the use cases of ring buffer
  • Design lock free Queue (SPSC)
  • Design a fixed size memory pool without the alloc/free overhead (I got asked last year and failed :( )
  • Basic C pointer manipulations
  • Design a shared pointer
  • Design thread pool

Some other thoughts generated by AI which I think makes sense:

  • Implement a state machine framework
  • Design a timer wheel / hierarchical timer system
  • Implement a simple memory allocator (first-fit, buddy system)
  • Write a circular DMA buffer driver
  • Implement a priority queue without heap allocation

System Design

Depends on your role, but the following are “general” embedded design questions.

  • Design a camera (e.g. wireless) streaming pipeline
  • Design logging system
  • Debug performance bottlenecks of a system
  • Design an OTA (over-the-air) firmware update system

And below from AI :)

  • Design a real-time task scheduler (priority-based preemptive)
  • Design an inter-process communication (IPC) framework for an embedded OS
  • Design a power management subsystem (sleep states, wake sources)
  • Design a sensor fusion pipeline (e.g., IMU + GPS)
  • Design a bootloader with secure boot chain
  • Design a watchdog and fault recovery system
  • Design a CAN bus / UART protocol stack
  • Design a display rendering pipeline (framebuffer, vsync, double buffering)
  • Design a DMA-based data transfer system

Common domain knowledge

Interviewers for embedded role tend to ask the following domain knowledge questions:

  • Describe the boot up process. What are the differences between a server and mobile device?
  • Common security measures in embedded system. e.g. Secure boot, DRM, fuzzing, etc.
  • Linux kernel (e.g. memory management, page size selection)
  • Cache system
  • File system, a classic question is what happens from user space to kernel when you write to a file/device.

From AI:

  • Interrupt handling (top half / bottom half, latency, nesting, priority inversion)
  • DMA — how it works, cache coherency issues with DMA buffers
  • Memory-mapped I/O vs port-mapped I/O
  • Virtual memory vs physical memory in embedded Linux (MMU, TLB)
  • Power states (suspend/resume, clock gating, voltage scaling)
  • Real-time constraints (WCET, priority inversion, priority inheritance)
  • IPC mechanisms (shared memory, message queues, signals, pipes)
  • Device tree — what it is, how the kernel uses it to probe drivers
  • Linux driver model (platform drivers, probe/remove, sysfs)
  • Concurrency primitives (spinlocks vs mutexes, RCU, atomic operations, memory barriers)
  • Bus protocols (I2C, SPI, UART, CAN) — when to use which, tradeoffs

Misc

Some other topics I can think of. It is true that quite some jobs require you understand hardware quite well. (e.g. bring ups, or work very closely with hardware team)

Debugging / Troubleshooting scenarios

  • “A device randomly crashes in the field — walk me through your debug process”
  • Reading crash dumps, core dumps, kernel oops
  • Using JTAG/SWD, logic analyzers, oscilloscopes
  • Reproducing race conditions and heisenbugs
  • Memory corruption debugging (stack overflow, use-after-free, buffer overrun)

Behavioral / Past project deep-dives

  • “Tell me about the hardest bug you’ve ever fixed”
  • “Describe a time you had to make a tradeoff between performance and power”
  • Ownership of a feature from bring-up to production
  • Cross-team collaboration (HW/SW co-design, working with silicon vendors)

Hardware-adjacent knowledge

  • Reading schematics and datasheets
  • Understanding timing diagrams
  • Board bring-up process (what do you check first?)
  • Signal integrity basics (pull-ups, debouncing, level shifting)

Build systems / Toolchain

  • Cross-compilation, toolchains (arm-none-eabi-gcc, Yocto/Buildroot)
  • Linker scripts, memory layout (flash, SRAM, DRAM sections)
  • Static analysis tools, sanitizers (ASan, UBSan, Valgrind)

RTOS-specific (if not Linux)

  • FreeRTOS / Zephyr task model
  • Priority inversion and mitigation
  • Stack sizing, heap fragmentation in constrained systems
  • Tick-less idle, low-power scheduling

Testing & CI for embedded

  • Hardware-in-the-loop (HIL) testing
  • Mocking hardware peripherals for unit tests
  • Firmware CI pipelines (flashing, running on real targets)
  • Code coverage on embedded targets