Self-taught IoT and embedded systems

v0.1

Toolbelt

weeks 1–2 · ~20 h

A working toolchain, a board on your desk, and version control. Embedded work stalls on environment problems more than any other field — solve that once, now.

CourseTimeWhy it's here

Arduino documentationArduino ~8 h Install the toolchain, flash a board, read a pin. Start here even if you will not stay here.

PlatformIOPlatformIO ~6 h A real build system for embedded work — dependency management, multiple boards, and CI that actually works.

Learn Git Branchinginteractive ~6 h Firmware is versioned like software, and knowing exactly which commit is on a device matters more here than anywhere.

Build

chore: initialize device-log

A public repository called device-log with a PlatformIO project that builds and flashes a blink sketch. One commit per study session, and a photo of each build in the README.

Done when

You can flash a board from the command line, not just an IDE button
Your project builds reproducibly from a clean checkout
You can read a datasheet pinout and wire an LED without a tutorial

v0.2

Electronics foundations

weeks 3–12 · ~110 h

Enough electronics to stop destroying components and start debugging circuits. This is the part software people skip and then plateau against.

CourseTimeWhy it's here

MIT 6.002 — Circuits and ElectronicsMIT OCW ~50 h Voltage, current, impedance, RC behaviour, amplifiers. Rigorous, and the reason you will understand why a circuit misbehaves rather than swapping parts at random.

SparkFun tutorialsSparkFun ~30 h Practical, well-illustrated fundamentals — soldering, multimeters, logic levels, power. Do these with parts in hand.

Adafruit LearnAdafruit ~30 h Thousands of free project guides. Use it for sensors and breakout boards — the wiring and driver notes are reliable.

Build

feat: a circuit you understand

Build a sensor circuit on breadboard from a datasheet rather than a tutorial — correct pull-ups, decoupling capacitors, and level shifting where needed. Document the reasoning for each component.

Done when

You can use a multimeter to find a fault instead of guessing
You can explain why a pull-up resistor is needed and choose its value
You have read a real datasheet and extracted the electrical limits that matter
You soldered a joint you would be willing to show someone

v0.3

Microcontrollers and C

weeks 13–22 · ~110 h

The language and the metal. Embedded C is a different discipline from application programming: no allocator you did not write, no exceptions, and hardware that lies.

CourseTimeWhy it's here

CS50x — Introduction to Computer ScienceHarvard ~50 h Take it for the C and memory weeks specifically. Pointers and manual memory are the daily reality here.

ESP-IDF programming guideEspressif ~35 h A production-grade SDK for the ESP32 — GPIO, timers, interrupts, peripherals, and a real build system.

Arduino documentation — language referenceArduino ~15 h Useful as a bridge, but move off the Arduino abstractions during this milestone, not after it.

Adafruit LearnAdafruit ~10 h Driver code for specific sensors when you need a known-good reference implementation.

Build

feat: registers, not wrappers

Rewrite one Arduino sketch using direct register access and hardware interrupts — no digitalWrite, no delay. Measure and document the difference in timing accuracy.

Done when

You can write and reason about an interrupt service routine
You know why delay() is unacceptable in real firmware
You can explain what volatile means and when its absence causes a bug
You debugged something with a logic analyser or oscilloscope trace

v0.4

How the machine works

weeks 23–30 · ~90 h

Below the SDK. Memory maps, the boot sequence, and what actually happens between power-on and your first line of code.

CourseTimeWhy it's here

nand2tetrisfree course ~50 h Build a computer from NAND gates upward — logic, ALU, memory, machine language, assembler. The clearest possible cure for treating hardware as magic.

ESP-IDF — system and memoryEspressif ~25 h Boot flow, partition tables, heap and stack layout, flash memory. Read the memory and startup sections carefully.

Interrupt — Memfault blogMemfault ~15 h Deep, practical articles on linker scripts, fault handlers and memory layout. Written by people who ship firmware.

Build

feat: read your own map file

Analyse your firmware's memory usage from the map file — where every section lives, what your stack high-water mark is — then deliberately cause and diagnose a stack overflow.

Done when

You can read a linker map and say what is consuming your flash and RAM
You caused a hard fault on purpose and traced it back to the offending line
You can describe the boot sequence of your chip from reset to main()
You know your stack high-water mark rather than hoping it is fine

v0.5

Real-time and RTOS

weeks 31–38 · ~90 h

Once a device does more than one thing, timing becomes the hard problem. An RTOS is how the field manages it — and how it introduces a new class of bug.

CourseTimeWhy it's here

FreeRTOS documentationFreeRTOS ~40 h Tasks, scheduling, queues, semaphores, mutexes and priority inversion. The most widely deployed RTOS in the world.

Zephyr Project documentationZephyr ~30 h A modern, Linux-Foundation RTOS with device trees and a proper driver model. Increasingly the professional default.

Interrupt — Memfault blogMemfault ~20 h Articles on RTOS debugging, watchdogs and tracing — the things the official docs assume you already know.

Build

feat: several things at once, correctly

Rebuild your sensor device as a multi-task RTOS application: separate tasks for sampling, processing and communication, with queues between them and a watchdog that recovers from a hung task.

Done when

You can explain priority inversion and how a mutex avoids it
Your tasks communicate through queues rather than shared globals
A deliberately hung task is caught by the watchdog and recovered
You sized each task's stack from measurement rather than guesswork

v0.6

Connectivity

weeks 39–48 · ~110 h

The I in IoT. Radio budgets, protocol choice and unreliable links — devices in the field lose connectivity, and firmware that assumes otherwise fails in the field.

CourseTimeWhy it's here

MQTT EssentialsHiveMQ ~25 h The protocol most IoT fleets speak. Topics, QoS levels, retained messages, last will. Short, clear, free.

ESP-IDF — Wi-Fi and networkingEspressif ~35 h Wi-Fi provisioning, TCP/IP on device, TLS, and the power cost of keeping a radio awake.

The Things Network documentationTTN ~30 h LoRaWAN end to end — the answer when devices are battery-powered, remote and low-bandwidth.

Beej's Guide to Network Programmingfree book ~20 h Sockets from first principles. Read it when the networking stack stops being an abstraction.

MQTT specification and resourcesOASIS ref The protocol itself, when the tutorials disagree.

Build

feat: a device that survives a bad network

Get your device publishing telemetry over MQTT with TLS, buffering readings while offline, backing off on reconnect, and never losing a sample to a dropped connection.

Done when

Pulling the network for ten minutes loses no data
You chose a QoS level deliberately and can justify it
Your device reconnects with exponential backoff rather than hammering the broker
You measured the power cost of transmitting and reduced it

v0.7

Fleet, cloud and security

weeks 49–58 · ~110 h

One device is a project; a thousand is a product. Provisioning, updates and security are what separate the two — and insecure IoT is a genuine public hazard.

CourseTimeWhy it's here

ESP-IDF — OTA and securityEspressif ~40 h Over-the-air updates, secure boot, flash encryption, rollback. Read this before you deploy anything you cannot physically reach.

MQTT Essentials — security and scaleHiveMQ ~20 h Authentication, authorisation, and what a broker does under fleet-scale load.

The Things Network documentationTTN ~25 h Device provisioning, session keys and fleet management for LoRaWAN deployments.

TinyMLcommunity ~25 h Running inference on-device — increasingly how IoT products avoid shipping raw data to a server at all.

Build

feat: updatable in the field

Ship signed OTA updates to your device with rollback on failure, per-device credentials, secure boot enabled, and a dashboard showing fleet health across at least three devices.

Done when

You can update firmware without physical access, and a bad image rolls back automatically
Each device has its own credentials — no shared secret across the fleet
Secure boot and flash encryption are enabled and you understand what they do not protect
You can see which firmware version each device is running

v0.9

Debugging and reliability

weeks 31–66 · alongside · ~60 h

Runs in parallel from v0.5. Embedded bugs are timing-dependent, hardware-adjacent and often unreproducible on a desk — so the debugging skill set is its own discipline.

CourseTimeWhy it's here

Interrupt — Memfault blogMemfault ~30 h Coredumps, fault handlers, watchdogs, logging and firmware observability. The best free writing on shipping reliable firmware anywhere.

Embedded.fmpodcast & blog ~15 h Long-running conversations with working embedded engineers. Good for judgement and vocabulary rather than syntax.

SparkFun tutorials — test equipmentSparkFun ~15 h Getting real value from a logic analyser, oscilloscope and bench supply.

Build

chore: observability on a device with no screen

Give your firmware a real diagnostic story: structured logging over serial, a coredump captured on fault and retrieved later, and an uptime and reset-reason counter reported with every telemetry message.

Done when

You can tell why a device last reset, after the fact
A crash in the field produces something you can actually analyse
You have debugged at least one bug that only appeared under timing pressure

v1.0

Capstone

weeks 59–66 · ~100 h

One device, built properly, deployed somewhere real, and left running. Embedded portfolios are judged on whether the thing survives contact with the physical world.

CourseTimeWhy it's here

ESP-IDF programming guideEspressif — Reference while you build. No new courses at this stage.

Adafruit LearnAdafruit ref Enclosure, power and sensor-specific guidance as practical problems come up.

Interrupt — Memfault blogMemfault ref Revisit the reliability articles before you leave a device unattended for a month.

Build

release: v1.0

A complete IoT product: custom firmware, sensors chosen from datasheets, a real enclosure, battery operation with a measured life, OTA updates, and a dashboard — deployed somewhere real and left running for thirty days.

Done when

It ran unattended for thirty days and you have the telemetry to prove it
You measured actual battery life rather than estimating it
You updated its firmware remotely at least once while it was deployed
The repository documents the hardware, the wiring and the build well enough to reproduce

From blinking an LED to a fleet in the field.

The road, to scale

Ground rules that make this work

Toolbelt

Electronics foundations

Microcontrollers and C

How the machine works

Real-time and RTOS

Connectivity

Fleet, cloud and security

Debugging and reliability

Capstone

Reference shelf