How this works
One resource per module. Not a shortlist — one. Choosing between four "great courses" is how a learning plan dies in week two.
The spine
Six of these modules point at the same book, and that's deliberate rather than lazy. Lessons in Electric Circuits by Tony R. Kuphaldt — hosted as the All About Circuits textbook, released under the Design Science License — is the best free electrical engineering text that exists. Six volumes: DC, AC, Semiconductors, Digital, Reference, Experiments. It's written for someone who wants to actually understand rather than pass an exam, and you can read a chapter in twenty minutes.
A different resource appears only where the book is genuinely weaker: practical measurement, digital-logic intuition, and PCB reality. Five outside resources total across fourteen modules. If you find yourself opening a seventh tab, that's procrastination wearing a lab coat.
The pace
Three to four hours a week. ~50 hours total, so about 14 weeks if you never skip and 20 if you're honest about life. That's a legitimate semester of EE fundamentals, done on your own schedule, for free.
Don't front-load. This runs underneath the 2730 build, not instead of it — every module is chosen because it explains something you have already hit or are about to hit on the bench.
The rule that makes it stick
Read the chapter, then go measure the thing on your breadboard. Ohm's law is abstract until you put a multimeter across a resistor you chose and see the number you predicted. You have the parts. Use them — that's the entire difference between this working and this being a YouTube playlist you feel guilty about.
How the content comes out of it
Each module has a hook — the one counterintuitive thing in it that makes a good standalone long-form video. These are deliberately detached from the 2730 series so they can live on their own and pull a different audience: people searching "why do capacitors go near the chip" rather than people following your build.
One long-form per module, roughly one a week. Fourteen weeks, fourteen videos, and by the end you have a fundamentals playlist that keeps earning search traffic long after the build series ends. That's the asset.
What this is not
- Not a degree. No electromagnetics field theory, no Laplace transforms, no control systems. You can add those later if you ever need them; almost nobody in embedded does.
- Not a certification path. Nothing here issues a credential. The credential is that you can debug a board.
- Not sequential-optional. Modules 01–07 build on each other properly. 08 onward can be reordered.
Khan Academy (only the maths you actually need) · Falstad Circuit Simulator (in-browser, for intuition) · EEVblog Fundamentals Friday (measurement and instruments) · Ben Eater (digital logic through to a working CPU) · Rick Hartley (why real boards fail).
Units, notation, and what the words mean
Charge, voltage, current, resistance, power. Every one of these has a precise definition and most people carry a vague analogy instead. Fix that first; everything downstream depends on it.
Lessons in Electric Circuits — Volume I (DC)
allaboutcircuits.com/textbook/direct-current/ — chapters 1 & 2
Kuphaldt starts with atoms and gets to Ohm's law without ever hand-waving. Chapter 1 covers charge, conductors, voltage and current; chapter 2 covers Ohm's law, power, and scientific notation with the metric prefixes you'll live inside.
Scope: Ch 1 (Basic Concepts) · Ch 2 (Ohm's Law). Skip nothing. Read, don't skim.
The specific things worth nailing here: voltage is a difference, never an absolute. There is no such thing as "the voltage at this pin" without a reference — which is why "ground" is the most abused word in electronics and why your MAX7219 failed. A 3.3 V logic high and a 5 V logic high are only different because they're both measured against a shared ground; the moment the grounds aren't shared, none of it means anything.
And metric prefixes are not decoration. µF, nF, pF span six orders of magnitude and datasheets switch between them mid-table. A 100 nF and a 100 µF capacitor do completely different jobs and look nearly identical in a parts drawer.
- Say precisely what a volt, an amp, an ohm and a watt are, without analogy
- Read any datasheet's absolute-maximum table and know what it's telling you
- Explain exactly why the 3.3 V Nano and the 5 V matrix didn't work
"There is no such thing as voltage at a point."
Open with a multimeter probing a single pin and reading nothing. Then attach the black lead. The reveal is that every voltage you have ever measured was a subtraction — and that's why grounding problems destroy boards.
Circuit analysis that actually gets used
Series, parallel, Kirchhoff's laws, voltage dividers, Thévenin. Ninety percent of the circuit maths you will ever do in embedded work is in this module.
Khan Academy — Electrical Engineering: Circuit Analysis
khanacademy.org/science/electrical-engineering
Chosen over the book for this one module specifically because it has practice problems with instant feedback. Circuit analysis is a skill, not knowledge — you get it by doing thirty divider problems, not by reading about dividers. Khan's format is the fastest path to that.
Scope: "Circuit analysis" unit — resistor circuits, DC circuit analysis, natural and forced response. Skip the op-amp section for now.
Run it alongside a simulator
Open falstad.com/circuit in a second tab. It's a free in-browser circuit simulator that draws current as moving dots and lets you probe any node instantly. Build every problem you solve. The feedback loop between "I calculated 3.3 V" and "the simulator says 3.3 V" is what converts formulas into intuition, and it takes seconds instead of a breadboard rebuild.
The voltage divider. It's how you read a battery's level on a 3.3 V ADC when the battery is 4.2 V. It's how every level shifter you'll build works. It's how a potentiometer works. Master it until you can do it in your head, because you'll need it on your Phase A power circuit.
- Calculate any resistor value you need instead of copying one from a tutorial
- Design a battery-monitoring divider that won't exceed your ADC's input range
- Work out why a circuit that "should" work is sagging under load
"Two resistors are the most important circuit in the world."
Voltage dividers are inside your volume knob, your battery gauge, your touchscreen and every level shifter. Show four completely different-looking devices, then reveal the same two resistors in all of them.
Measurement, and how your instruments lie
You cannot debug what you cannot see. This module is the highest practical return per hour in the entire pathway, and it's the one most self-taught people skip.
EEVblog — Fundamentals Friday
youtube.com/@EEVblog — search the channel for "Fundamentals Friday"
Dave Jones covering multimeters, probing technique, what your meter's input impedance does to the circuit, oscilloscope basics and the mistakes that produce measurements which are confidently wrong. No textbook teaches this well because it's a craft, not a theory.
Scope: multimeter basics, how not to blow up your meter, probing and ground leads, scope basics. Ignore the teardowns for now — they're fun, they're not this.
What matters here: the act of measuring changes the circuit. Your meter has finite input impedance, your probe has capacitance, and your ground lead is an antenna. Measuring across a high-impedance node with a cheap meter gives you a number that is real and also wrong.
Also learn continuity mode properly. Half the "my circuit doesn't work" problems in your OLED session would have been found in thirty seconds with continuity testing — a breadboard contact that looks seated and isn't is the single most common hardware fault there is.
A ₹500 multimeter does everything in this module. You do not need an oscilloscope to learn embedded systems, and you especially don't need one before you understand what you'd point it at. Revisit that decision when you're debugging I²C timing on the Phase B board and not before.
- Find a bad breadboard contact in seconds instead of rewiring the whole board
- Measure current correctly, which most people get wrong the first time and blow a fuse
- Know when your measurement is being distorted by the act of measuring it
"Your multimeter is lying to you, and here's exactly when."
Measure the same node two ways and get two different answers. Then explain input impedance. Strong hook because the viewer has a meter and has never questioned it.
Capacitors, inductors, and time
Resistors are boring because they have no memory. Capacitors and inductors store energy, which means circuits gain a time dimension — and that's where all the interesting behaviour lives.
Lessons in Electric Circuits — Volume I (DC)
allaboutcircuits.com/textbook/direct-current/ — chapters 13, 15 & 16
Capacitors, inductors, and RC/L-R time constants in one coherent run. Kuphaldt's treatment of the time constant is unusually clear — he builds it from what the component physically does rather than dropping an exponential on you.
Scope: Ch 13 (Capacitors) · Ch 15 (Inductors) · Ch 16 (RC and L/R Time Constants).
The payoff you'll feel immediately is decoupling capacitors. Every board you look at has a 100 nF capacitor sitting next to every IC's power pin, and most people place them because tutorials say to. The real reason: when a chip switches, it demands current faster than the power supply's trace inductance can deliver it. The capacitor is a tiny local battery that supplies that instantaneous spike. Place it far away and the trace inductance defeats the whole point.
That's a Phase A design decision you're about to make, and getting it wrong produces intermittent faults that look exactly like software bugs.
- Explain why decoupling caps must be physically close, not just present
- Calculate an RC time constant for a debounce circuit instead of guessing
- Pick between a 100 nF and a 10 µF and say why
- Understand why your boost converter needs the capacitor values the datasheet specifies
"Why every chip on every board has the same tiny capacitor next to it."
Zoom across four different PCBs — a phone, a router, an Arduino, your own board — finding the same 100 nF part in the same place each time. Then explain what happens in the nanosecond a chip switches.
AC, reactance, and impedance
You're building a DC device, so this looks skippable. It isn't — every digital signal is an AC signal wearing a square hat, and every signal-integrity problem you will ever have lives here.
Lessons in Electric Circuits — Volume II (AC)
allaboutcircuits.com/textbook/alternating-current/ — chapters 1, 2, 3, 4 & 5
Volume II handles complex numbers in context, which is the only way that maths ever makes sense. Chapter 2 teaches you exactly as much complex arithmetic as you need and not one page more — then chapters 3–5 immediately spend it on reactance and impedance.
Scope: Ch 1 (Basic AC) · Ch 2 (Complex Numbers) · Ch 3–5 (Reactance and Impedance: R, L, C).
Khan Academy's complex-numbers unit is the fallback, and the only place in this pathway where I'd send you to a second source for the same topic. Cap it at one hour. You need j, magnitude, phase, and rectangular↔polar conversion — nothing else.
The idea that reframes everything: a square wave is a sum of sine waves. Your 400 kHz I²C clock isn't a 400 kHz signal — its sharp edges contain energy at tens of megahertz. That's why long jumper wires broke your OLED at 400 kHz and worked at 100 kHz, why traces become antennas, and why "it works on the breadboard but not on the PCB" happens to everyone exactly once.
- Explain why wire length matters at high clock rates when DC theory says it shouldn't
- Read an impedance spec on a datasheet and know what it constrains
- Understand why your I²C pull-up value interacts with bus capacitance
"Your square wave is a lie."
Show a clean square wave, then decompose it into sine waves one harmonic at a time until it reassembles. Then connect it: this is why a 400 kHz signal emits at 40 MHz, and why your wire length broke a working circuit.
Filters and the frequency domain
One resistor and one capacitor make a filter. That circuit is inside your audio path, your ADC input, your power rail and your debounce logic — usually without anyone calling it a filter.
Lessons in Electric Circuits — Volume II (AC)
allaboutcircuits.com/textbook/alternating-current/ — chapter 8
Low-pass, high-pass, band-pass, band-stop, and resonance, built from the reactance you just learned. Short chapter, high density, and it's the direct prerequisite for making sense of audio and sensor signals.
Scope: Ch 8 (Filters). Add Ch 6 (Resonance) if you're enjoying it.
Build every filter in Falstad and sweep the frequency. Watching the output amplitude collapse past the cutoff does more for your intuition in five minutes than the derivation does in an hour.
Concretely for your build: the MAX98357A's output wants a filter before it hits certain speakers, your INMP441 microphone data needs DSP filtering before it's useful, and any analogue sensor you ever read wants an RC low-pass in front of the ADC to stop it aliasing noise into your samples.
- Design an RC low-pass for a given cutoff frequency from scratch
- Recognise the same filter topology across audio, power and sensor circuits
- Understand why an unfiltered ADC input reads garbage that looks like a code bug
"One resistor, one capacitor, and suddenly you have a filter."
Play audio through an RC filter and sweep the cutoff live so viewers hear the treble vanish. Same two components as the divider from module 02 — only now one of them cares about time.
Diodes, LEDs, and making power behave
The first component with an opinion about direction. Everything about power supplies, protection and every LED you have ever lit starts here.
Lessons in Electric Circuits — Volume III (Semiconductors)
allaboutcircuits.com/textbook/semiconductors/ — chapter 3
Diode behaviour, forward voltage, rectifiers, Zeners, and LED characteristics in one chapter. Covers the reverse-recovery and clamping behaviour that explains flyback diodes — which you need the moment you drive anything inductive.
Scope: Ch 3 (Diodes and Rectifiers). Sections on rectifier configurations can be skimmed unless you're doing mains.
The immediately applicable bit: an LED is a current device, not a voltage device. Its forward voltage barely moves while its current changes by orders of magnitude, which is why it needs a series resistor and why the resistor value is calculated from the current you want, not the voltage you have. Most beginners get a working LED and never understand why the resistor is there.
The other one: those 1N4148 diodes in your keypad matrix are doing exactly the job this chapter describes — enforcing one-way current flow so pressing three keys doesn't create a phantom fourth. You'll have built that circuit around day 9. This is the chapter that explains it.
- Size an LED resistor from the datasheet instead of using 220 Ω because everyone does
- Explain keypad ghosting and why diodes fix it
- Add reverse-polarity protection to your own board so one wrong connection doesn't kill it
"Why your LED needs a resistor — and why 220 Ω is usually the wrong answer."
Everyone copies that value. Show the datasheet, do the actual calculation for three different LEDs, and get three different answers. Ends with an LED dying on camera when you skip it.
Transistors as switches
The component that makes computing possible. You don't need amplifier design — you need to understand the switch, because that's what every one of the billions inside your ESP32 is doing.
Lessons in Electric Circuits — Volume III (Semiconductors)
allaboutcircuits.com/textbook/semiconductors/ — chapters 4 & 6
BJTs in chapter 4, field-effect transistors in chapter 6. Read the switching sections properly and skim the amplifier biasing material — you can come back for it if you ever build analogue audio, and you probably won't.
Scope: Ch 4 (Bipolar Junction Transistors) — focus on "Transistor as a switch". Ch 6 (Insulated-Gate FETs) — MOSFET switching, gate threshold, logic-level parts.
The distinction that matters in practice: a BJT is current-controlled and a MOSFET is voltage-controlled. That's why CMOS logic — and therefore every processor — uses MOSFETs: a voltage-controlled switch draws essentially no steady-state current, so a chip with billions of them doesn't melt.
The trap that catches everyone: logic-level MOSFETs. A standard MOSFET needs ~10 V on the gate to turn fully on. Your ESP32 outputs 3.3 V. Drive a non-logic-level part from a microcontroller pin and it half-turns-on, dissipates heat, and behaves erratically. Check VGS(th) before you buy.
- Switch a load bigger than a GPIO pin can handle, correctly
- Pick a MOSFET that will actually turn on from 3.3 V
- Explain why a CPU is "just" a very large number of switches — and mean it
- Build a level shifter from first principles rather than buying a module
"The switch with no moving parts that runs the entire world."
Start with a mechanical relay clicking. Then a transistor doing the same job silently, a million times faster. Then the number of them in the chip on the desk in front of you.
Boolean algebra and logic gates
Where electronics becomes computation. You've done this as a CS student — this time you're doing it knowing what's physically underneath each gate.
Lessons in Electric Circuits — Volume IV (Digital)
allaboutcircuits.com/textbook/digital/ — chapters 1, 2, 3, 7 & 8
Numeration systems through to Karnaugh maps, but crucially chapter 3 covers logic gates as physical circuits — propagation delay, fan-out, TTL vs CMOS input thresholds. That physical framing is what makes this different from the digital logic you already know.
Scope: Ch 1–2 (Numeration, Binary Arithmetic — skim, you know these) · Ch 3 (Logic Gates — read fully) · Ch 7 (Boolean Algebra) · Ch 8 (Karnaugh Mapping).
The part that's new to you: logic levels are ranges, not values. A "1" isn't 3.3 V — it's anything above VIH, and a "0" is anything below VIL, with a forbidden band between where behaviour is undefined. A floating input sits in that band and reads as random. That's the entire reason pull-up and pull-down resistors exist, and why your I²C bus needs them at all.
Also: propagation delay is real. Every gate takes time. Chain enough of them and you have a maximum clock frequency — which is where a processor's GHz number actually comes from.
- Size an I²C pull-up resistor properly instead of copying 4.7 kΩ
- Explain what a floating pin actually does and why it's not zero
- Minimise a logic expression with a K-map
- Read the DC characteristics table of any digital datasheet
"A '1' is not 3.3 volts."
Show a floating input flickering randomly on a scope or an LED. Then explain the forbidden band. Genuinely surprising to most software people, and it explains a class of bug they've all hit.
Memory, clocks, and state
Gates alone can't remember. Latches, flip-flops and registers are how a circuit gains state — and this is the hinge between electronics and computing.
Ben Eater — Building an 8-bit computer (parts 1–20)
eater.net/8bit — full playlist on YouTube, schematics and parts lists on the site
A 44-part, ~13-hour series building a programmable computer from logic gates on breadboards. Parts 1–20 cover the 555 clock, SR latch, D latch, D flip-flop, bus architecture, tri-state logic and registers. Nobody explains sequential logic better, and he builds it physically so you watch the abstraction become wire.
Scope: parts 1–20 (clock through registers and ALU). You do not need to buy the kit — watching and following the schematics is the point. Buy it later if you want a project.
This is where the pathway stops being a refresher and starts being genuinely new territory for a CS graduate. You know what a register is in software. Watching one get built from two cross-coupled NAND gates changes what the word means to you permanently.
You'll be tempted to run Eater at 1.5×. Don't. He builds at a deliberate pace and the whole value is following the reasoning, not collecting the conclusion. This is the single densest module here and worth two weeks.
- Explain how a circuit made of stateless gates stores a bit
- Understand what a clock edge physically does
- Reason about setup and hold time, and why timing violations are real
- Design a finite state machine in hardware, not just in code
"How do you make a circuit remember something?"
Two NAND gates wired into each other. That's it — that's one bit of memory. Build it live, flip it, show it holding. The moment it stays after you remove the input is the whole video.
From gates to a working CPU
The payoff module. ALU, RAM, program counter, control logic, microcode — the complete path from a NAND gate to a machine that runs a program you wrote.
Ben Eater — Building an 8-bit computer (parts 21–44)
eater.net/8bit — continue the same playlist
ALU design and construction, RAM module, program counter, output display, CPU control logic, microcode, instruction set expansion, flags register, conditional jumps, and finally Turing completeness. Same series, no new resource needed.
Scope: parts 21–44. Two's complement, ALU, RAM, control logic, microcode, conditional jumps.
For someone with a CS degree who has never seen the hardware underneath, this closes a loop that most software engineers never close. You will finish this able to explain — with no gaps and no hand-waving — how a line of code becomes voltage on a wire and back again.
That's also the single most valuable thing you can claim when positioning a PCB design agency staffed by a CS person. Not "I learned electronics" — "I built a CPU from gates and I can show you every part of it."
- Explain the full stack from transistor to instruction with no gaps
- Read a microprocessor datasheet's timing diagrams and understand them
- Understand what an ESP32 is actually doing, rather than treating it as magic
- Teach the entire chain, which is the real test of whether you have it
"I have a computer science degree and I had never seen this."
The most honest hook available to you, and the most shareable. The gap between "I can write code" and "I know what happens" is real, most developers feel it, and almost nobody says it out loud.
Why real boards fail
Everything above works in theory and on a breadboard. This module is the gap between that and a board that works reliably — and it's the one that separates hobbyists from designers.
Rick Hartley — "How to Achieve Proper Grounding"
youtube.com/watch?v=ySuUZEjARPY — free full-length seminar
Hartley has 50+ years in PCB design for avionics and telecoms. The talk's core argument reframes everything: energy in a PCB trace doesn't travel through the copper — it travels in the electromagnetic field around the trace. Once that lands, grounding, stack-up, return paths and EMI stop being rules to memorise and become consequences of one idea.
Scope: the full talk. Long, dense, worth every minute. Watch it twice — once now, once before you route the Phase B board.
Directly load-bearing for you. Phase B is a 4-layer board with DDR memory. Return path discontinuities, stack-up choice and reference-plane placement are the difference between a board that boots and an expensive coaster. Hartley's talk is the reason to not learn that lesson at ₹6,000 a time.
It also explains breadboard behaviour you've already met. A breadboard has no ground plane, long uncontrolled return paths, and significant stray capacitance between rows. That's why 400 kHz I²C died on long jumpers and 100 kHz survived — you were already fighting the physics in this talk.
- Explain why "ground" is a reference plane, not a wire
- Choose a layer stack-up deliberately instead of accepting the default
- Predict where a return path will break before you route it
- Debug intermittent faults that only appear at speed
"Electricity doesn't travel through the wire."
The strongest counterintuitive claim in the whole pathway. Almost everyone believes electrons flowing down copper carry the energy. They don't — the field around the trace does. Handle it carefully and cite the source; this one gets argued about in comments, which is good for reach.
The microcontroller interface layer
The specific electrical knowledge that sits exactly where your firmware meets the world. No single textbook covers this well — it lives in datasheets, which is itself the lesson.
The ESP32-S3 Datasheet + Technical Reference Manual
espressif.com — Documents → ESP32-S3 Series Datasheet, and the Technical Reference Manual
Reading a real datasheet properly, once, is worth more than another course. The chip on your desk, the electrical characteristics you actually have to respect. Every module above gave you the vocabulary to read this — this is where you spend it.
Scope: Absolute maximum ratings · DC characteristics (VIH, VIL, IOH, IOL) · GPIO section · ADC characteristics and its non-linearity · power consumption by mode.
What to extract
| Find this | Because |
|---|---|
| Max current per GPIO pin | It's small — around 40 mA absolute max, far less recommended. This is why you need a transistor to drive anything real |
| Total current across all pins | A separate, lower limit that people blow past by driving many LEDs at once |
| VIH / VIL thresholds | Tells you exactly what a 5 V sensor will do to a 3.3 V input, in numbers rather than folklore |
| Which pins are input-only | On the S3, some are. Assigning an output to one produces a silent failure |
| ADC non-linearity | ESP32 ADCs are famously non-linear at the extremes. Affects your battery gauge directly |
| Strapping pins & boot behaviour | You already met this at 11pm when a jumper on GPIO0 held the board in download mode |
- Design a pin assignment that respects real electrical limits, not guesses
- Level-shift correctly between 3.3 V and 5 V devices
- Calibrate an ADC reading instead of trusting the raw number
- Read any chip's datasheet — the skill transfers completely
"I read the whole ESP32 datasheet so you don't have to — here are the 6 numbers that matter."
Extremely searchable, genuinely useful, and it positions you as someone who reads primary sources. Repeat the format for every chip you use; it becomes a series on its own.
The bridge to TinyML
This is why the whole pathway was worth doing. Machine learning on microcontrollers is a constraints problem, and you now understand the constraints from the physics up.
Harvard TinyML — the course you're already using
edX — Tiny Machine Learning (audit track is free)
You're already running this on the ML side. Nothing new to add — the point of this module is that you now arrive at it with the hardware layer underneath instead of treating the device as an abstraction.
Scope: continue as planned. Reread the deployment sections after finishing modules 09–13.
What changes now that you've done the rest
| TinyML concept | What the pathway gave you |
|---|---|
| Quantisation to int8 | Module 09 — fixed-width binary and why hardware prefers integer maths |
| Memory-constrained inference | Modules 10–11 — you built RAM from flip-flops. You know why it's expensive |
| Sensor preprocessing / MFCC | Modules 05–06 — the frequency domain, filters, sampling |
| Power budgets for always-on | Modules 04, 13 — duty cycling, sleep modes, real current draw |
| Latency and real-time guarantees | Module 09 — propagation delay, clock rates, why timing is physical |
| Why models run on an MCU at all | Module 11 — you know precisely what the machine does per cycle |
Most people doing TinyML treat the microcontroller as a small computer that runs Python badly. You'll be one of the few who can say why a model fits or doesn't before trying it — and that's a genuinely rare position to argue from, in content and in a room.
"Why machine learning on a $3 chip is a physics problem, not a software problem."
The capstone video, and the one that ties the hardware channel to the AI channel. Cross-post it to both — it's the only piece of content that legitimately belongs on each.
The schedule
Fourteen weeks at 3–4 hours. One long-form video per module. Everything free.
| # | Module | Resource | Hrs |
|---|---|---|---|
| 01 | Units & notation | LiEC Vol I, ch 1–2 | 2 |
| 02 | Circuit analysis | Khan Academy + Falstad | 4 |
| 03 | Measurement | EEVblog Fundamentals Friday | 3 |
| 04 | Capacitors & inductors | LiEC Vol I, ch 13, 15, 16 | 3 |
| 05 | AC & impedance | LiEC Vol II, ch 1–5 | 4 |
| 06 | Filters | LiEC Vol II, ch 8 | 3 |
| 07 | Diodes & power | LiEC Vol III, ch 3 | 3 |
| 08 | Transistors | LiEC Vol III, ch 4, 6 | 4 |
| 09 | Boolean & gates | LiEC Vol IV, ch 1–3, 7–8 | 3 |
| 10 | Sequential logic | Ben Eater, parts 1–20 | 6 |
| 11 | Gates to CPU | Ben Eater, parts 21–44 | 7 |
| 12 | Why boards fail | Rick Hartley — grounding | 3 |
| 13 | Interface layer | ESP32-S3 datasheet + TRM | 4 |
| 14 | TinyML bridge | Harvard TinyML (edX audit) | — |
| Total | 6 sources | ≈ 49 |
The weekly loop
- Read / watch the module's one resource. 2–3 hrs, split however suits you.
- Measure something. 20 min on the breadboard proving one claim from the module. Non-negotiable — this is what makes it stick.
- Record the long-form. Take the hook, teach the one counterintuitive thing, show the measurement. 20–40 min of video, low production.
- Cut one reel from the same footage, ending with "full video linked, it's free."
These videos are deliberately detached from the 2730 build, and that's the point. The build series pulls people who like watching someone make something. The fundamentals series pulls people searching a specific question at 1am. Different intent, different discovery path, same channel — and the fundamentals videos keep earning views for years while build content peaks and fades.
You already have the 2730 build, the AI series, the roast funnel, the ML track and a day job. This is a sixth commitment. It's the cheapest of them — 3 hours of reading and one low-production video — but it's still a commitment.
If a week gets crushed, skip the video and keep the reading. The learning is the point; the content is the by-product. Inverting that is how this turns into a chore you resent.