Harness Labs / Learn & Build
Start curious.
Build something.
Learn the code. Understand the circuit. Make an idea tangible, one small build at a time.
From a first line of code to a physical idea
A concept illustration. Your first build runs in a browser.
No hardware?
You can start here.
Follow the stages in order, or jump to the skill you need. Each pairs a lesson with a small build. Papers and deeper reading are there when you want them.
Browser / simulator first · Optional USB-powered hardware · Self-paced
Time, access & safety
About 60–95 hours for selected core lessons and builds, self-paced. Estimates exclude full optional courses, physical fabrication, and advanced on-device ML.
Time estimates are editorial planning estimates for selected lessons and builds. They are not course lengths or a promise of proficiency.
Start with virtual circuits. Keep optional physical builds to USB-powered, low-voltage development boards. No mains wiring or battery fabrication.
Full access & safety notes ↓8 stages / one connected project
A little theory.
A working next step.
Start with the first lesson, then try the build. Open any stage to explore.
No matching resources.
Try a broader search, another level, or all formats.
01Code the basicsTurn a small idea into a working decision rule.
What you’ll learn
Start: Run a tiny Python example in your browser.
- Use variables, functions, conditions, and loops.
- Keep sample data separate from decisions.
- Save a recoverable revision and explain a change.
No prior experience needed.
Idea → requirements
Use AI as a study partner: Ask AI to explain one error and propose a smaller example. Run the example and explain the fix yourself.
Start with this lesson
-
VideoBeginner
Your first Python lesson (opens in a new tab)
Learn functions and variables with Harvard’s video and notes.
Harvard CS50 · Free learning access · No account to read · No hardware purchase
Access & lesson details
- Full title
- CS50P: Week 0, Functions and Variables
- Start here
- Watch the opening lesson and run each small example yourself.
- Account
- No login needed to watch/read. Official submission and cs50.dev workflow uses a GitHub account and authorization; course feedback instructions also call for an edX account. First-session practice can stay in Pyodide.
- Hardware
- Computer/browser only.
- Plan for
- Estimated 3–5 hours for Week 0 and practice; 40–80 hours for the full course and projects is a separate optional commitment. Learning estimate, not a verified video runtime.
- Before this
- None; the course explicitly welcomes learners without prior programming experience.
- Good to know
- The entire ten-week course is not a prerequisite for the first circuit. Follow course academic-honesty rules for submitted assignments.
- Checked
- 2026-10-20
More ways to learn 4 resources
-
ToolBeginner
Try Python in your browser (opens in a new tab)
Run your first lines of Python without installing anything.
Pyodide project · Free learning access · No account · Browser only
Access & lesson details
- Full title
- Pyodide browser Python console
- Start here
- Type 2 + 2, then try a variable and print its value.
- Account
- No account or login was requested in the live browser check.
- Hardware
- Computer/browser only; no electronics.
- Plan for
- Estimated 20–45 minutes for arithmetic, strings, variables, and one small function. Learning estimate, not a verified video runtime.
- Before this
- A modern browser; no programming experience required for the first arithmetic and variable exercises.
- Good to know
- Treat this as a scratch console, not durable project storage. Browser Python has compatibility limits; it is not a full replacement for desktop Python or a hardware-programming IDE.
- Checked
- 2026-10-20
-
CourseBeginner
Save a version with GitHub (opens in a new tab)
Practice commits and branches on harmless sample files.
GitHub Skills · Free learning access · Account for exercise · Browser only
Access & lesson details
- Full title
- GitHub Skills: Introduction to GitHub
- Start here
- Read the exercise, then decide whether to use a free practice account.
- Account
- GitHub account required to copy and run the exercise; reading instructions is public.
- Hardware
- Computer/browser only.
- Plan for
- Estimated 45–90 minutes including writing a useful project README. Provider states its basic exercise takes less than one hour. Learning estimate, not a verified video runtime.
- Before this
- None beyond basic browser use.
- Good to know
- Use harmless practice content in a public repository. Never commit Wi-Fi passwords, API keys, personal recordings, or private lab data.
- Checked
- 2026-10-20
-
GuideBeginner
Understand Git (opens in a new tab)
Learn what a commit, branch, and repository actually mean.
Git project / Scott Chacon and Ben Straub · Free learning access · No account to read · Terminal for practice
Access & lesson details
- Full title
- Pro Git: Getting Started and Git Basics
- Start here
- Read Getting Started and the first Git Basics sections.
- Account
- None to read or use Git locally.
- Hardware
- Browser for reading; Git-capable local or existing cloud terminal for hands-on command-line practice later.
- Plan for
- Estimated 3–5 hours for selected early chapters with practice. Learning estimate, not a verified video runtime.
- Before this
- Basic files/folders; terminal basics helpful for doing the command-line exercises.
- Good to know
- Do not make Git installation or a cloud account a day-one blocker.
- Checked
- 2026-10-20
-
DocumentationIntermediate
Look up a Python concept (opens in a new tab)
Use the official reference after the first lessons.
Python Software Foundation · Free learning access · No account to read · No hardware purchase
Access & lesson details
- Full title
- The Python Tutorial
- Start here
- Find the section for a concept your program needs.
- Account
- None.
- Hardware
- Browser only for reading; Pyodide can run many elementary examples.
- Plan for
- Estimated 2–4 hours of selected sections; use as-needed rather than cover-to-cover. Learning estimate, not a verified video runtime.
- Before this
- Basic programming concepts, gained from the introductory lessons.
- Good to know
- The tutorial explicitly assumes general programming knowledge. It should not be the only first resource for a complete beginner.
- Checked
- 2026-10-20
No resources in this stage match your filters. The build is still here when you’re ready.
02Simulate a circuitMake an input change an indicator.
What you’ll learn
Start: Build a virtual LED circuit, then add a button.
- Identify power, ground, signal, and current limiting.
- Read a simulated analog input.
- Distinguish a raw sensor value from a measured physical quantity.
Before this: foundations
Requirements → circuit sketch
Use AI as a study partner: Ask AI to review your labeled circuit and list assumptions. Check every pin, voltage, and resistor calculation against the source documentation.
Start with this lesson
-
ToolBeginner
Build a virtual circuit (opens in a new tab)
Try an LED, button, and sensor input without buying parts.
Autodesk Tinkercad · Free learning access · Account to create · Browser only
Access & lesson details
- Full title
- Tinkercad: Learn Circuits
- Start here
- Open an introductory LED circuit lesson.
- Account
- Sign-in required to create and save work; private-by-default designs according to Autodesk's guide.
- Hardware
- Browser/internet only; no board or components needed.
- Plan for
- Estimated 3–5 hours for an LED, resistor, pushbutton, and sensor-input lesson. Learning estimate, not a verified video runtime.
- Before this
- Basic voltage/current and breadboard ideas; coding can start with blocks.
- Good to know
- Simulation covers supported parts and libraries, not every Arduino shield or real-world electrical behavior.
- Checked
- 2026-10-20
More ways to learn 3 resources
-
GuideBeginner
Voltage, current, resistance (opens in a new tab)
Understand the relationships before wiring a circuit.
SparkFun · Free learning access · No account to read · No hardware purchase
Access & lesson details
- Full title
- SparkFun: Voltage, Current, Resistance, and Ohm's Law
- Start here
- Read the LED example and calculate a suitable current-limiting resistance.
- Account
- None for reading.
- Hardware
- No hardware for reading/calculations; reproduce the example in simulation instead of buying its listed parts.
- Plan for
- Estimated 60–90 minutes including a few resistor/current calculations. Learning estimate, not a verified video runtime.
- Before this
- Basic arithmetic and rearranging a simple equation.
- Good to know
- The article's physical experiment uses a battery and meter. Keep this curriculum simulator-first, then manufacturer-supported USB low-voltage hardware only.
- Checked
- 2026-10-20
-
GuideBeginner
Read a breadboard (opens in a new tab)
See which holes connect and trace the current path.
SparkFun · Free learning access · No account to read · No hardware purchase
Access & lesson details
- Full title
- SparkFun: How to Use a Breadboard
- Start here
- Trace one complete circuit through the virtual breadboard rows.
- Account
- None for reading.
- Hardware
- No purchase required; use a virtual breadboard.
- Plan for
- Estimated 45–75 minutes including tracing a simple virtual circuit. Learning estimate, not a verified video runtime.
- Before this
- Understand a closed circuit and power/ground.
- Good to know
- Check rail connectivity on the actual breadboard later; do not assume rail labels or both sides imply electrical connections.
- Checked
- 2026-10-20
-
GuideBeginner
Understand sensor errors (opens in a new tab)
Learn why raw readings and accurate measurements differ.
Adafruit · Free learning access · No account to read · No hardware purchase
Access & lesson details
- Full title
- Adafruit: Calibrating Sensors
- Start here
- Compare an offset error with a scale error using invented readings.
- Account
- None to read; account only for optional favorites.
- Hardware
- No hardware to learn the concepts or use synthetic readings. Real calibration later needs an appropriate reference.
- Plan for
- Estimated 1–2 hours with a synthetic offset/scale correction exercise. Learning estimate, not a verified video runtime.
- Before this
- Know what a sensor reading represents; basic arithmetic.
- Good to know
- Simulation and synthetic data do not prove real sensor accuracy. Skip hot/cold or hazardous physical experiments in this beginner path.
- Checked
- 2026-10-20
No resources in this stage match your filters. The build is still here when you’re ready.
03Write the firmwareMake your virtual gadget respond predictably.
What you’ll learn
Start: Run an ESP32 MicroPython example in Wokwi.
- Read inputs and drive an indicator with MicroPython.
- Use named states and a non-blocking loop.
- Handle reset and missing input deliberately.
Before this: circuits
Circuit sketch → firmware
Use AI as a study partner: Ask AI to suggest missing state transitions and failure cases. Compile/run the code and replay those cases; generated behavior is not evidence.
Start with this lesson
-
DocumentationBeginner
Simulate an ESP32 (opens in a new tab)
Run MicroPython on a virtual microcontroller.
Wokwi · Free personal projects · No account to read · No hardware purchase
Free projects are public. Keep code and data non-sensitive.
Access & lesson details
- Full title
- Wokwi: ESP32 Simulation
- Start here
- Open the linked MicroPython template and change Blink.
- Account
- Documentation/examples are public. An account is useful for keeping a continuing project; exact anonymous-save limits were not live-tested.
- Hardware
- No physical ESP32 required.
- Plan for
- Estimated 2–4 hours for Blink, a button, serial output, and one modification. Learning estimate, not a verified video runtime.
- Before this
- Basic variables, loops, functions, and circuit connections.
- Good to know
- Bluetooth is not simulated. Timing/peripherals are incomplete approximations; successful simulation is not a hardware pass.
- Checked
- 2026-10-20
More ways to learn 4 resources
-
DocumentationBeginner
Try Arduino later (opens in a new tab)
Explore the optional C++ route for timing and buttons.
Arduino · Free learning access · No account to read · No hardware purchase
Access & lesson details
- Full title
- Arduino: Built-in Examples
- Start here
- Read Blink Without Delay; keep its board assumptions separate.
- Account
- None to read. Use the simulator's own account rules if saving a virtual build.
- Hardware
- Use a simulated Arduino Uno for these beginner examples; no purchase needed.
- Plan for
- Estimated 3–5 hours for the selected examples and one combined sensor monitor. Learning estimate, not a verified video runtime.
- Before this
- Basic programming and simple circuits; Arduino examples use C++ syntax.
- Good to know
- Board pins and voltage assumptions differ from ESP32. Do not copy Arduino Uno wiring onto ESP32 without checking the board documentation.
- Checked
- 2026-10-20
-
DocumentationBeginner
Add a virtual sensor (opens in a new tab)
Extend your gadget with simulated temperature and humidity.
Wokwi · Free personal projects · No account to read · No hardware purchase
Free projects are public. Keep code and data non-sensitive.
Access & lesson details
- Full title
- Wokwi: DHT22 Temperature and Humidity Sensor
- Start here
- Change one simulated reading and inspect the logged value.
- Account
- Public read access; account useful for ongoing saved projects.
- Hardware
- No hardware required.
- Plan for
- Estimated 1–2 hours to read values and add a threshold indicator. Learning estimate, not a verified video runtime.
- Before this
- Basic digital input/output and serial printing.
- Good to know
- For the Arduino-on-ESP32 example, Wokwi specifically recommends the DHT sensor library for ESPx. Its SDA label denotes this sensor's data pin; do not assume the device uses I2C.
- Checked
- 2026-10-20
-
DocumentationIntermediate
Control pins with Python (opens in a new tab)
Use digital inputs, outputs, and analog readings.
MicroPython · Free learning access · No account to read · No hardware purchase
Access & lesson details
- Full title
- MicroPython: Quick Reference for ESP32
- Start here
- Read the Pin and ADC examples that match your runtime.
- Account
- None to read.
- Hardware
- Use Wokwi for supported virtual peripherals first; physical flashing requires a compatible board later.
- Plan for
- Estimated 2–4 hours for selected GPIO, timing, and ADC examples. Learning estimate, not a verified video runtime.
- Before this
- Python functions/loops and the Wokwi ESP32 MicroPython template.
- Good to know
- The latest URL is the development branch. Match docs to stable firmware/runtime; not all peripherals are simulated. ESP32 uses 3.3 V logic: do not feed GPIO with Uno 5 V wiring; physical hardware must follow the exact board’s pin/voltage limits.
- Checked
- 2026-10-20
-
DocumentationIntermediate
Keep the loop responsive (opens in a new tab)
Measure elapsed time without freezing the button input.
MicroPython · Free learning access · No account to read · No hardware purchase
Access & lesson details
- Full title
- MicroPython: time, ticks_ms and ticks_diff
- Start here
- Replace one long sleep with ticks_ms and ticks_diff.
- Account
- None to read.
- Hardware
- Wokwi simulation only; no board needed.
- Plan for
- Estimated 1–2 hours to replace a long blocking delay with a responsive scheduling loop. Learning estimate, not a verified video runtime.
- Before this
- Python loops, conditionals, and variables; a running Wokwi MicroPython example.
- Good to know
- Use ticks_diff rather than plain subtraction on tick counters. Keep each loop iteration short; a long sensor call can still block. Select docs matching the runtime version.
- Checked
- 2026-10-20
No resources in this stage match your filters. The build is still here when you’re ready.
04Shape the enclosureCreate a box that fits the parts and can be opened.
What you’ll learn
Start: Sketch the board, connector, and lid before opening CAD.
- Create a dimensioned sketch and a solid model.
- Leave access for connectors, wires, and a removable lid.
- Record assumed dimensions and what still needs a real fit check.
Before this: embedded
Sketch → CAD → preliminary BOM
Use AI as a study partner: Ask AI to turn your dimensions into a design checklist. Check dimensions in CAD and mark physical fit as unverified until tested.
Start with this lesson
-
CourseBeginner
Make your first enclosure (opens in a new tab)
Combine simple shapes into a removable-lid box.
Autodesk Tinkercad · Free learning access · Account to create · Browser only
Access & lesson details
- Full title
- Tinkercad: Learn 3D Design
- Start here
- Practice aligning a solid box and a hole.
- Account
- Account/sign-in for creating and saving designs; private by default according to official guide.
- Hardware
- Browser only; no 3D printer required for the design milestone.
- Plan for
- Estimated 2–4 hours for basics and a rough two-part box. Learning estimate, not a verified video runtime.
- Before this
- Basic mouse/trackpad navigation; no CAD experience.
- Good to know
- Simple geometry is a good first step, but more complex dimension-driven revisions are easier in parametric CAD. Commercial licensing is not asserted here.
- Checked
- 2026-10-20
More ways to learn 3 resources
-
CourseBeginner
Explore parametric CAD (opens in a new tab)
Make dimension-driven designs that are easier to revise.
Onshape · Free non-commercial plan · Account; public designs · Browser only
Free-plan designs are public and non-commercial. Do not use confidential designs.
Access & lesson details
- Full title
- Onshape: CAD Basics Learning Pathway
- Start here
- Read the public-design warning before choosing this optional route.
- Account
- Onshape sign-in required for hands-on documents and Learning Center access/progress.
- Hardware
- Browser/internet only; no printer required.
- Plan for
- Estimated 5–8 hours with practice; work through the beginning rather than rushing every lesson. Learning estimate, not a verified video runtime.
- Before this
- None; intended for new CAD learners.
- Good to know
- Warning: Free-plan models are PUBLIC and can be viewed and copied. Do not upload confidential, client, employer, or commercially sensitive designs. Education eligibility must be checked separately.
- Checked
- 2026-10-20
-
DocumentationIntermediate
Hollow out a solid (opens in a new tab)
Create an enclosure cavity with the Shell feature.
Onshape · Free learning access · Public-design practice account · No hardware purchase
Free-plan designs are public and non-commercial. Do not use confidential designs.
Access & lesson details
- Full title
- Onshape Help: Shell
- Start here
- Try Shell on a simple box before adding cutouts.
- Account
- None to read; an Onshape account to practice.
- Hardware
- Browser only.
- Plan for
- Estimated 45–90 minutes including making and inspecting a box cavity. Learning estimate, not a verified video runtime.
- Before this
- Can sketch and extrude a solid part in Onshape.
- Good to know
- Shell is one modeling operation, not a complete enclosure engineering course. Free-plan practice models are public; wall and fit choices still need physical validation.
- Checked
- 2026-10-20
-
GuideBeginner
Design for a real print (opens in a new tab)
Consider walls, clearances, overhangs, and orientation.
Prusa Research · Free learning access · No account to read · No hardware purchase
Access & lesson details
- Full title
- Prusa: Modeling with 3D Printing in Mind
- Start here
- Annotate your enclosure with the fit assumptions that need testing.
- Account
- None to read.
- Hardware
- No hardware required for reading/design review; later fit testing requires a real print or dimensional mock-up.
- Plan for
- Estimated 1–2 hours to read and annotate an enclosure design checklist. Learning estimate, not a verified video runtime.
- Before this
- Can make a basic 3D shape; no printer ownership needed.
- Good to know
- There is no universal fit tolerance. Treat printer/material-specific values as examples, then verify the actual process. Buying a printer is unnecessary for this stage.
- Checked
- 2026-10-20
No resources in this stage match your filters. The build is still here when you’re ready.
05Add useful AITrain a simple classifier and test where it fails.
What you’ll learn
Start: Train a two-object classifier in your browser.
- Separate training examples from held-out tests.
- Measure per-class mistakes and test unfamiliar inputs.
- Use an unknown state and record model limitations.
Before this: foundations; embedded
Inputs → model → decision contract
Use AI as a study partner: Ask AI to challenge your dataset split and model-card claims. Preserve actual test counts and inspect errors; never invent performance results.
Start with this lesson
-
ToolBeginner
Train a tiny classifier (opens in a new tab)
Teach the browser to recognize your own everyday objects.
Google Creative Lab · Free learning access · No account for basics · Browser; own image files
Access & lesson details
- Full title
- Teachable Machine
- Start here
- Use two harmless object classes and a separate other/background class.
- Account
- Basic local train/test is presented without a required sign-in. Optional Google Drive saving uses a Google account. No account was created or tested during verification.
- Hardware
- Existing computer and modern desktop browser. Use your own non-sensitive image files; a webcam is optional, not necessary. No development board.
- Plan for
- Estimated 60–90 minutes for the first classifier Learning estimate, not a verified video runtime.
- Before this
- Use a desktop browser and organize a few image files; no coding or ML background required.
- Good to know
- Google says examples and training stay on-device unless the learner chooses Google Drive saving. Local processing does not by itself mean the site and exported project will load without internet; test that separately. Browser training is not microcontroller deployment.
- Checked
- 2026-10-20
More ways to learn 4 resources
-
CourseBeginner
Understand model mistakes (opens in a new tab)
Learn train/test separation, thresholds, and confusion matrices.
Google for Developers · Free learning access · No account to read · No hardware purchase
Access & lesson details
- Full title
- Machine Learning Crash Course
- Start here
- Start with Classification and the visual examples.
- Account
- No account needed for public lessons. Optional Colab notebook work may require Google sign-in; no paid Colab plan is needed for the conceptual path.
- Hardware
- Existing computer and browser; no board or separate GPU. The course uses browser-based Colab for optional programming exercises.
- Plan for
- Estimated 3–4 hours for the selected concepts and exercises; not the entire course Learning estimate, not a verified video runtime.
- Before this
- For the full course: variables, graphs, algebra, basic statistics and programming, ideally Python. NumPy/pandas prework is recommended for coding exercises. A new coder can start with the selected visual lessons and defer notebooks.
- Good to know
- Do not require the complete course or calculus before building the first toy classifier.
- Checked
- 2026-10-20
-
DocumentationIntermediate
What changes on a tiny device? (opens in a new tab)
Learn why a browser model may not fit a microcontroller.
Google AI Edge · Free learning access · No account to read · No hardware purchase
Access & lesson details
- Full title
- LiteRT for Microcontrollers
- Start here
- Read Workflow and Limitations; do not start by buying a board.
- Account
- None for reading.
- Hardware
- None for this reading. The hardware examples are deferred; executing them requires an appropriate target and toolchain.
- Plan for
- Estimated 30–45 minutes Learning estimate, not a verified video runtime.
- Before this
- Know what a model, training and inference are. C++ and embedded basics are needed only if implementing the examples later.
- Good to know
- The official overview says the runtime targets 32-bit platforms, uses a low-level C++ API and does not support on-device training. It is not a turnkey Teachable Machine-to-board tutorial.
- Checked
- 2026-10-20
-
PaperDeep dive
Paper: smaller vision models (opens in a new tab)
Explore an early accuracy-versus-compute design tradeoff.
Howard et al., author paper on arXiv (2017) · Free learning access · No account to read · No hardware purchase
Access & lesson details
- Full title
- MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Applications
- Start here
- Read the abstract and inspect one accuracy-versus-compute figure.
- Account
- None.
- Hardware
- None; no paper reproduction required.
- Plan for
- Estimated 20–30 minutes for a guided skim Learning estimate, not a verified video runtime.
- Before this
- Basic idea of a neural network and tradeoffs between model size, latency and accuracy. Convolution math is optional for this skim.
- Good to know
- Historical foundational paper, not a claim that this architecture is the best current choice or that it fits any given microcontroller.
- Checked
- 2026-10-20
-
PaperDeep dive
Paper: report model limits (opens in a new tab)
Document what your model is for and where it fails.
Mitchell et al., FAT* 2019; author paper on arXiv · Free learning access · No account to read · No hardware purchase
Access & lesson details
- Full title
- Model Cards for Model Reporting
- Start here
- Borrow a few model-card headings for your own experiment.
- Account
- None.
- Hardware
- None.
- Plan for
- Estimated 20–30 minutes for reading, plus 30–45 minutes for your card Learning estimate, not a verified video runtime.
- Before this
- Have trained or inspected one classifier. No advanced mathematics needed for the reporting idea.
- Good to know
- The curriculum adds offline behavior and manual fallback fields for the physical-product context; these are exercise design choices, not a claim that the paper prescribes those exact fields.
- Checked
- 2026-10-20
No resources in this stage match your filters. The build is still here when you’re ready.
06Connect the behaviorsDefine what every event means before networking.
What you’ll learn
Start: Write down the three events your indicator understands.
- Define event names, fields, units, and versions.
- Replay lost, stale, duplicated, and invalid messages.
- Explain MQTT publish/subscribe without depending on a public broker.
Before this: embedded; ai
Modules → event contract → integration
Use AI as a study partner: Ask AI to identify ambiguities in your event contract. Replay malformed, stale, and duplicate messages to check the fixes.
Start with this lesson
-
DocumentationBeginner
Draw the device behavior (opens in a new tab)
Define states and transitions before connecting modules.
Stately · Free learning access · No account to read · No hardware purchase
Access & lesson details
- Full title
- What are state machines and statecharts?
- Start here
- Draw idle, active, and unknown, then add reset and timeout events.
- Account
- None for docs or the basic Sketch flow described by Stately. Saving/sharing a permanent Sketch URL requires sign-in; do not use it for this exercise.
- Hardware
- Existing computer or browser; paper tracing is a fully acceptable fallback. No physical device.
- Plan for
- Estimated 45–60 minutes Learning estimate, not a verified video runtime.
- Before this
- Basic if/else logic helps; no library installation is required for reading or sketching states.
- Good to know
- Use the language-independent concepts and a simple diagram; the docs currently expose evolving XState versions. No dependency installation or commitment to a particular XState version is required. Simulation checks the modeled behavior only.
- Checked
- 2026-10-20
More ways to learn 3 resources
-
VideoBeginner
Watch: how MQTT works (opens in a new tab)
Understand publishers, subscribers, topics, and brokers.
HiveMQ · Free learning access · No account to read · No hardware purchase
Access & lesson details
- Full title
- MQTT Essentials Video Series
- Start here
- Watch Part 1, or use the written companion.
- Account
- No account for the public article. Embedded video availability can depend on browser/region; use the written companion if it does not play.
- Hardware
- Existing browser only.
- Plan for
- Estimated 20–30 minutes for video and a diagram Learning estimate, not a verified video runtime.
- Before this
- Understand a device can send and receive a message; no networking setup required.
- Good to know
- The official HiveMQ page links to its YouTube video; search metadata identified the uploader as HiveMQ. Direct YouTube retrieval failed, so playback was not verified. No broker or paid cloud plan is required to learn the concepts.
- Checked
- 2026-10-20
-
ToolBeginner
Try messages in two tabs (opens in a new tab)
Explore a shared public broker with invented test data only.
HiveMQ · Free learning access · No account; public broker · Browser and internet
Public broker: use invented test data only. Never send credentials or personal data.
Access & lesson details
- Full title
- Free MQTT broker
- Start here
- Read the public-data warning before opening the browser client.
- Account
- HiveMQ explicitly says its shared public broker needs no account or broker setup. Its separate private/cloud broker signup is not required.
- Hardware
- Existing modern browser and internet connection; two tabs. No board or software installation.
- Plan for
- Estimated 30–45 minutes Learning estimate, not a verified video runtime.
- Before this
- Know broker, client, topic and message. Read the public-data warning first.
- Good to know
- The broker is public and shared. Use only invented labels and numbers, never samples, images, personal identifiers, secrets, private model data or real control commands. Random topics reduce accidental collisions, not provide privacy. Availability and message delivery are not guaranteed. Leave Retain off for this introductory test.
- Checked
- 2026-10-20
-
DocumentationIntermediate
Describe an event contract (opens in a new tab)
Agree on message fields and allowed values.
AsyncAPI Initiative · Free learning access · No account to read · No hardware purchase
Access & lesson details
- Full title
- Hello world
- Start here
- Write a plain-language contract before trying YAML.
- Account
- No account needed for reading. Studio is publicly accessible; save files locally rather than enabling cloud collaboration. Interactive runtime was not tested.
- Hardware
- Existing browser only; no broker required for writing or validating the description.
- Plan for
- Estimated 30–45 minutes reading and contract design; add 30 minutes for optional Studio validation Learning estimate, not a verified video runtime.
- Before this
- Know an event/message and a channel/topic; reading simple JSON or YAML helps.
- Good to know
- The current Hello world page uses AsyncAPI 3.1.0. Schema validation describes/checks the interface; it does not establish delivery, ordering, electrical safety or application-level correctness.
- Checked
- 2026-10-20
No resources in this stage match your filters. The build is still here when you’re ready.
07Prove what worksKeep evidence for successes, failures, and unknowns.
What you’ll learn
Start: Choose one requirement and define its pass/fail test.
- Map every requirement to a reproducible test.
- Automate decision-rule checks.
- Record model errors, simulator limits, and physical checks still required.
Before this: cad; interactions
Prototype → test → revision
Use AI as a study partner: Ask AI to propose tests that could disprove your claim. Run the tests and keep the observed outputs, including failures.
Start with this lesson
-
DocumentationIntermediate
Test your decision rule (opens in a new tab)
Make checks repeatable instead of testing by memory.
Python Software Foundation · Free learning access · No account to read · No hardware purchase
Access & lesson details
- Full title
- Python: your first automated tests
- Start here
- Write valid, missing, and out-of-range input tests.
- Account
- None to read.
- Hardware
- None; Python is needed to run examples, in a browser runtime or locally.
- Plan for
- Estimated 1–2 hours for the basic example and your own tests. Learning estimate, not a verified video runtime.
- Before this
- Python functions; basic familiarity with classes.
- Good to know
- Read the Basic example first; skip the long API reference. In a browser, use an explicit test suite and TextTestRunner rather than relying on command-line discovery.
- Checked
- 2026-10-20
More ways to learn 3 resources
-
GuideIntermediate
Turn a goal into a test (opens in a new tab)
Link each requirement to an observable result.
NASA · Free learning access · No account to read · No hardware purchase
Access & lesson details
- Full title
- NASA: write a testable requirement
- Start here
- Read Appendix C, then write one pass/fail requirement.
- Account
- None to read.
- Hardware
- None.
- Plan for
- Estimated 45–90 minutes for Appendices C–E. Learning estimate, not a verified video runtime.
- Before this
- A written user need and a prototype.
- Good to know
- Selected appendices of a professional systems-engineering handbook. Scale the method down to five requirements; the full handbook is optional.
- Checked
- 2026-10-20
-
DocumentationIntermediate
Inspect digital timing (opens in a new tab)
Capture a virtual signal when logs are not enough.
Wokwi · Free learning access · No account to read · Optional local waveform viewer
Access & lesson details
- Full title
- See your simulated digital signals
- Start here
- Record one button-to-indicator transition.
- Account
- None to read; saving simulator projects may require a Wokwi account.
- Hardware
- No physical analyzer needed; Wokwi simulates it.
- Plan for
- Estimated 1–2 hours for one capture. Learning estimate, not a verified video runtime.
- Before this
- A working Wokwi circuit; digital pin basics.
- Good to know
- The browser simulator can export a VCD trace. Viewing detailed waveforms may require a separate local viewer such as PulseView or GTKWave. Virtual signals do not establish physical voltage or timing margins.
- Checked
- 2026-10-20
-
PaperDeep dive
White paper: check the claims (opens in a new tab)
Read an embedded-AI performance claim critically.
Arm / Tanuj Arora · Free learning access · No account to read · No hardware purchase
Access & lesson details
- Full title
- How to read an embedded-AI white paper
- Start here
- List the workload and hardware behind one claimed speedup.
- Account
- None to read.
- Hardware
- None.
- Plan for
- Estimated 45–90 minutes for a guided skim. Learning estimate, not a verified video runtime.
- Before this
- Inference, memory, latency, and microcontroller basics.
- Good to know
- Vendor white paper: Accelerating Machine Learning Compute for the IoT and Embedded Market. It discusses particular Arm technologies; it is not a neutral benchmark or a required shopping list. PDF downloads directly and currently redirects to Arm’s document storage.
- Checked
- 2026-10-20
No resources in this stage match your filters. The build is still here when you’re ready.
08Make it reproducibleFinish a learning release with files, instructions, and limits.
What you’ll learn
Start: Follow your own README from a clean folder.
- Package source, editable CAD, BOM, and assembly instructions.
- Version the model, firmware, event contract, and test evidence.
- Explain reuse permissions and scope before publishing.
Before this: verification
Tested prototype → documented release candidate
Use AI as a study partner: Ask AI to review your README for missing steps. Follow it from a clean folder and verify every part number and third-party license.
Start with this lesson
-
DocumentationBeginner
Write the quick start (opens in a new tab)
Help a second builder reproduce your scoped demo.
GitHub Docs · Free learning access · No account to read · No hardware purchase
Access & lesson details
- Full title
- Write a README someone can follow
- Start here
- Write purpose, setup, replay steps, and known limits.
- Account
- None to read or draft locally; GitHub account needed to publish on GitHub.
- Hardware
- None.
- Plan for
- Estimated 30–60 minutes to read and draft your README. Learning estimate, not a verified video runtime.
- Before this
- A working or clearly scoped prototype.
- Good to know
- Publishing is optional. A local folder or ZIP is enough for the learning milestone.
- Checked
- 2026-10-20
More ways to learn 3 resources
-
GuideIntermediate
Package the design files (opens in a new tab)
Keep source, parts, and assembly notes together.
Open Source Hardware Association · Free learning access · No account to read · No hardware purchase
Access & lesson details
- Full title
- Package an open hardware project
- Start here
- List what another builder would need to modify your project.
- Account
- None to read.
- Hardware
- None.
- Plan for
- Estimated 1–2 hours for the selected documentation sections. Learning estimate, not a verified video runtime.
- Before this
- CAD, firmware, and a preliminary bill of materials.
- Good to know
- Read Original Design Files, Bill of Materials, Software and Firmware, and Instructions. Decide licensing separately; this curriculum does not publish or license your work for you.
- Checked
- 2026-10-20
-
DocumentationIntermediate
Version the release (opens in a new tab)
Connect the package to a specific revision.
GitHub Docs · Free learning access · No account to read · No hardware purchase
Access & lesson details
- Full title
- Create a versioned release
- Start here
- Draft a version name and release notes locally.
- Account
- None to read; a GitHub account and repository write permission are needed to publish.
- Hardware
- None.
- Plan for
- Estimated 30–60 minutes for a draft release. Learning estimate, not a verified video runtime.
- Before this
- Basic Git history and a complete project folder.
- Good to know
- Draft the release notes locally first. No repository, upload, or public release is required by the course.
- Checked
- 2026-10-20
-
DocumentationIntermediate
Check reuse permissions (opens in a new tab)
Record asset origins before sharing your work.
GitHub Docs · Free learning access · No account to read · No hardware purchase
Access & lesson details
- Full title
- Understand repository licensing
- Start here
- List the license for each third-party file or dependency.
- Account
- None to read.
- Hardware
- None.
- Plan for
- Estimated 30–60 minutes for a first pass. Learning estimate, not a verified video runtime.
- Before this
- A list of your own files and third-party dependencies.
- Good to know
- Software, hardware designs, data, and documentation may need different licenses. This is orientation, not legal advice. Do not assume that public source code is automatically reusable.
- Checked
- 2026-10-20
No resources in this stage match your filters. The build is still here when you’re ready.
Bring the pieces together
Desk Signals: a modular AI-enabled indicator
A harmless desk prototype that classifies your own object images and maps results to a clear indicator state.
- 01Input
- 02Model
- 03Decision
- 04Output
- 05Enclosure
- 06Evidence
Browser model → saved event trace → replayed ESP32 simulator → CAD enclosure → documented release candidate.
Explore the complete build
- Input: Personal object images, button input, and clearly labeled synthetic test events.
- Model: Browser inference, held-out evaluation, and a documented unknown state.
- Decision: A deterministic state machine with stale-event rejection and manual reset.
- Output: A virtual indicator first; an optional low-voltage LED later.
- Enclosure: Editable CAD with connector access and explicit fit assumptions.
- Evidence: Versioned requirements, event traces, tests, and limitations.
Keep a trail from idea to release
- Idea: One-sentence need, intended learner, and exclusions.
- Requirements: Five numbered, observable acceptance criteria.
- Sketch / CAD: Block diagram, circuit sketch, editable enclosure, and dimension assumptions.
- BOM: Part identifiers, quantities, ratings, datasheet links, alternatives, and unverified prices left blank.
- Assembly: Simulator diagram and an optional physical assembly plan with power-off wiring checks.
- Test: Requirement-to-test matrix, model results, traces, failures, and unperformed physical checks.
- Release: Versioned source package, README, model card, licenses/attributions, and known limits.
Ready to share when
- The learner can explain the input, model, decision, and output modules.
- The same saved event trace reproduces the same indicator states.
- Unknown, malformed, stale, and duplicate events have defined behavior.
- A new learner can follow the README without guessing missing steps.
- Every result is labeled as observed in software, observed in simulation, or tested on hardware.
Optionally reproduce the indicator on a compatible USB-powered development board after reviewing its exact wiring, logic levels, and current limits. Keep the model in the browser unless a separate on-device conversion and evaluation step succeeds.
- Educational prototype only; no safety, medical, security, or production-readiness claims.
- No claim that a browser model automatically deploys to a microcontroller. Model size, supported operations, memory, latency, and accuracy must be checked separately.
- No built-in live bridge between the browser model and Wokwi is assumed; manual event replay is the baseline.
- No mains wiring, battery construction or charging circuits, heaters, motors, or other hazardous actuation.
- A model score is not a calibrated probability; an unknown threshold reduces some errors but does not guarantee detection of unfamiliar inputs.
Before you start
Keep it small.
Keep it testable.
Free reading does not always mean a free tool or account-free authoring. Check each resource’s access details before you commit.
Access, safety & source notes
Access
- The default route uses a desktop-class browser and no purchased hardware. An internet connection is needed to load tools and learning material.
- All selected reading and videos are free to access at the checked links. Some authoring, saving, grading, or publishing features require accounts; paid certificates and upgrades are not part of this path.
- Public/free authoring tools may expose project files. Use non-sensitive practice data and check visibility before saving.
- Onshape Free is for non-commercial work and makes documents public. Use an appropriate private/local CAD workflow for confidential or commercial designs.
- A local folder is an acceptable release artifact. Nothing in this curriculum requires you to publish, upload, or buy anything.
Safe experiments
- Start in a simulator. For optional physical work, use compatible USB-powered low-voltage development boards and verify the exact pinout, logic voltage, and component ratings.
- Disconnect power before changing wiring. A simulator cannot prove real electrical safety, current limits, thermal behavior, radio reliability, or mechanical fit.
- Avoid mains electricity, battery fabrication or charging circuits, high-current loads, motors, heaters, and safety-critical or medical use cases.
- Use your own non-sensitive object images. Camera use is optional; avoid recording people or private surroundings.
- Public MQTT brokers are shared and untrusted. Use invented data only and do not connect them to consequential actuators.
Platform conditions
Wokwi
Free Community tier supports unlimited simulations and public projects. Documentation calls it free for personal use; commercial/professional work has paid plans. Free projects are visible to everyone. Unlisted projects, custom-library uploads and the private IoT gateway are paid features. Do not put credentials or confidential code in public projects; avoid networking in the first labs.
Tinkercad
Free browser app; sign-in is used to create and keep designs. Autodesk's official guide says designs are private by default. Its current free-CAD FAQ describes Tinkercad as intended for educational and personal projects; this research does not establish a blanket commercial-use license. Review applicable terms before business use. Do not confuse Tinkercad with Fusion's separate personal-use or education licenses.
Official source 1 ↗ · Official source 2 ↗ · Official source 3 ↗
Onshape
Free plan is for non-commercial work and public, open-source designs. Other users can view and copy those documents. It cannot create private documents. Use only throwaway learning models or designs you intentionally want public. Education plans have separate eligibility and restrictions; do not assume eligibility. Free learning resources exist, but not all Learning Center content is free.
Official source 1 ↗ · Official source 2 ↗ · Official source 3 ↗
How to use this path
- Start with the single highlighted resource and the build for each stage.
- Open the remaining resources only when you need a concept or want more depth.
- For a paper: read the abstract and conclusion, inspect one figure, and write down the claim, evidence, and limitation before tackling the mathematics.
- Use AI to explain an error, suggest a test, or review a draft. Verify generated wiring, pins, dimensions, part numbers, citations, and claims against primary sources. Never treat generated text as test evidence.
Curated by Harness Labs for learners building across code, electronics, form, and AI. Sources are linked directly; videos and papers open on their own sites. No external media is embedded here.
Links and source content were checked on 2026-10-20. Pyodide arithmetic was live-tested. Course accounts, most interactive tools, video playback, networking, CAD exports, model training, and physical builds were not end-to-end tested. Source-specific checks appear with each resource. Access and pricing can change.
Links last checked 2026-10-20. Access and pricing can change. Time labels are editorial estimates. Finishing this path is a starting point for further practice, not certification or proof of expertise.