All Topics
69 in-depth articles across 12 embedded systems domains, organized from foundational to advanced. Use the sidebar to jump to a category, or search to find a specific topic.
New here? Start with the foundations.
We recommend working through the 33 foundational topics first — they’re tested in nearly every embedded interview.
Core C/C++ programming skills and low-level concepts essential for embedded development — Foundation skills — always tested in interviews
Data Types & Memory Layout
C data types, memory sections (.text, .data, .bss, stack, heap), storage duration, fixed-width integers, and memory-aware programming for embedded systems.
Pointers, Arrays & Pointer Arithmetic
Pointer fundamentals, pointer arithmetic, array decay, void pointers, and common interview traps — the building blocks of every embedded C program.
volatile and const
Master the volatile and const type qualifiers — what the compiler does differently, hardware register access, ISR-shared variables, const with pointers, volatile const for read-only hardware, and MISRA C implications.
C++ Classes & OOP for Embedded
C++ classes in embedded systems — encapsulating hardware registers, constructors/destructors for init/deinit, inheritance for device hierarchies, the cost of virtual functions and vtables in ROM, CRTP as a zero-cost polymorphism alternative, and when to prefer composition over inheritance.
Structs, Unions & Bitfields
Structure layout and padding, packed structs, unions for type punning and register overlays, bitfields for hardware register mapping, and portability pitfalls — all through the lens of embedded systems interviews.
C++ Embedded Constraints & STL
Navigate C++ in resource-constrained embedded systems — disabled exceptions and RTTI, heap-free programming, safe STL subsets, compiler flags, C/C++ interop with extern C, and industry guidelines (MISRA C++, AUTOSAR C++14).
Embedded C Code Patterns
State machines, ring buffers, bit manipulation, error handling, memory-mapped I/O, volatile-safe patterns, and guard clauses -- the embedded C patterns interviewers expect you to write from memory.
Function Pointers & Callbacks
Function pointer syntax and typedef, callback patterns (event handlers, dispatch tables, state machines), qsort as a classic example, HAL abstraction via function pointers, vtable-style polymorphism in C, and safety considerations for embedded systems.
Memory Alignment & Endianness
Memory alignment rules, struct padding and reordering, endianness (big vs little), network byte order, byte swapping, and portable serialization for cross-architecture embedded systems.
RAII & Smart Pointers
Master RAII (Resource Acquisition Is Initialization) and smart pointers for embedded C++ — deterministic cleanup, lock guards, DMA buffer ownership, unique_ptr with custom deleters, and heap-free RAII patterns.
Templates & Constexpr
Zero-cost abstractions with C++ templates and constexpr — compile-time register maps, type-safe units, static polymorphism via CRTP, constexpr lookup tables, and managing template bloat on flash-constrained MCUs.
Inline Functions & Macros
#define macros (object-like, function-like, pitfalls), inline functions (type safety, debugging advantages), preprocessor directives (include guards, #pragma once, #ifdef), MISRA C guidelines, X-macros, and static inline for header-file functions.
Build Systems
Compilation pipeline, toolchains, linker scripts, memory layout, and binary inspection — Core toolchain knowledge — frequently tested across embedded roles
Compilation Pipeline
Understand what 'press Build' actually does: preprocessor, compiler, assembler, and linker — and what each stage produces.
ELF, Map & Binary Inspection
Read ELF files and linker map files to debug binary-size, symbol-resolution, and unexpected-bloat issues using objdump, nm, size, readelf, strip, and addr2line.
Make & CMake for Embedded
Compare Make and CMake for embedded projects: rules, targets, toolchain files, and when to use each.
Toolchains & Cross-Compilation
Understand cross-compilation: gcc + binutils + libc components, sysroot, target triplets, and the float-ABI/CPU flags that pin a build to specific hardware.
Memory Layout & Startup
How VMA/LMA, .data copy, .bss zero, and the C runtime preparation chain make C code work — Reset_Handler from Flash to main().
Linker Scripts
Master the linker script: MEMORY and SECTIONS blocks, the location counter, KEEP/ALIGN, and how to place code and data exactly where you want it.
MCU & System Architecture
CPU fundamentals, MCU cores, boot process, interrupts, and driver design — Core embedded skills — essential for all roles
Interrupts and priorities
Master interrupt service routine design, NVIC priority schemes, nested interrupts, and latency optimization for real-time embedded systems.
Boot, vector table, and clock bring-up
Understand the hardware-side boot sequence on a Cortex-M MCU: reset sources, vector table, clock tree bring-up, and peripheral initialization order.
Driver design: HAL vs bare metal
Understand HAL vs bare-metal driver design tradeoffs, abstraction layer architecture, register-level access patterns, and when to use each approach in embedded systems.
MCU cores and clocking
Understand ARM Cortex-M core families, RISC-V in embedded, clock tree architecture, PLL configuration, and power modes for optimal embedded system design.
CPU fundamentals for embedded
Understand CPU pipeline, cache coherency with DMA, memory barriers, bus architecture (AHB/APB), and memory types (SRAM, TCM, CCM) — the computer architecture concepts embedded interviewers actually test.
Peripherals
Essential peripheral interfaces and communication protocols — Core peripheral knowledge — frequently tested
GPIO
GPIO (General Purpose Input/Output) fundamentals including pin modes, push-pull vs open-drain, pull-up/pull-down resistors, interrupts, debouncing, and atomic port operations for embedded systems.
ADC
ADC (Analog-to-Digital Converter) fundamentals including resolution, sampling theory, SNR, oversampling, and DMA integration for embedded systems.
CAN
CAN (Controller Area Network) communication including classic vs FD, arbitration, bit timing, and error handling for embedded systems.
DMA
DMA (Direct Memory Access) fundamentals including transfer modes, channel configuration, circular buffers, and cache coherency for embedded systems.
I2C
Master I2C (Inter-Integrated Circuit) communication including addressing, repeated start, clock stretching, and error recovery for embedded systems.
SPI
Master SPI (Serial Peripheral Interface) communication including modes, CS handling, multi-slave timing, and throughput optimization for embedded systems.
Timers and PWM
Master timer peripherals and PWM generation including counting modes, prescaler configuration, input capture, output compare, and dead-time insertion for embedded systems.
UART
Master UART (Universal Asynchronous Receiver-Transmitter) communication including baud rate configuration, framing, DMA, flow control, and common pitfalls in embedded systems.
USB
USB (Universal Serial Bus) fundamentals including device architecture, transfer types, enumeration, descriptors, and common device classes for embedded systems.
Watchdog Timer
Watchdog timer fundamentals including IWDG vs WWDG, windowed mode, feeding strategies, and system recovery for reliable embedded systems.
Hardware & Power Design
Hardware fundamentals, signal integrity, and low-power design for firmware engineers — Hardware understanding and power optimization
Hardware fundamentals for firmware engineers
Essential EE concepts for embedded interviews: reading schematics, pull-up resistors, LDO vs switching regulators, decoupling caps, voltage levels, and power sequencing.
Low-power design techniques
System-level power optimization for embedded: battery budgeting, duty cycling, peripheral power management, wake-up strategies, and sleep current auditing.
Signal integrity and EMC
Understand signal integrity and electromagnetic compatibility: rise times, reflections, EMC compliance, grounding strategies, and PCB layout awareness for firmware engineers.
RTOS & Real-Time
Real-time programming concepts, task scheduling, and RTOS fundamentals — Critical for senior roles
RTOS fundamentals
Understand real-time operating systems: hard vs soft real-time, task states, RTOS vs bare-metal tradeoffs, memory model, and FreeRTOS vs Zephyr comparison.
RTOS Scheduling and Timing
Understand preemptive vs cooperative scheduling, context switching mechanics and cost, rate monotonic analysis, timing analysis, and tickless idle for power-efficient RTOS systems.
RTOS Synchronization Primitives
Compare mutex vs semaphore, message queues, event flags, and understand priority inversion and deadlock prevention in RTOS-based embedded systems.
ISR-to-task patterns
Master the deferred processing pattern: how ISRs signal RTOS tasks using semaphores, queues, and task notifications, with FromISR API rules and double-buffering techniques.
State Machines
FSM fundamentals, implementation patterns, event-driven design, and hierarchical state machines — Core firmware design skill — every protocol parser is an FSM
FSM Fundamentals
States, events, transitions, and actions: the mental model for finite state machines, plus Mealy vs Moore and why FSMs beat nested if/switch.
Event-Driven State Machines
Move from polling to event-driven FSMs: RTOS queue dispatch, run-to-completion, ISR safety, and the active-object pattern.
FSM Patterns in C
Three implementation patterns for FSMs in C — switch-case, table-driven, function-pointer table — with trade-offs and a folded-in section on testing FSMs.
Hierarchical State Machines
How nested states + behavioral inheritance solve the state-explosion problem; UML statecharts, the QP framework, and when an HSM is justified over a flat FSM.
Networking & Protocols
TCP/IP, sockets, MQTT, HTTP/REST, and TLS for embedded connectivity — High priority for IoT and connected device roles
MQTT
MQTT protocol for IoT: publish/subscribe model, topic hierarchy and wildcards, QoS levels (0/1/2), retained messages, last will and testament, persistent sessions, MQTT 5.0, broker selection, and embedded client considerations.
Sockets API Basics
Sockets API lifecycle for embedded systems: socket/bind/listen/accept/connect/send/recv/close, TCP vs UDP patterns, blocking vs non-blocking I/O, select/poll/epoll multiplexing, socket options, error handling, and lwIP vs Linux sockets.
TCP/IP Fundamentals
TCP/IP protocol stack for embedded systems: layers, TCP vs UDP, three-way handshake, flow control, congestion control, sockets API, and lightweight stacks (lwIP).
TLS for Embedded Systems
TLS in embedded systems: TLS 1.2 vs 1.3 handshake, certificate vs PSK authentication, RAM/flash costs on Cortex-M, hardware crypto acceleration, DTLS for UDP protocols, certificate management in the field, and embedded TLS library comparison (mbedTLS, wolfSSL, BearSSL).
HTTP REST for IoT
HTTP and REST for embedded/IoT: REST principles, HTTP/1.1 vs HTTP/2, API design for embedded devices, JSON vs CBOR, authentication (API keys, OAuth, JWT), TLS overhead on constrained devices, CoAP for constrained networks, and when REST is appropriate versus lightweight protocols.
Wireless Technologies
BLE, WiFi, LoRa, cellular IoT, UWB, and mesh networking for embedded systems — Essential for IoT, wearable, and connected device roles
Wireless Technology Selection Guide
Decision matrix for choosing the right wireless technology for embedded IoT: BLE vs WiFi vs LoRa vs Cellular vs Zigbee/Thread vs UWB compared across range, data rate, power, topology, cost, and use case. Includes a decision flowchart and common multi-radio combinations.
BLE Basics
Bluetooth Low Energy fundamentals: BLE vs Classic Bluetooth, GAP advertising and connections, GATT services and characteristics, connection parameters, BLE 5.0 features, security, and power optimization for embedded systems.
WiFi for Embedded
WiFi for embedded systems: station vs AP mode, provisioning methods, power management (DTIM, light/deep sleep), WPA2/WPA3 security, embedded WiFi modules, and decision matrix for choosing WiFi vs BLE vs cellular.
Cellular IoT: NB-IoT & LTE-M
Cellular IoT for embedded systems: NB-IoT vs LTE-M (Cat-M1) comparison, PSM and eDRX power saving, AT command modem control, SIM/eSIM provisioning, cellular module integration, data plan considerations, and 5G RedCap for IoT.
LoRa & LoRaWAN
LoRa and LoRaWAN for embedded IoT: PHY vs protocol stack, spreading factor/bandwidth/coding rate trade-offs, LoRaWAN architecture, device classes (A/B/C), OTAA vs ABP activation, ADR, duty cycle restrictions, and comparison with NB-IoT and Sigfox.
Mesh Networking: Zigbee, Thread & Matter
Mesh networking for embedded IoT: why mesh matters (self-healing, range extension), Zigbee architecture and ZCL, Thread's IP-native mesh over 802.15.4, Matter as the unifying application layer, and choosing mesh vs star topology.
Ultra-Wideband (UWB)
Ultra-Wideband for embedded systems: short-pulse wideband radio for precise ranging, IEEE 802.15.4z, TWR vs TDoA ranging methods, UWB vs BLE positioning comparison, digital car keys, indoor positioning, and embedded UWB chips.
Embedded Linux Essentials
Linux kernel basics, build systems, and user-space programming — For Linux-based embedded systems
Linux boot process
Understand the embedded Linux boot sequence from power-on through U-Boot, kernel initialization, initramfs, and rootfs mounting to the first userspace process.
Linux build systems
Compare Yocto, Buildroot, and OpenWrt for building embedded Linux images. Understand layers, recipes, cross-compilation toolchains, and image generation.
Linux device tree
Understand device tree syntax, node structure, compatible strings, overlays, and how the kernel uses DTB to discover and configure hardware on embedded Linux systems.
Linux drivers and kernel modules
Understand Linux kernel modules, the driver model, character devices, platform drivers, and the probe/remove lifecycle for embedded Linux driver development.
Linux IPC mechanisms
Compare Linux inter-process communication mechanisms — pipes, shared memory, Unix sockets, message queues, signals, and D-Bus — and know when to use each in embedded systems.
Linux userspace basics
Understand the embedded Linux userspace environment: root filesystem layout, filesystem types for Flash, init systems, BusyBox, process model, and debugging tools.
Debugging, Testing & Tools
Debugging techniques, testing strategies, power profiling, and development tools — Practical skills — essential for all embedded roles
Debugging embedded systems
Master embedded debugging: JTAG/SWD, GDB remote debugging, hard fault analysis, printf vs trace, logic analyzers, and systematic debugging methodology.
Power profiling and measurement
Measure and optimize embedded power consumption: current probes, power analyzers (PPK2, Joulescope), software estimation, and profiling methodology.
Testing and code coverage
Embedded testing strategies: unit testing with Unity/CppUTest, HIL testing, code coverage with gcov, static analysis, and CI/CD for embedded.
Safety, Security & Reliability
Safety standards, security fundamentals, OTA updates, and reliability engineering — Critical for safety-critical and secure systems
Industry safety and security standards
Overview of embedded industry standards: IEC 61508, ISO 26262, IEC 62304, DO-178C, and MISRA C — what firmware engineers need to know for interviews.
OTA updates and rollback
Design reliable over-the-air firmware updates: A/B partitioning, delta updates, rollback strategies, update security, and power-fail safety.
Safety mechanisms for embedded systems
Implement safety mechanisms: defensive programming, watchdog strategies, memory integrity checks, redundancy patterns, and fail-safe vs fail-operational design.
Secure boot and cryptography
Understand secure boot chains, hardware crypto accelerators, TLS for embedded, key management, and common embedded security attacks.