Sefism Embedded Systems and IoT Roadmap

What this roadmap is

The Embedded systems and IoT roadmap is Sefism's path from writing C on a laptop to finishing a real connected device: firmware on a board, sensors wired safely, data travelling over MQTT to a dashboard, and a write-up with measured results. It is written for computer engineering, electrical engineering and CS students, and for early-career engineers who want to work closer to hardware.

When you set it up, you choose your board:

• Arduino and ESP32: the cheapest start, with Wi-Fi built into the ESP32.
• STM32: industry microcontrollers, closer to what embedded jobs use.
• Raspberry Pi: a small Linux computer, suited to IoT gateways.

The ten stages are the same for every board, but topics, tools, milestones and suggested projects change with your choice. On a Raspberry Pi, for example, the microcontroller stage becomes Raspberry Pi GPIO basics with Python and gpiozero, and the RTOS stage becomes concurrency on Linux.

What you can do at the end

• Write C that controls hardware directly with bitwise operations, fixed-width types, pointers to registers and volatile, and explain where every variable lives in memory.
• Wire LEDs, buttons, sensors and loads safely using Ohm's law, voltage dividers, pull-ups, correct logic levels and transistor or relay drivers.
• Read sensors over GPIO, ADC, UART, I2C and SPI, debug the bus with a logic analyser and calibrate readings against a reference.
• Structure firmware with interrupts, timers and FreeRTOS tasks, queues and mutexes (or Linux services on a Pi), so several jobs run reliably at once.
• Send readings over Wi-Fi and MQTT to a broker, database and dashboard with alerts, and present a finished device with a power budget, BOM and measured results.

Who it suits, and who should start elsewhere

It suits students who want an embedded or IoT final year project that actually works, and engineers who want to move towards firmware or connected-device roles. You do not need an electronics degree; stage 2 teaches the seven circuit ideas you need.

If you have not programmed before, start with the Programming foundations roadmap and come back once loops, functions and arrays are comfortable. If your interest is mainly networks rather than devices, the Network engineering roadmap fits better. If you only want the cloud side of IoT, DevOps and cloud covers servers and pipelines in more depth.

Time and pace

The ten stages total about 280 hours. The first two stages (C for embedded, and Electronics you need) are foundations: if you already know them, your plan lets you skim or skip them.

A student's week (10 to 12 hours): one evening of theory and datasheets, two evenings at the bench wiring and flashing, and a weekend session working through the stage checklist and committing code with a README describing the wiring. Line the last stage up with your final year project if you can.

Someone working full time (about 5 hours): one weeknight for reading and one weekend block at the bench. Hardware rewards longer sessions, because setting up takes time; protect one uninterrupted block a week.

What to buy: the roadmap's advice is to keep your first board for a whole stage before buying another, buy a cheap multimeter before a second board, and buy a cheap USB logic analyser in stage 4.

Stage by stage

1. C for embedded (about 30 hours, foundation)

Why C still runs the hardware, fixed-width integer types, bitwise operations and masks, pointers and memory-mapped registers, volatile and compiler optimisation, and flash, RAM, stack and heap. Raspberry Pi learners also cover Python on the Pi and when C matters.

Milestone: a small C program, compiled for your board or a simulator, that sets, clears and tests bits in a variable standing in for a register, uses only stdint types, and prints its memory use from the build output.

2. Electronics you need (about 20 hours, foundation)

Ohm's law and power, LEDs and current-limiting resistors, voltage dividers, 3.3 V and 5 V logic levels, pull-ups, pull-downs and buttons, common ground and clean power, and a first circuit with a breadboard and multimeter.

Milestone: an LED with a calculated resistor and a button with a pull-up wired to your board, with your calculations written down and the resistor voltage measured to match.

3. Microcontroller basics (about 30 hours)

Microcontroller or Linux board, your toolchain (Arduino IDE and the ESP32 core, STM32CubeIDE, CubeMX and a Nucleo board, or Raspberry Pi OS and gpiozero), GPIO inputs and outputs, debouncing buttons, timers and PWM, interrupts and ISRs, and timing without blocking. Pi learners also learn what Linux timing cannot do.

Milestone: one LED blinking steadily, a second dimmed with PWM, and debounced button presses counted with an interrupt or callback, all without blocking.

4. Protocols: UART, I2C and SPI (about 25 hours)

UART serial, I2C, SPI, choosing between them, using the buses on your board, and seeing the bus with a logic analyser. RS485 and Modbus for real equipment is an optional topic.

Milestone: your board reading one I2C sensor and one UART or SPI device, with an I2C scan, a logic analyser capture of one transaction, and a table of every part's bus, address or pins and voltage.

5. Sensors and actuators (about 30 hours)

Reading a sensor datasheet, analogue readings and the ADC (with ESP32 ADC pins and calibration, or analogue sensors on a Pi), sensor libraries and drivers, calibration and filtering, switching loads with transistors and relays, and motors, servos and drivers.

Milestone: a calibrated sensor shown in real units, and a load such as a fan, pump or LED strip switched through a transistor or relay with a threshold and hysteresis.

6. RTOS basics (about 30 hours)

When a superloop is not enough, FreeRTOS tasks and the scheduler, queues between tasks, mutexes and semaphores, priority inversion, deadlock and starvation, and deferring work from interrupts. On a Pi this stage covers threads, asyncio and services instead.

Milestone: at least three concurrent jobs (a sampler, a status indicator and a reporter) passing data through a queue and sharing one bus under a mutex or lock, running for an hour without stalls.

7. Wireless and IoT (about 30 hours)

Wi-Fi that recovers from drops, MQTT publish and subscribe, designing MQTT topics, QoS, retained messages and Last Will, an MQTT client on your device (or connecting an STM32), Bluetooth Low Energy, and security and updates for connected devices. LoRa and cellular for remote sites are optional.

Milestone: your device publishing JSON readings to an MQTT broker with a documented topic scheme, a retained online and offline status using Last Will, a command topic it obeys, and automatic recovery after you restart the router.

8. Cloud dashboards for devices (about 25 hours)

Running your own broker, message format and timestamps, storing readings over time, flows with Node-RED, choosing a dashboard, alerts people trust, and showing which devices are offline.

Milestone: a broker with authentication, timestamped readings, a 24-hour chart, an alert with hysteresis delivered to your phone, and a clear offline indicator.

9. Debugging hardware (about 20 hours)

A method for hardware bugs, multimeter and logic analyser, logging that helps, a hardware debugger on ESP32 or STM32, reading crashes, watchdog timers, and brownouts and power problems.

Milestone: a written debugging log of three real problems with the symptom, measurements, cause and fix, plus boot-reason logging and a working watchdog.

10. Portfolio: a working device (about 40 hours)

Picking a device worth finishing, power budget and battery life, sleep and low-power modes, a tidy build and a bill of materials, testing and measured results, and writing it up.

Milestone: one finished device in an enclosure, running for at least a week in its real setting, with firmware, schematic, BOM, photos, a results table, a debugging log and a one-minute video from sensor to dashboard alert.

Projects matched to your board

The roadmap suggests final year projects from the Sefism library for each board, for example:

• Rooftop water tank level and pump controller with dry-run protection (Arduino and ESP32), a beginner device with a real user.
• E-rickshaw battery health monitor on STM32 with FreeRTOS (STM32).
• Solar inverter and battery logger over RS485 (STM32), a strong test of protocols and dashboards.
• Classroom CO2 and ventilation monitor network with a Raspberry Pi gateway (Raspberry Pi).

Each board gets three or four suggestions in the member area.

How it works on Sefism

The public page at /roadmaps/embedded-iot/ shows the full stage list, with the first two stages open to read. Everything on Sefism is free to learn from. Some actions use credits, such as adding a roadmap to your dashboard; new members get starting credits, your first roadmap is free, and if you are learning seriously and run out you can ask for more.

Adding the roadmap opens every stage in the member area. You pick your board and weekly hours, tick off topics and stages, and each topic has a plain explanation, a check question and a prompt to paste into an AI assistant so it quizzes you rather than doing the work. Following the roadmap also unlocks its companion cheat sheet. Stuck on a wiring problem or a project choice? Send Tauseef a question or book a 1:1 session.

The companion cheat sheet

The Embedded systems and IoT cheat sheet mirrors the ten stages with editions for Arduino and ESP32, STM32 and Raspberry Pi. Use it to revise formulas, snippets and the classic mistake for each idea before it costs you a component.

Related on Sefism

• Should I start embedded systems with Arduino, ESP32, STM32 or Raspberry Pi?
• How do I become an embedded systems engineer?
• Which final year project will actually help me get a job?
• Making Embedded Systems and Modern Embedded Systems Programming, used throughout the stages.
• HiveMQ MQTT Essentials for stage 7, and Wokwi for simulating before you wire.

What you can do afterwards

You will have one finished, measured, documented device, a debugging log full of real stories, and working knowledge of C on hardware, buses, an RTOS and an IoT pipeline. That is the portfolio embedded and IoT employers look for, and a strong base for a final year project.

Frequently asked questions

How long does it take to learn embedded systems? This roadmap is about 280 hours: roughly 23 weeks at 12 hours a week, or a year at 5 hours a week. The first two stages can be skimmed if you already know C and basic circuits.

Which board should I start with? Arduino and ESP32 is the cheapest start and has Wi-Fi built in. STM32 is closer to industry work. Raspberry Pi is a Linux computer, best for gateways. Whichever you pick, keep it for a whole stage before buying another.

Do I need to know electronics before starting? No. Stage 2 covers Ohm's law, LED resistors, dividers, logic levels, pull-ups, a shared ground and clean power, which is enough to wire safely for the rest of the roadmap.

Is C still worth learning for embedded in 2026? Yes. Stage 1 opens with why C still runs the hardware, and every later stage depends on registers, masks and flags. Raspberry Pi learners use Python for much of the work, and still learn when C matters.