Max/m3y54m_Embedded-Engineering-Roadmap
1
0
Fork 0
mirror of https://github.com/m3y54m/Embedded-Engineering-Roadmap.git synced 2026-10-12 01:08:13 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
9c50799fc916aca312b46111e477f79b16376b66
m3y54m_Embedded-Engineering…/README.md
T

136 KiB
Raw Blame History

Embedded Systems Engineering Roadmap

GitHub Repo stars GitHub forks GitHub watchers GitHub contributors GitHub tag (with filter) GitHub all releases

This roadmap is created to help beginners aspiring to build a career as an Embedded Engineer/Developer, as well as assist current practitioners in expanding their skills.

Embedded engineering demands a solid understanding of hardware functionality as well as software development and programming skills. If you really want to pursue this career, you need to be motivated and passionate about it. As the saying goes, "Hardware is hard!" But don't panic: be patient with the challenges you will meet along this exciting journey. With enough time and effort spent practicing and building projects, you will soon be a real embedded engineer! 😀

❓ What is an Embedded System?

📖 Embedded System Definitions

Standards, books and glossaries word it differently, but the common idea is a computer built into a larger product to perform a dedicated function, usually with tight limits on cost, size, power and reliability.

▶️ ISO/IEC/IEEE 24765 Standard:

computer system that is part of a larger system and performs some of the requirements of that system. For example, a computer system used in an aircraft or rapid transit system.

The hardware and software of an embedded system are usually minimized and optimized for specific functions. The embedded system includes at least one microcontroller, microprocessor or digital signal processor. The embedded system designed to optimize reliability, cost, size and power saving for applications.

▶️ "Making Embedded Systems" Book:

An embedded system is a computerized system that is purpose built for its application.

▶️ "Computer Organization and Embedded Systems" Book:

A physical system that employs computer control for a specific purpose, rather than for general-purpose computation, is referred to as an embedded system.

▶️ Analog Devices Glossary:

An embedded system is a system in which the computer (generally a microcontroller or microprocessor) is included as an integral part of the system.

Often, the computer is relatively invisible to the user, without obvious applications, files, or operating systems. Examples of products with invisible embedded systems are the controller that runs a microwave oven or the engine control system of a modern automobile.

▶️ Embedded Systems Glossary:

A combination of computer hardware and software, and perhaps additional mechanical or other parts, designed to perform a dedicated function.

In some cases, embedded systems are part of a larger system or product, as in the case of an antilock braking system in a car.

🗺️ The Roadmap

🌐 Open the interactive roadmap to explore it in your browser. Click any topic to read its description and see its learning resources, hover over it to see the topics it is related to, highlight topics by learning priority (required, recommended or optional), and search across all topics and resources. The roadmap can also be downloaded there as a PDF or PNG image.

Embedded Systems Engineering Roadmap

The embedded systems engineering roadmap is structured into three fundamental areas: SOFTWARE, HARDWARE, and SOFT SKILLS.

Hardware and software overlap heavily in embedded systems, but specific job titles tend to emphasize one over the other. Roles such as "Embedded Software Engineer/Developer," "Firmware Engineer/Developer" and "Embedded Linux Engineer/Developer" focus mainly on software development. Positions such as "Embedded Hardware Engineer" and "Hardware Design Engineer" deal mainly with hardware design and electronics. Roles such as "Embedded Systems Engineer" require a solid understanding of both.

Each company in the embedded industry may have its own requirements for a given job title, so tailor your focus to your career goals. If you're seeking an embedded software position, prioritize the software skills in the roadmap. If you're interested in an embedded hardware job, concentrate on the hardware skills and spend more time learning electronics.

The roadmap covers the essential topics for a typical "Embedded Systems Engineer" role. By studying both software and hardware, you can build the skills to thrive in this dynamic field. If you have a clear preference for one side, you can tailor your learning path accordingly.

🔗 For more information about the history behind this roadmap, read this article: Embedded Systems Roadmap: Bridging the Gap

Note

Remember that the priority of individual software and hardware skills can differ depending on the company's requirements and the job role.

Tip

To differentiate between the types of learning resources and the quality of their content, specific symbols are used before each item.

Resource types:

  • 📘 : Books
  • 🎞️ : Videos
  • 📝 : Write-ups, articles, and blog posts
  • 🔗 : Other links that do not fit into any of the above categories

Content quality symbols:

  • 👶 : Easy-to-understand and beginner-friendly resources. Refer to them if you do not have prior knowledge in a topic.
  • 💎 : Well-known references that have truly invaluable and comprehensive content. Refer to them if you want to deepen your understanding of a topic.

Important

This repository is not affiliated with or financially supported by any content creator, publisher, or organization. We do not endorse or recommend any specific paid resources. Both free and paid resources are included to provide a range of options, allowing you to choose what best suits your needs and preferences.

😕 Don't Know Where to Start!

If you feel overwhelmed by the long list of topics in the roadmap, you're not alone. Before delving too deeply, ease into it with some simple starter projects. Learning embedded systems engineering takes time and effort, so don't get discouraged if you don't understand something right away. Keep practicing and you will get there.

⚒️ Projects

Hands-on projects are the most effective way to learn, far better than relying solely on theory from books or articles. Even a seemingly basic project can teach you more than hours of aimless reading. Refer to books, articles and courses when you get stuck on problems in real-world projects.

Don't try to build a complex project right away. Start with small, manageable projects to get your feet wet.

🔎 Search and Ask!

Use search engines to find the answers to your questions.

If search engines don't help, AI chatbots can also assist. Keep in mind that AI can give incorrect answers, so confirm anything important against more reliable references.

If you have reservations about relying on AI advice alone, you can also ask real people:

💼 Career Development

To advance your career as an embedded systems engineer, it's essential to stay up to date with industry trends, best practices and new technologies. These resources can help:

  • 🔗 EmbeddedJobs - A job board focused exclusively on the embedded systems job market.

🎥 Courses and YouTube Contents

You may have heard that YouTube is a university, and it's true: there is an extensive amount of invaluable free embedded systems content on YouTube. You'll also find some excellent free courses on Coursera and edX, and Udemy offers some high-quality paid ones.

🕹️ Arduino

If you have no background in programming embedded systems, Arduino boards and libraries are the best place to start learning the basics. Just keep in mind that most Arduino libraries are written for learning purposes and are not optimized for industrial use.

The Arduino Core (the platform-specific implementation of the hardware-independent ArduinoCore-API) also takes care of most of the low-level hardware operations that an embedded engineer should be able to handle, or at least clearly understand. To become a professional embedded developer, learn to use the industry-standard APIs and SDKs provided by microcontroller vendors, such as CMSIS for ARM Cortex-M microcontrollers, STM32Cube for STM32 and ESP-IDF for Espressif microcontrollers.

👨‍🏫 Educational Websites

🗺️ Other Helpful Roadmaps

🛠️ Development Environments

An IDE or editor ties the compiler, debugger and flashing tools together so that a first program runs on the board quickly. Which one fits depends on your microcontroller family and how much you want to configure yourself.

🔵 Vendor IDEs

Vendor IDEs bundle the toolchain, debugger integration and peripheral configuration tools for their microcontrollers, which makes them a quick way to bring up a first target.

🔵 VS Code Extensions

A lighter alternative to a vendor IDE: extensions add Cortex-M debugging and microcontroller vendor SDK integration to VS Code.

🔵 PlatformIO

PlatformIO is a professional, cross-platform, cross-architecture and multi-framework development tool for embedded systems engineers and for software developers who write applications for embedded products.

PlatformIO is not yet widely adopted in industrial and large-scale projects, but it is an excellent choice for smaller projects. It greatly reduces the effort of installing frameworks and setting up build and debug tools, so you can concentrate on programming.

📚 Learning Resources

Warning

You do not need to read every book and article or watch every video listed here. Trying to do so will only leave you tired and discouraged, because it could take years. Study enough to gain at least a basic understanding of the required topics. Of course, the more time you spend studying and building projects, the deeper your knowledge and expertise will become.

Some of the resources here are only meant as references. Refer to them when you need them.

✳️ Soft Skills

Like other professionals, embedded engineers need soft skills, which can't be learned solely by reading or watching videos. They are developed through interacting with others and overcoming obstacles at work. Improving them is not a one-size-fits-all process: it varies with your individual traits and requires self-awareness of your strengths and areas for growth. It takes time and effort.

🔵 Communication Skills

🔵 Problem-Solving Skills & Critical Thinking

🔵 Teamwork & Collaborative Abilities

🔵 Organizational & Time Management Skills

🔵 Being Self-Driven and Independent

🔵 Adaptability & Patience

✳️ Electronics

Electronics knowledge lets firmware engineers read schematics and datasheets, understand voltage levels, current limits and timing, and tell a hardware fault from a software bug.

🔵 Basic Calculus

Calculus underpins signal processing, control theory and the behavior of circuits with capacitors and inductors.

🔵 Principles of Electric Circuits

Ohm's and Kirchhoff's laws, RC and RL circuits and AC basics are what you need to size pull-up resistors, filters and power supplies around a microcontroller.

🔵 Electronics Fundamentals

The building blocks that appear around every microcontroller: resistors, capacitors, diodes, transistors and op-amps, and how they behave in real circuits.

🔵 Digital Design

Logic gates, flip-flops and registers are the hardware inside microcontrollers and FPGAs; understanding them explains how peripherals, buses and timing work.

🔵 Computer Architecture

Computer architecture is the backbone of embedded systems, governing how hardware and software interact. Embedded developers need to understand it to design, develop and debug embedded software effectively. ARM and RISC-V are the two most prevalent instruction set architectures (ISAs) in embedded systems, so expertise in them is valuable: ARM is dominant, while RISC-V is gaining traction thanks to its open-source nature and flexibility.

✳️ Using Test Equipment

Embedded systems are verified with instruments as well as code. Multimeters, oscilloscopes, logic analyzers, power supplies and function generators let you measure signals, inject stimuli and see what the hardware really does.

🔵 Multimeter

Measures voltage, current, resistance and continuity. It is the first tool for checking power rails, connections and short circuits.

🔵 Logic / Protocol Analyzer

Captures digital signals and decodes protocols such as UART, I2C, SPI and CAN, so you can see exactly what is exchanged on the wires.

🔵 Oscilloscope

Shows signals over time: edges, rise times, noise, glitches and power supply ripple that a logic analyzer cannot show.

✳️ Prototyping Skills

Hardware design and prototyping are primarily the responsibility of electronic hardware design engineers, but embedded software engineers benefit from understanding them too. This knowledge helps identify and resolve hardware-related issues while debugging an embedded system. With a grasp of hardware principles, software engineers can pinpoint the root causes of problems and troubleshoot faster.

🔵 Breadboarding

Breadboarding is a hands-on approach to prototyping circuits, providing a versatile platform for experimentation and design. Breadboards are easy to use, flexible and inexpensive, and they let developers connect components, then test and refine a design without permanent soldering. This allows rapid iteration and efficient debugging, which makes breadboarding an invaluable tool for embedded system development.

🔵 Hardware Design Basics

Reading schematics, choosing components, and designing the power supply, reset and clock circuits that a microcontroller needs to run.

🔵 PCB Design / EMC

Turning a schematic into a board. Layout, grounding and decoupling decide signal integrity and electromagnetic compatibility (EMC), and whether a product passes certification.

🔵 Soldering / Rework

Assembling prototypes and repairing boards, from through-hole parts to fine-pitch SMD components, including replacing parts with hot air.

✳️ FPGA Development

FPGAs (Field-Programmable Gate Arrays) are integrated circuits that can be configured to implement digital logic. They are widely used in embedded systems for their high performance, flexibility and cost-effectiveness. FPGA designers use hardware description languages (HDLs) to create custom circuits that map directly onto the FPGA architecture. Because FPGA design and verification differ significantly from embedded software development, it is a specialized domain within embedded systems.

✳️ Programming Fundamentals

Mastering programming fundamentals and software development principles is essential for successful embedded design. Resource-constrained environments demand efficient code, optimized data management, reusable design patterns and effective memory management. Embedded developers need a strong foundation in these core concepts to build reliable, performant systems.

🔵 Discrete Mathematics

Discrete mathematics is the theoretical basis of computer science and engineering. The parts most useful to embedded engineers are logic and switching algebra (digital circuit design), automata theory (state machines and protocols), combinatorics, coding theory (data transmission and audio/video codecs) and modular arithmetic (checksums and cryptography).

🔵 Algorithms & Data Structures

Tight RAM and CPU budgets shape the choices: fixed-size buffers, ring buffers, queues and lookup tables are more common in firmware than dynamic structures.

🔵 Design Patterns

Patterns that work without heavy object orientation or dynamic allocation, such as state, observer, opaque pointers and layered hardware abstractions.

🔵 State Machines

Most embedded behavior, such as protocols, user interfaces and device modes, is a state machine reacting to events. Making states explicit keeps it predictable and testable.

🔵 Memory Management

Firmware usually avoids malloc after startup and relies on static allocation, stacks of known size and memory pools. Understanding the stack, the heap and the linker's memory map helps prevent overflows and fragmentation.

✳️ Programming Languages

Low-level languages like C and assembly provide direct hardware access, enabling efficient optimization for resource-constrained embedded systems. System-level languages like C++ and Rust offer a higher level of abstraction for complex embedded applications, while Python is often used to test embedded systems because of its simplicity.

🔵 C

The dominant language of embedded firmware: close to the hardware, with a minimal runtime, predictable memory use and support in every toolchain.

🔵 C++

Adds classes, templates and stronger type checking on top of C at little or no runtime cost, when used without exceptions, RTTI and heavy dynamic allocation.

Additional resources from Bjarne Stroustrup, creator of C++

🔵 Assembly

Needed for startup code, interrupt entry and the rare hot spot, and for reading disassembly while debugging. ARM and RISC-V are the most common instruction sets.

🔵 Python

Used on the host for test automation, tooling and scripting, and on microcontrollers through MicroPython and CircuitPython.

🔶 Python for Microcontrollers

🔵 Rust

A memory-safe systems language without a garbage collector. It is gaining ground in embedded for firmware that must be both safe and efficient.

🔵 Zig

✳️ Microcontrollers

Microcontrollers are integrated circuits (ICs) that combine a processor core, memory and input/output (I/O) peripherals on a single chip. Designed for embedded applications, they control devices in many industries, including automotive, industrial, consumer electronics and healthcare.

Popular microcontroller families include STM32, ESP32, nRF, RP2040/RP2350, and the NXP and Renesas lines, alongside long-established AVR, PIC and MSP430. Choosing the right one involves assessing application requirements, processing power, memory needs and input/output capabilities, and considering ease of use, cost, reliability, availability and future expansion.

🔵 GPIO

Pins that firmware configures as digital inputs or outputs, with pull-ups, open-drain or alternate functions. The basis for LEDs, buttons and bit-banged protocols.

🔵 ADC

Converts an analog voltage into a digital value. Resolution, sampling rate, reference voltage and noise determine how accurate readings are.

🔵 DAC

Converts a digital value into an analog voltage, used for audio, waveform generation and set-points.

🔵 Timers / Counters

Count clock cycles to measure time, generate periodic interrupts and capture or generate signals. They are the base of scheduling and PWM.

🔵 PWM (Pulse Width Modulation)

A digital output whose duty cycle is adjustable, used to control motor speed, LED brightness and power converters.

🔵 RTC (Real Time Clock)

A low-power clock that keeps calendar time, often from a backup battery, and can wake the microcontroller from sleep.

🔵 Watchdog

A timer that resets the microcontroller if the firmware stops servicing it, so the device recovers from hangs on its own.

🔵 Interrupts

Let hardware events preempt the running code immediately. Priorities, latency and short handlers are central to responsive firmware.

🔵 DMA

Moves data between peripherals and memory without the CPU, freeing it for other work and sustaining high-rate transfers from ADCs, SPI or UART.

🔵 Clock Management

Clock sources, PLLs and dividers set CPU and peripheral speed and affect accuracy and power. A misconfigured clock is a common source of mysterious problems.

🔵 Power Management

Sleep and low-power modes, wake-up sources and clock gating are what let battery-powered devices last for months or years.

🔵 Bootloader / DFU (Device Firmware Update)

A small program that starts first, checks the application image and can update the firmware over UART, USB or the air.

✳️ Interfaces, Protocols & Communication Technologies

Embedded systems exchange data with sensors, memories, displays, other chips and the outside world. An interface is the physical connection and a protocol defines how data is exchanged over it. The right choice depends on bandwidth, distance, number of wires, power consumption, cost and available hardware support.

🔵 Basic Protocols

Short-distance serial buses such as UART, I2C and SPI that connect a microcontroller to sensors, memories, displays and other chips on the same board.

🔶 UART
🔶 I2C
🔶 SPI
🔶 SDIO
🔶 I3C
🔶 1-Wire

🔵 Digital Audio Protocols

Interfaces that move audio samples between a microcontroller or processor and codecs, microphones and amplifiers.

🔶 I2S
🔶 PCM

🔵 Display & Camera Protocols

Interfaces for displays and image sensors, from simple control buses to the high-speed MIPI links used with application processors.

🔶 SCCB
🔶 MIPI CSI-2
🔶 MIPI DSI
🔶 HDMI

🔵 Wireless Protocols

Radio links trade off range, data rate, power consumption and ecosystem: low-power short range (BLE, Zigbee, Thread), long range (LoRa), high throughput (Wi-Fi) and ranging (UWB).

🔶 Bluetooth / BLE
🔶 Wi-Fi
🔶 LoRa / LoRaWAN
🔶 Zigbee
🔶 Thread
🔶 Matter
🔶 UWB

🔵 Industrial Protocols

Fieldbus and industrial Ethernet protocols that connect controllers, sensors and drives in factories and automation systems.

🔶 Modbus
🔶 RS485
🔶 EtherCAT
🔶 Profinet
🔶 CoAP & MQTT

🔵 High-Speed Protocols

Wired links for high data rates, such as Ethernet, USB and PCIe. They usually need a hardware controller, a protocol stack and careful PCB layout.

🔶 Ethernet
🔶 USB
🔶 PCIe

🔵 Automotive Protocols

Vehicle networks that connect electronic control units (ECUs), from the low-cost LIN to CAN, FlexRay and MOST. They are built for robust, real-time communication in electrically noisy environments.

🔶 CAN
🔶 LIN
🔶 MOST
🔶 FlexRay

🔵 Network Protocols / Socket Programming

How devices communicate over IP networks: TCP and UDP sockets, and the lightweight IP stacks such as lwIP that run on microcontrollers and embedded Linux.

🔵 Cellular Communication

Cellular modems give a device wide-area connectivity: 4G modems for high throughput, and low-power IoT variants (LTE-M, NB-IoT) designed for battery-powered devices.

🔶 GSM / LTE
🔶 LTE-M & NB-IoT

✳️ Memory Technologies & File Systems

Embedded systems combine volatile (SRAM, DRAM, PSRAM) and non-volatile (flash, EEPROM, FRAM) memory to store and access data, chosen by factors such as performance, cost, power consumption and durability.

🔵 Flash Memory

Non-volatile memory that stores firmware and data. It is erased in blocks and wears out with writes; NOR flash suits code execution, NAND flash suits bulk storage.

🔶 NOR / NAND
🔶 eMMC
🔶 SD Card

🔵 EEPROM

Byte-erasable non-volatile memory for small amounts of data such as settings and calibration values, with a limited number of write cycles.

🔵 SRAM / DRAM

Fast volatile memory. SRAM is built into the microcontroller and needs no refresh; DRAM is larger and cheaper but needs a memory controller and periodic refresh.

🔵 File Systems

A file system organizes data on a storage device. Embedded devices need ones designed for the medium: flash wears out and is erased in blocks, so wear leveling and power-loss safety matter more than speed (for example LittleFS, FAT on SD cards, or UBIFS and ext4 on eMMC under Linux). Small microcontrollers often need no file system at all.

✳️ Hardware Simulation / Emulation

Embedded development often involves simulating or emulating hardware to test and debug software before deploying it on actual hardware. Simulators create virtual models of hardware systems, while emulators reproduce the behavior of the real hardware closely enough to run the actual firmware. These tools reduce development time and hardware costs and improve software reliability.

🔵 QEMU

A general machine emulator that can boot kernels and firmware for many architectures and boards without hardware, widely used for embedded Linux and RTOS development.

🔵 Renode

An open-source framework that simulates whole embedded systems, including peripherals and multiple nodes, which makes firmware testable in CI without boards.

✳️ Sensors & Actuators

Sensors and actuators are the eyes and hands of embedded systems: they gather information about the environment and act on it. Sensors convert physical phenomena, such as temperature, light or sound, into electrical signals that the embedded system can process. Actuators do the opposite, converting electrical signals into physical actions, such as controlling the speed of a motor or opening and closing a valve.

🔵 Sensors

🔵 Actuators

✳️ Digital Signal Processing

Digital signal processing manipulates sampled signals such as audio, sensor data and radio signals. On microcontrollers it appears as digital filters, FFTs and sensor fusion, running on CPUs with DSP instructions (for example Cortex-M4 and M7), dedicated DSP cores or FPGAs, often in fixed-point arithmetic to save time and energy.

🔵 DSP Basics & Filter Design

Sampling theory, FIR and IIR filters and fixed-point arithmetic: the tools for cleaning up sensor and audio signals in firmware.

🔵 Discrete Fourier Transform / FFT

Turns time-domain samples into frequencies, used for vibration analysis, audio and sensor data, typically through optimized libraries such as CMSIS-DSP.

✳️ Control Theory

Control theory covers how a system holds a target despite disturbances, such as motor speed, temperature or a drone's attitude. In firmware it appears as control loops running at a fixed sampling rate with sensor feedback and filtering.

🔵 PID Controller

The most widely used controller. It combines proportional, integral and derivative action on the error, and is discretized and tuned in firmware for motors, heaters and many other loops.

🔵 MATLAB / Simulink

Model-based design: simulate controllers and algorithms first, then generate C code for the target microcontroller.

✳️ Operating Systems

Embedded systems can be programmed either on top of an operating system (OS) or directly on the hardware, which is known as bare-metal programming. Each approach has its own advantages and disadvantages. An embedded OS provides a layer of abstraction between the hardware and the application code and offers resource management, task scheduling, error handling and communication capabilities. However, it adds overhead and may not suit memory-constrained applications.

🔵 Operating System Fundamentals

Processes, scheduling, memory management and drivers: the concepts behind what an RTOS or Linux does for your application.

🔵 Real-Time Operating Systems

Real-time operating systems (RTOS) are specialized operating systems designed to meet strict timing deadlines. They are used in embedded systems where timing is critical, such as avionics, robotics and medical devices. An RTOS provides a deterministic environment in which tasks run with predictable timing, so critical tasks always execute on time, even in the presence of interrupts and other disruptions.

🔶 RTOS Basics
🔶 FreeRTOS
🔶 Zephyr
🔶 μC/OS / Micriμm OS
🔶 NuttX
🔶 RT-Thread
🔶 Mbed OS
🔶 QNX
🔶 VxWorks
🔶 Eclipse ThreadX (formerly Azure RTOS)

🔵 Embedded Linux

Embedded Linux runs on application processors rather than small microcontrollers. It is chosen for its networking, file system, USB and graphics stacks and its large software ecosystem, at the cost of more memory, longer boot times and no hard real-time guarantees unless the PREEMPT_RT patch is used.

🔶 Linux Kernel
🔶 Linux Device Drivers
🔶 U-Boot
🔶 Buildroot
🔶 Yocto
🔶 Embedded Android

Embedded Android builds on Embedded Linux: the device runs a Linux kernel with Android-specific additions, and the Android Open Source Project (AOSP) adds its own build system, hardware abstraction layers (HALs) and framework on top. Learn Embedded Linux first, then how AOSP is built, ported to a board and extended with HALs and native (NDK) code.

🔵 Multithreading & Parallel Processing

Running several tasks concurrently on one or more cores brings shared-data hazards such as race conditions, priority inversion and deadlocks. Mutexes, queues and careful design keep them under control.

🔶 High-Performance Computing (HPC)

🔵 Inter-Process Communication (IPC)

How tasks and processes exchange data and signals: queues, shared memory, sockets, pipes and message buses such as D-Bus.

🔵 Qt Framework

A C++ framework for GUIs and applications on embedded Linux, with QML for declarative interfaces and a lighter Qt for MCUs edition for microcontrollers.

✳️ Debugging

Embedded bugs often involve hardware, timing and software together. Debugging combines in-circuit debuggers, logging, tracing, static analysis, simulation and instruments such as oscilloscopes to find the root cause.

🔵 JTAG / SWD

JTAG and SWD (Serial Wire Debug) are two popular interface protocols for debugging and programming embedded systems. JTAG is a general-purpose protocol that can debug and program a wide range of devices, while SWD is a simpler, more compact protocol designed specifically for ARM microcontrollers.

🔵 GDB

GDB is the standard open-source debugger for C, C++ and Rust firmware. Connected through a debug probe and a GDB server such as OpenOCD, it lets you set breakpoints, step through code, and inspect registers, memory and the call stack on the target.

🔵 OpenOCD

OpenOCD is the open-source bridge between a debug probe (ST-Link, J-Link, CMSIS-DAP and others) and GDB. It talks JTAG or SWD to the target and supports flashing, debugging and boundary scan on a wide range of microcontrollers.

✳️ Build System

Firmware is cross-compiled for a target that differs from the development machine, linked with a memory layout script and converted to a flashable image. Build systems automate these steps so builds are repeatable on every machine and in CI.

🔵 Compilers / GCC

A cross-compiler such as GCC (arm-none-eabi-gcc, riscv-gcc) or Clang turns C and C++ into code for a specific microcontroller. Its flags, optimization levels, linker scripts and startup code determine size, speed and behavior. Commercial compilers such as Keil and IAR offer vendor-tuned optimization and support that some projects prefer.

🔵 Make / CMake

Make rebuilds only what changed, based on rules in a Makefile. CMake generates Makefiles or Ninja files and supports toolchain files for cross-compiling, which is why many embedded SDKs such as Zephyr, the Pico SDK and ESP-IDF use it.

🔵 Bash Scripting

Shell scripts glue the toolchain together on Linux and in CI: running builds and tests, flashing boards, parsing serial logs and preparing release images. On Windows, Bash is available through WSL.

🔵 Docker

A container image pins the exact compiler, SDK and tool versions, so every developer and CI job builds the same firmware, even years later, and new team members skip a long toolchain setup.

✳️ Software Development Life Cycle (SDLC) Models

Embedded projects combine software, hardware and often safety or regulatory requirements, which shapes how development is planned. SDLC models describe how requirements, design, implementation, verification and maintenance are organized, from sequential models such as the V-model to iterative ones such as Agile.

🔵 Agile / SCRUM

Iterative development in short sprints. In embedded projects it has to account for hardware availability, long lead times and certification.

🔵 V-Model (V-cycle)

Pairs every development stage with a matching test stage. It is common in safety-critical domains such as automotive, medical and aerospace.

✳️ Version Control Systems

Firmware has to be traceable: every released binary should map to an exact source revision, often together with the hardware design files. Version control tracks changes, supports branches for features and hotfixes, and helps find the change that introduced a bug. Git is the standard; Subversion is still found in older projects.

🔵 Git

The standard distributed version control system. Branches, tags for releases and bisect for finding regressions are used daily in firmware projects.

🔵 SVN (Subversion)

✳️ Testing

Embedded testing covers logic that can run on a PC as well as behavior that only appears on real hardware, such as timing, interrupts, peripherals and power. A typical strategy combines host-based unit tests, integration tests on the target and system tests.

🔵 Test Driven Development (TDD)

Writing tests before the code. In embedded projects the tests usually run on the host with the hardware mocked, which gives fast feedback without flashing a board.

🔶 Unit Testing
🔸 GoogleTest - Google Testing and Mocking Framework
🔶 Integration Testing

🔵 CI/CD Pipelines

Continuous integration builds and tests every change automatically, for example compiling for all targets and running unit tests. Continuous delivery also produces versioned, signed firmware images and can deliver them to devices over the air. Hardware-in-the-loop runners extend CI to real boards.

🔵 SIL / HIL Testing

Software-in-the-loop (SIL) and hardware-in-the-loop (HIL) testing validate the functionality and performance of embedded software against a simulated environment. In SIL the code runs on a development machine against a software model of the system; in HIL the real target hardware runs the firmware while a simulator provides the signals of the real world, such as sensors, loads and buses.

🔵 Standards & Certifications

Embedded systems development is subject to many standards and certifications, which serve as guidelines and benchmarks for the quality, safety and reliability of these systems. They are often developed and maintained by industry bodies such as the International Electrotechnical Commission (IEC) and the Society of Automotive Engineers (SAE).

🔶 Functional Safety

✳️ Embedded Security

Security is particularly challenging in embedded systems because of their resource constraints. They typically run on small, low-power microcontrollers with limited memory and processing power, which makes it difficult to reach the level of security of traditional computing platforms. They also often receive updates and patches rarely, if at all, which leaves them more vulnerable to known vulnerabilities.

🔵 Hardware Hacking

Hardware hacking means attacking a device through its physical interfaces: debug ports (JTAG/SWD, UART), flash chips, bus sniffing and fault injection. Knowing these attacks shows embedded engineers which protections matter, such as locking debug access and encrypting firmware.

🔵 Cryptography

Hashing, symmetric and asymmetric encryption and digital signatures, implemented in software or by the hardware accelerators on many microcontrollers, to protect data and authenticate devices and firmware.

🔵 Secure Boot & Secure Firmware Update

Make sure that only authentic, signed firmware runs and can be installed, using a hardware root of trust and verified images.

✳️ Embedded GUI

A display needs a user interface that fits small RAM and flash, a limited CPU or GPU and tight latency. Embedded GUI libraries such as LVGL, TouchGFX and Qt provide widgets, drawing and touch handling on top of the display driver.

✳️ IoT (Internet of Things)

IoT devices combine sensors, a microcontroller and a network link, and often run on batteries for years. The embedded work covers connectivity, power budgets, secure provisioning, cloud protocols such as MQTT and over-the-air updates for devices deployed in the field.

🔵 Delta Over-The-Air Firmware Update

Updating devices by sending only the differences between firmware versions, which saves bandwidth, time and flash wear.

✳️ Edge AI

Edge AI is the ability of devices to perform machine learning tasks on their own, without sending data to a central server, by running small, specialized AI models embedded directly in the device. TinyML is a subset of Edge AI that focuses on developing these models for devices with very limited computing power, such as microcontrollers and sensors.

🔵 AI & ML Basics

The concepts needed before deploying models on devices: training versus inference, models and datasets, and techniques such as quantization that shrink models.

🔵 TensorFlow Lite

Google's lightweight runtime for running machine learning models on mobile and embedded devices, including a variant for microcontrollers.

🔵 TinyML

Machine learning on microcontrollers, where model size, memory, latency and power are the main constraints.

✳️ AUTOSAR Architecture

AUTOSAR, or AUTomotive Open System ARchitecture, is a global industry standard for automotive software development. It is a software architecture that provides a standardized platform for developing and integrating software components in vehicle electronic control units (ECUs), which allows ECUs from different manufacturers to communicate and work together seamlessly.

History

At first this was meant to be my personal reading list, but as the list gradually grew, I wondered why not share it with others. So I researched current job postings for embedded engineering roles, selected the most frequent skills and put them on a roadmap. To make the roadmap more comprehensive I also added some basic skills, and finally came up with what you see here.

The idea for this roadmap came from vazeri / Embedded-Engineering-RoadMap-2018, which was well designed but had some flaws and had not been updated for years. I took that idea, changed the structure of the roadmap and tried to improve it. The initial results can be found in m3y54m / Embedded-Engineering-Roadmap-Archived, which is now archived. Early versions of the roadmap were created using Balsamiq Wireframes, which is not suitable for these types of diagrams. Today the roadmap is drawn by the interactive explorer in this repository, directly from this README and the map definition.

Copyright

This work is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License which means that you are free to share or adapt this work under the following terms:

Attribution — You must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use.

ShareAlike — If you remix, transform, or build upon the material, you must distribute your contributions under the same license as the original.

Acknowledgement

Special thanks to my friends in the community of Iranian Embedded Engineers on Twitter and the r/embedded subreddit for their suggestions that helped improve this roadmap.

Contribution

If you think this roadmap can be improved in any way, or you know of good learning resources that could be added here, please open an issue or a pull request. I’ll maintain and update this repository frequently.

The roadmap image and PDF are generated from this repository. Topics, descriptions and learning resources come from this README; where each topic sits on the map and its learning priority (required, recommended or optional) come from explorer/map.json. Edit those files and the interactive explorer in explorer/ renders the PNG and PDF automatically.

Reference in New Issue View Git Blame Copy Permalink