How to become a Robotics Engineer in 6 months (RESOURCES)
Robotics is the least crowded high-value skill in tech right nowThe problem is that almost nobody knows where to start, because the field lo...
📝 摘要
这是一篇近 12,000 字的实战路线图，系统性地规划了零基础者在 6 个月内成为机器人工程师的路径。文章按月递进：第 1 月打电子基础（电路仿真、焊接、Python/Git），第 2 月做微控制器与传感器（Arduino/ESP32、电机驱动、PID 调参、巡线/自平衡机器人），第 3 月学机械设计与制造（Onshape/Fusion CAD、3D 打印、SO-101 机械臂组装），第 4 月入 ROS 2 生态（节点/URDF/Gazebo 仿真/SLAM/Nav2），第 5 月补控制与感知数学（PID/LQR/MPC、正逆运动学、相机标定/MoveIt 2），第 6 月进机器人学习前沿（LeRobot 仿示教学、VLA 模型、强化学习），并给出三个就业方向和作品集构建策略。全文附 100+ 链接资源、27 个实战项目、三级预算方案及 2026 年 9 月验证的硬件价格。
核心概念： 机器人工程的核心不是学位，而是"让物理实体可靠地执行你告诉它做的事，然后证明你做到了"——从电路层到学习策略的全栈动手能力。
关键技术栈 / 关键要点：
- 电子与嵌入式 — 从 Falstad 仿真到 ESP32-S3，必须会用万用表诊断问题，理解电机堵转为何会导致 MCU 复位
- 微控制器与执行器 — Arduino 入门、ESP32 进阶；TB6612FNG 替代淘汰的 L298N；编码器闭环控制是关键里程碑
- 机械设计与 3D 打印 — CAD（Onshape/Fusion/FreeCAD）+ FDM 打印（PLA/PETG/TPU 选材）+ SO-101 开源机械臂
- ROS 2 + 仿真 + 导航 — Jazzy LTS + Gazebo Harmonic + ros2_control + SLAM Toolbox + Nav2，全程可零硬件完成
- 控制理论与运动学 — PID 调参是基本功；LQR/MPC 进阶；Modern Robotics 螺旋理论 + 数值 IK + MoveIt 2 操控
- 机器人学习 — LeRobot（ACT/Diffusion Policy）仿示教学闭环；π₀/OpenVLA/SmolVLA 等开放权重 VLA 模型；MuJoCo Playground RL
- 就业与作品集 — 三方向（机器人学习/自主导航/嵌入式集成）；作品集核心是"什么坏了以及你怎么修的"，而非完成教程的证书
关键结论 / 实践建议： 先造再学，每月至少完成一个实物项目并推到 GitHub；硬件可选三级预算（$0 纯仿真/$60 入门套件/$300 完整台位）；6 个月每天 2 小时足以"入行"，但要到 Senior 需 5 年真实部署经验；作品集中"调试过程记录"是最不可伪造的信号。
Robotics is the least crowded high-value skill in tech right now
The problem is that almost nobody knows where to start, because the field looks like five fields stacked on top of each other
Some people start with a university robotics textbook and quit at the chapter on rotation matrices
Some buy an Arduino kit, blink an LED, and never build the second thing
Some jump straight into ROS 2 tutorials without knowing what a PWM signal is, then wonder why nothing works on real hardware
Others go the opposite way and learn only machine learning, which means they can train a policy but cannot make a motor turn
The result is usually the same: months of scattered effort and no working robot to show anyone
If your goal is to become a robotics engineer, you do not need a mechanical engineering degree and you do not need to derive the dynamics of a seven-link arm by hand
You need to be able to make physical things do what you tell them to, reliably, and then prove it
That means learning how to:
- read a schematic, wire a circuit, and debug it with a multimeter
- program a microcontroller to drive motors and read sensors in real time
- design and manufacture your own mechanical parts
- build robots the way companies build them, in ROS 2, with simulation
- close a control loop and know why it oscillates when it does
- teach a robot a task from demonstrations instead of hand-coding it
- ship a portfolio that survives three follow-up questions in an interview
This guide is a practical 6-month roadmap, and it assumes you are starting from zero electronics knowledge
Every single section has resources, a focus list, and a practical task that leaves you with something real, because a robotics portfolio is made of things that moved, not courses you finished
It also has hardware costs and where to order from, at three budget tiers, so you can follow this whether you are in San Francisco or somewhere AliExpress takes six weeks to reach
This one runs to nearly 12,000 words with over 100 linked resources and 27 practical projects, so bookmark it and come back to it month by month rather than trying to read it in one sitting
Every price and every link in here was checked against the vendor or the official docs in September 2026, and where the widely-quoted numbers did not survive checking I have said so instead of repeating them
Important!!!
While writing this article, I realized the most important skill is being able to explain hard technical things in simple words
So I created my personal YouTube channel where I am going to record videos about AI & Robotics engineering
If you really love my content on X and want to become Advanced in these two disciplines FOR FREE, then
Follow me: https://www.youtube.com/@deronin_23
It would mean a lot to me. I want this to be genuinely useful, and to keep making more of the content that gets so much positive feedback on X ❤️
Now let's start reading the article ⬇️
Why robotics and not AI engineering
Everyone in your timeline is an AI engineer now, and that is the whole problem
You cannot build a moat out of what a subagent does at 3am for pennies
Robotics is the opposite, for reasons that are structural rather than fashionable:
- the models already work, what is missing is someone who can put them in a body
- you cannot scrape the physical world, someone has to move a real machine to create the data
- there is no Stack Overflow answer for why your gripper keeps slipping
- a robot falling over is not a problem you can hand to a subagent
- nobody clones your robot over a weekend
AI engineering is crowded and robotics is empty
What a robotics engineer actually does
A lot of people hear "robotics engineer" and imagine someone designing a humanoid from scratch
In reality the job splits into specialisms, and you pick one and stay literate in the rest:
- perception and computer vision
- controls and state estimation
- motion planning and manipulation
- robot learning
- embedded and firmware
- simulation
- systems and integration
- deployment and operations
I read live job listings from Figure and Skild, and the same four requirements appear in every single one:
- C++ and Python, both, not one or the other
- experience on real hardware, since simulation-only does not qualify you as senior
- depth in one specialism and literacy across the rest
- debugging named as a skill in its own right
Notice what is not on that list: a specific degree
That is why this roadmap is built around making things work rather than studying theory, and why every section below ends with something you have to build
Keep whatever is paying you while you do it, treat this as two or three hours a day, and the six months are designed to be run that way
⏩---------------------------------------------------------------------⏪
Month 1: Electronics, the bench, and the tools you build everything with
Your goal this month: be able to read a schematic, build a circuit that works, and find the fault when it does not
Almost every roadmap skips this and starts at Arduino, which is why so many people can copy a wiring diagram but cannot fix anything when it breaks
Robotics is the one software field where the bug is sometimes a loose wire, a sagging battery or a motor drawing more current than your regulator can supply, and you will never diagnose those if you do not understand the electrical layer underneath
What to learn
1. Electronics fundamentals
You need Ohm's law, voltage dividers, what a capacitor does, how a transistor switches, and how to read a schematic
You do not need to design an op-amp from first principles
How to learn it:
Start in a simulator before you spend a single dollar, because you can wire things wrong at zero cost and actually see why they failed
The most common beginner mistake is watching hours of video without ever building the circuit, so build every example as you go, even in the simulator
Resources:
1. Falstad Circuit Simulator (free, in-browser)
Link: https://www.falstad.com/circuit/
Animated electron flow and live voltage colouring, so you actually watch current move instead of imagining it, which is the fastest way to build intuition
2. Tinkercad Circuits (Autodesk, free with account)
Link: https://www.tinkercad.com/circuits
The only simulator that gives you a virtual breadboard, a virtual Arduino and a virtual multimeter together, so it catches your wiring mistakes before you own any parts
3. All About Circuits, "Lessons in Electric Circuits" (free)
Link: https://www.allaboutcircuits.com/textbook/
A complete open-licensed EE textbook in six volumes, and this is your reference when a video hand-waves something you need to actually understand
4. Afrotechmods Tutorials (free)
Link: https://afrotechmods.com/tutorials/
Short, fast, funny videos sorted into beginner, intermediate and advanced, and the right choice if you bounce off lecture-format teaching
5. Make: Electronics, 3rd edition, Charles Platt ($29.99)
Link: https://www.makershed.com/products/make-electronics-3rd-edition-print
The best single paper book for someone who has never held a multimeter, built around deliberately destroying components to learn their limits
What to focus on:
- Ohm's law and voltage dividers until they are automatic
- Current draw, and why a motor stalling browns out your microcontroller
- Reading a schematic, including the symbols you will meet constantly: resistor, capacitor, diode, transistor, ground, Vcc
- Pull-up and pull-down resistors, because you will use them every week
- What a decoupling capacitor is and why every IC needs one
- Battery chemistry basics: LiPo cell counts, C ratings, and why you never leave a LiPo charging unattended
Practice task: build a voltage divider in Falstad, calculate the output voltage by hand, then confirm it in the simulator. Then build a transistor switch that turns an LED on from a logic-level input, since that is the exact circuit that will later let a 3.3V microcontroller pin control something that needs more current than the pin can supply
2. The bench, the tools, and what everything costs
This is the section that decides whether you actually start, so here is the honest budget
Tier 0, $0. Falstad, Tinkercad and All About Circuits, so that you learn Ohm's law and dividers before spending anything. Genuinely do this first
Tier 1, roughly $45 to $60. A starter kit and a multimeter. Every kit below is solderless, so you need no iron yet
Tier 2, roughly $110 to $160. Add a soldering iron, solder, side cutters, wire strippers, helping hands, perfboard and extra passives
Tier 3, roughly $200 to $300. Add a bench power supply, better meter, desoldering pump, storage drawers and a robot chassis kit
Verified kit prices, September 2026:
1. Elegoo UNO R3 Super Starter Kit ($42.99)
Link: https://www.elegoo.com/products/elegoo-uno-r3-super-starter-kit
The best value pick and the kit most beginner courses target, with a pre-soldered LCD, power module and a 22-lesson PDF
2. Elegoo UNO Basic Starter Kit ($19.99)
Link: https://www.elegoo.com/products/elegoo-uno-basic-starter-kit
The cheapest real entry point if money is genuinely tight, with an Uno clone and basic passives
3. SparkFun Inventor's Kit v4.1.2 ($99.95)
Link: https://www.sparkfun.com/sparkfun-inventor-s-kit-v4-1-2.html
The best curriculum of any kit, 16 circuits across 5 projects ending in a working robot, and the free guide is readable even if you buy a cheaper kit
4. Adafruit digital multimeter 9205B+ ($17.50)
Link: https://www.adafruit.com/product/2034
Volts, current to 20A, continuity, resistance and capacitance, which is everything you need for years
5. Pinecil V2 soldering iron ($25.99 community, $35.99 retail)
Link: https://pine64.com/product/pinecil-smart-mini-portable-soldering-iron/
A real temperature-controlled iron for the price of a toy one, USB-C powered, takes standard TS100 and Hakko T12 tips
Where to order, and the honest guidance:
- AliExpress is cheapest by a wide margin, often 3 to 10 times less, but shipping runs 2 to 6 weeks and there is no support when a board arrives dead
- Amazon is mid-priced and fast, and the right place for your first kit
- Elegoo direct ships from regional warehouses in about a week
- Adafruit and SparkFun cost more and are worth it early, because every product page links a full tutorial and their support is real
- Seeed Studio and DFRobot ship worldwide from China at low-to-mid prices
- DigiKey and Mouser are for exact parts by specification with genuine datasheets, not for kits
- Pololu ships internationally and is the best source for motors and drivers
For your first order, pay the premium and buy from Amazon or Elegoo direct so you are building within days instead of sulking for a month. Once you know what a 10k resistor is for, order everything from AliExpress
Practice task: buy a kit and a multimeter, then measure things. Measure the voltage of a battery, the resistance of five random resistors and check them against the colour bands, then use continuity mode to find a deliberately broken wire you make yourself. This sounds trivial and it is the single skill that will save you the most hours over the next six months
3. Soldering
At some point a jumper wire will not be good enough, and a robot that shakes itself apart mid-demo is not a portfolio piece
Resources:
1. Adafruit Guide to Excellent Soldering (free)
Link: https://learn.adafruit.com/adafruit-guide-excellent-soldering
Iron selection, joint technique, photographs of every common failure, and safety, and it is the reference everyone in the industry points to
2. SparkFun: How to Use a Multimeter (free)
Link: https://learn.sparkfun.com/tutorials/how-to-use-a-multimeter
Voltage, resistance, current and continuity explained properly, including what to do when you blow the fuse, which you will
What to focus on:
- Tinning the tip and keeping it clean
- Heating the joint, not the solder
- Recognising a cold joint by sight
- Through-hole first, surface-mount much later
- Using flux, which fixes most problems beginners blame on the iron
Practice task: solder header pins onto a cheap breakout board, then test every pin with continuity mode, and do the whole thing three times. Then desolder one and resolder it, because removing components badly is how most beginners destroy boards
4. Python, the terminal and Git
You will use all three every single week from here to month six, so get them out of the way now
Resources:
1. CS50P: Introduction to Programming with Python (Harvard, free)
Link: https://cs50.harvard.edu/python/
More rigorous than most beginner courses, with problem sets and a final project, and the structure is what makes people finish it
2. Python for Everybody (Coursera, free to audit)
Link: https://www.coursera.org/specializations/python
The gentlest starting point if CS50P feels too steep, taught by one of the most beginner-friendly instructors online
3. The Missing Semester of Your CS Education (MIT, free)
Link: https://missing.csail.mit.edu/
Shell, scripting, and the command-line fluency that university courses skip, and robotics runs on the command line
4. Learn Git Branching (free, interactive)
Link: https://learngitbranching.js.org/
The best visual tool for understanding branches and merges, which is the part of Git that confuses everyone
What to focus on:
- Python: functions, classes, file I/O, JSON, virtual environments, pip
- Terminal: cd, ls, grep, running scripts, environment variables, ssh
- Git: init, add, commit, push, branches, and writing a README someone can follow
Practice task: from today, every project you build lives in a GitHub repo with a README that has a photo, a wiring description and a one-paragraph explanation of what broke and how you fixed it. That last part is what makes a repo look like engineering instead of a tutorial
Month 1 Milestone
By the end of this month you should be able to:
- Read a schematic and build the circuit it describes on a breadboard
- Calculate whether a resistor value is right before you plug it in
- Find a short, a break or a dead component with a multimeter
- Solder a clean through-hole joint and check it electrically
- Write a Python script, run it from the terminal, and push it to GitHub
- Explain out loud why a motor stalling can reset your microcontroller
⏩---------------------------------------------------------------------⏪
Month 2: Microcontrollers, motors and sensors, and your first moving robot
Your goal this month: build a robot that moves, senses its environment, and corrects itself
This is the month robotics stops being theory, and it is also the month where most of the fundamental skills of the whole field first appear in miniature
A line-following robot is a closed control loop with sensor input, actuator output and a tuning problem, which is exactly what a humanoid is, only smaller and cheaper to break
What to learn
1. Arduino
Start on Arduino rather than ESP32, because the ecosystem is enormous and every tutorial in existence targets it
You will move to ESP32 within weeks, and nothing you learn here is wasted
Resources:
1. Paul McWhorter, Arduino Lessons (free)
Link: https://toptechboy.com/arduino-lessons/
Over 100 lessons taught slowly with homework at the end of each one, and the single best fit for a true beginner who has failed at Arduino before
2. Arduino Built-in Examples (official, free)
Link: https://docs.arduino.cc/built-in-examples/
Runnable sketches already inside your IDE, which is the fastest route from "installed" to "something moved"
3. Arduino Official Docs, Learn section (official, free)
Link: https://docs.arduino.cc/learn/
The authoritative reference for digital and analog IO, PWM, I2C, SPI and UART, best used as lookup rather than as a course
4. Arduino Project Hub (free)
Link: https://projecthub.arduino.cc/
Over 6,000 projects with wiring and code, and this is where you go when tutorials end and you need something to build
What to focus on:
- digitalWrite, digitalRead, analogRead and analogWrite, and what PWM actually is
- Interrupts, and why polling a button in a loop eventually fails you
- I2C and SPI: how to wire them and how to read a sensor datasheet to find the address
- Serial debugging, which will be your primary tool for months
- Non-blocking timing with millis() instead of delay(), because delay() will ruin every robot you build
Practice task: build a reaction-timer game. An LED fires after a random delay, a button stops the clock, and the time in milliseconds prints to serial. It uses interrupts, debouncing and non-blocking timing, and it has a score, which makes it demonstrable in fifteen seconds of video
2. ESP32
The ESP32 is where you go the moment you want WiFi, Bluetooth, more processing power or two cores, and it is cheaper than an Arduino Uno
Buy an ESP32-S3 as your main board, which is the most capable current variant, and one classic ESP32 so that older tutorial code runs unmodified
Resources:
1. Random Nerd Tutorials, Getting Started with ESP32 (free)
Link: https://randomnerdtutorials.com/getting-started-with-esp32/
The highest-signal free tutorial library anywhere for this chip, with a specific fix for nearly every beginner failure mode, and a 250+ project index alongside it
2. ESP-IDF Programming Guide (Espressif official, free)
Link: https://docs.espressif.com/projects/esp-idf/en/stable/esp32/get-started/index.html
The only source of truth once you outgrow the Arduino layer, covering the real toolchain, menuconfig and the build system
3. Arduino ESP32 Core documentation (Espressif official, free)
Link: https://docs.espressif.com/projects/arduino-esp32/en/latest/
Espressif's own docs for the Arduino layer, and the bridge that makes "Arduino versus ESP-IDF" a spectrum rather than a fork in the road
4. DroneBot Workshop ESP32 hub (free)
Link: https://dronebotworkshop.com/esp32-2/
Long-form, wiring-diagram-heavy tutorials with written articles mirroring every video, covering ESP-NOW, OTA updates and low-power modes
Board prices, verified:
- ESP32-S3-DevKitC-1, 8MB flash, $15.95 at Adafruit Link: https://www.adafruit.com/product/5312
- Classic ESP32 Dev Board, $15.00 at Adafruit Link: https://www.adafruit.com/product/3269
- Seeed XIAO ESP32-C3, $4.99, for when you need something tiny Link: https://www.seeedstudio.com/Seeed-XIAO-ESP32C3-p-5431.html
- Generic ESP32 clones on AliExpress run roughly $4 to $9, which is unverified but is the well-known street range
Decision framework:
- Arduino framework for speed to a working robot, with the largest library ecosystem
- ESP-IDF when you need real control over tasks, cores, power and timing
- MicroPython for fast sensor experimentation, but not for a balancing loop, since garbage collection pauses will wreck your timing
Practice task: build something that could not exist on an Arduino Uno. Serve a web page from the ESP32 that shows live sensor readings and has buttons that drive a servo, then access it from your phone on the same network. This teaches WiFi, HTTP handling and asynchronous work at the same time
3. Motors, drivers and actuation
This is where electronics stops being abstract, because motors draw real current and behave badly
Four types matter, and you should understand all four by the end of the month
Brushed DC gearmotor: cheap, needs an H-bridge, and has no position feedback unless you add an encoder. The default for a first rover
Hobby servo: an internal closed loop with roughly 180 degrees of travel and no feedback out
Smart serial bus servo: daisy-chained, with position, velocity and current feedback and a 12-bit magnetic encoder. This is what modern low-cost arms use
Stepper: open-loop absolute positioning with high holding torque
Resources:
1. DroneBot Workshop, Controlling DC Motors with the L298N (free)
Link: https://dronebotworkshop.com/dc-motors-l298n-h-bridge/
DC motor theory, PWM, H-bridge internals and three complete sketches, ending in a joystick-driven robot car
2. SparkFun TB6612FNG Hookup Guide (free)
Link: https://learn.sparkfun.com/tutorials/tb6612fng-hookup-guide/all
Pinout, wiring and library for the driver you should actually use, with the reasoning for why
3. DroneBot Workshop, Stepper Motors with Arduino (free)
Link: https://dronebotworkshop.com/stepper-motors-with-arduino/
Unipolar versus bipolar, microstepping, NEMA sizing, and four demos across three different drivers
4. SimpleFOC documentation (open source, free)
Link: https://docs.simplefoc.com/
The clearest free explanation of field-oriented control anywhere, and the affordable on-ramp to brushless motors when you get there
Hardware, verified prices:
- Adafruit DRV8833 motor driver, $5.95, the cheapest good driver on the list Link: https://www.adafruit.com/product/3297
- SparkFun TB6612FNG breakout, $14.77, the correct default replacement for the L298N Link: https://www.sparkfun.com/sparkfun-motor-driver-dual-tb6612fng-1a.html
- Pololu gearmotor with encoder assembly, $19.95 each, with the encoder wiring already solved Link: https://www.pololu.com/product/3675
- Pololu A4988 stepper driver carrier, $8.95Link: https://www.pololu.com/product/1182
- FeeTech STS3215 smart servo, 12V, 30 kg·cm, $31.71 at RobotShop, which is the servo used in the open-source SO-101 arm Link: https://www.robotshop.com/products/feetech-12v-30kgcm-magnetic-encoding-servo-sts3215
What to memorize: the L298N is in every tutorial and you should not use it. It is an obsolete bipolar-transistor H-bridge that drops about 2V across its output stage, gets hot and wastes your battery. Learn it because the tutorials use it, then switch to the TB6612FNG or DRV8833
Practice task: drive one DC motor forward and backward at five different speeds using PWM, then add an encoder and write a function that turns the wheel exactly one full revolution regardless of battery voltage. The second half is your first real closed loop, and it is much harder than it sounds
4. Sensors and reading the physical world
Resources:
1. Adafruit BNO085 9-DoF IMU guide (free)
Link: https://learn.adafruit.com/adafruit-9-dof-orientation-imu-fusion-breakout-bno085/overview
Covers an IMU that does sensor fusion on-chip and hands you a quaternion, which is the "buy your way out of the maths" option
2. Kalman and Bayesian Filters in Python, Roger Labbe (free, CC-BY)
Link: https://rlabbe.github.io/Kalman-and-Bayesian-Filters-in-Python/
Jupyter notebooks with runnable code and solved exercises covering g-h, discrete Bayes, KF, EKF, UKF and particle filters, and it is the best free filtering education that exists
3. MathWorks, Understanding Sensor Fusion and Tracking (free)
Link: https://www.mathworks.com/videos/series/understanding-sensor-fusion-and-tracking.html
Six short parts from "what is sensor fusion" to fusing IMU and GPS for pose, and the right conceptual overview before you touch code
Sensor prices, verified:
- HC-SR04 ultrasonic, $3.95, cheap obstacle detection with a wide cone and poor performance on soft surfaces
- VL53L0X time-of-flight laser, $14.95, a much narrower 35-degree cone and no double-imaging problems
- MPU-6050 6-DoF IMU, $12.95, the cheap classic where you do the fusion yourself, which is the point
- BNO085 9-DoF IMU, $29.50, fusion on-chip with a UART mode built for robotics
- Pololu magnetic encoder pair, $8.95, for adding odometry to motors that lack it
- RPLIDAR C1 360-degree lidar, $69.00 at DFRobot, newer and cheaper than the classic A1
Beginner tip: for a balancing robot, write a complementary filter before you write a Kalman filter. It is four lines, angle = a * (angle + gyro * dt) + (1 - a) * accelAngle with a around 0.98, and it works. Graduate to Kalman when you understand why the complementary filter fails
Practice task: mount an IMU on a board, print the pitch angle to serial, hold the board perfectly still and watch the number drift anyway. Now add a complementary filter and watch that drift disappear, which is the single most important lesson in state estimation and it took you twenty minutes
5. Your first two robots
These two projects together teach more than any course will
Line-following robot. Quality build roughly $105, budget build roughly $38
Bill of materials, quality: ESP32-S3 $15.95, Pololu Romi chassis kit $39.95, TB6612FNG driver $14.77, QTR-8RC reflectance array $12.95, batteries and holder about $12, wiring and headers about $10
Budget version: generic ESP32 about $6, 2WD acrylic chassis about $12, DRV8833 $5.95, five TCRT5000 sensors about $3, batteries about $6, wiring about $5
Self-balancing robot. Quality build roughly $134, budget build roughly $62
Bill of materials, quality: ESP32 $15.95, two gearmotor-with-encoder assemblies $39.90, TB6612FNG $14.77, MPU-6050 $12.95, printed or laser-cut chassis about $10, LiPo and charger and wheels about $30, misc about $10
Practice task for the month: build the line follower first, tune it with a P controller, then add the D term and watch the oscillation disappear, filming both versions. The video of a badly tuned robot next to the same robot tuned properly is one of the most persuasive things a beginner can put in a portfolio, because it proves you understand the loop rather than having copied a gain
Then build the balancer, which will not work at all until your filter and your loop timing are both correct, and that frustration is the point
Month 2 Milestone
By the end of this month you should be able to:
- Drive a motor at a controlled speed and know the difference between PWM duty and actual RPM
- Read an encoder and close a position loop around it
- Wire and read an I2C sensor from its datasheet without a tutorial
- Fuse accelerometer and gyroscope data into a stable angle estimate
- Explain what P, I and D each do by describing what your robot did when you changed them
- Show two working robots on GitHub with wiring, code and a written account of what broke
⏩---------------------------------------------------------------------⏪
Month 3: Mechanical design, CAD and manufacturing your own parts
Your goal this month: design a part in CAD, manufacture it, and have it fit
This is the month that separates people who assemble kits from people who build robots
Every robot you build after this will contain parts that exist only because you designed them, and being able to go from an idea to a physical bracket in an afternoon changes what projects are possible for you
What to learn
1. CAD
Pick one tool and go deep rather than sampling all of them
Decision framework:
- Onshape Free if you are happy designing in public. It runs in a browser, works on any machine including a Chromebook, and its assembly and mate system behaves the way robot joints actually behave. The catch is real: every document is public on the free tier
- Fusion Personal if you want CAM and 3D-print integration later. Free on a renewable 3-year term for non-commercial use under $1,000 a year of revenue, but with limited import and export file types
- FreeCAD if you are somewhere cloud CAD or card payment is a problem, or you object to a licence that can be revoked. Version 1.1 landed in March 2026 and it is genuinely usable now
- SOLIDWORKS for Makers at $48/year if you want the industry-standard tool, with the caveat that native files are watermarked and will not open in commercial SOLIDWORKS
Resources:
1. Onshape Learning Center, Fundamentals: CAD (free with account)
Link: https://learn.onshape.com/learning-paths/onshape-fundamentals-cad
The only free structured CAD curriculum that ends in a credential you can put on a CV, and it ships a dedicated robotics-competition track
2. Product Design Online, Learn Autodesk Fusion in 30 Days (free)
Link: https://productdesignonline.com/learn-autodesk-fusion-360-in-30-days-official-course/
Thirty modelled objects in thirty days, which is the fastest route from never having opened CAD to confident parametric sketching
3. MangoJelly Solutions FreeCAD tutorials (free)
Link: https://www.youtube.com/@MangoJellySolutions
The best FreeCAD teacher for makers, organised as short targeted lessons rather than one monolithic course
4. Protolabs Network, Design for 3D printing (free)
Link: https://www.hubs.com/knowledge-base/design-for-3d-printing/
The design-for-manufacture half of CAD: wall thickness, orientation, tolerances, supports, snap-fits, and when to use STL versus 3MF versus STEP
What to focus on:
- Fully constrained sketches, because an under-constrained sketch will move when you edit it later and ruin your day
- Parametric design driven by variables, so changing one dimension updates the whole part
- Assemblies and mates that mirror real joints: revolute, slider, fixed
- Designing around hardware you actually own, starting from the servo's datasheet dimensions
- Exporting STEP for sharing and STL for printing, and knowing the difference
Practice task: model a bracket that holds the exact servo you bought, with correctly sized screw holes and a shaft clearance, from the manufacturer's datasheet drawing rather than by eye. Then print it and see if it fits, which it probably will not the first time, and that failure is the lesson
2. 3D printing
Verified printer prices, September 2026:
- Creality Ender-3 V3 SE, $199
Link: https://store.creality.com/products/ender-3-v3-se-3d-printer
- Bambu Lab A1 mini, $219.99
Link: https://www.bestbuy.com/product/bambu-lab-a1-mini-3d-printer-silver/CZTZV9ZGGV
- Bambu Lab A1, $299.99, with the 256mm bed you will want for larger brackets
Link: https://www.bestbuy.com/product/bambu-lab-a1-3d-printer-silver/CZW2ZH33H4
- Creality K1C, $369, enclosed and hardened for carbon-fibre filaments
Link: https://store.creality.com/products/k1c-3d-printer
- Bambu Lab P1S, $799, enclosed CoreXY for ABS and ASA
Link: https://us.store.bambulab.com/products/p1s
Filament, and when to use each:
- PLA and PLA+ for prototype brackets, jigs, and the SO-101 arm itself, which specifies PLA+ at 15% infill and 0.2mm layers. Stiffest of the easy materials, and it creeps under sustained load and softens around 55 to 60°C
- PETG for the default real robot part: chassis plates, gearbox housings, servo mounts, anything that must survive a drop. Tough with far better layer adhesion than PLA, and stringy
- ABS and ASA for parts near hot motors and for outdoor rovers, and they warp badly without an enclosure
- Nylon for gears and cable guides, and it is easier to order than to print
- Carbon-fibre filled for stiff structural links, and it needs a hardened nozzle because it is abrasive
- TPU for feet, bumpers and compliant gripper fingers
Resources:
1. OrcaSlicer Calibration wiki (free)
Link: https://github.com/OrcaSlicer/OrcaSlicer/wiki/Calibration
Temperature, flow, pressure advance, retraction and tolerance calibration in a recommended running order, and it is the most useful slicing document for anyone who wants parts that fit
2. Teaching Tech 3D Printer Calibration (free, interactive)
Link: https://teachingtechyt.github.io/calibration.html
A printer-agnostic interactive walkthrough that takes you through every calibration in sequence
3. CNC Kitchen (free)
Link: https://www.youtube.com/@CNCKitchen
Instrumented, repeatable strength tests on infill, walls, threaded inserts and orientation, which is where print orientation stops being folklore and starts being data
4. Clearance and Tolerance 3D Printer Gauge (free STL)
Link: https://www.printables.com/model/57067-clearance-and-tolerance-3d-printer-gauge
Print this once and you know your machine's real clearance for press fits and sliding fits, which every bracket and bearing seat you design afterwards depends on
If you cannot buy a printer:
- Fab Labs worldwide, roughly 2,875 of them, searchable by country
Link: https://fablabs.io/labs
- Public library makerspaces, free or near-free in much of the US
Link: https://action.everylibrary.org/how_to_find_a_makerspace_near_you
- Craftcloud compares quotes across a network spanning 95 countries and routes to a manufacturer near you, which is the right choice outside the US and EU
Link: https://craftcloud3d.com/
- JLC3DP starts at $1.00 per part for MJF nylon and FDM, with 3-day builds
Link: https://jlc3dp.com/
The honest economics: an SO-101 arm needs roughly 1kg of PLA+, which is about $20 to $25 of filament on your own machine against $30.99 for a ready-printed set. A printer does not pay for itself on one build. It pays for itself on iteration, because the tenth revision of a gripper finger costs 40 cents and 25 minutes at home, against $8 and a week from a service
Practice task: print the tolerance gauge, write down your machine's actual clearance numbers, then design and print a two-part snap-fit enclosure for your ESP32 that closes without glue. Iterate until it clicks properly. This is the loop that all mechanical design is made of
3. Actuators, transmissions and why robots are hard
Understanding gear reduction, backlash and torque density is what separates a robot that works in a video from a robot that works repeatedly
What to focus on:
- Gear ratios and the trade between speed and torque
- Backlash, and why it destroys position accuracy in a way software cannot fully fix
- Bearing selection and preload
- Belt versus gear versus direct drive
- Why a cheap servo's plastic gearset is the first thing to fail on any arm
Practice task: design and print a simple planetary or cycloidal reducer for a NEMA17 stepper or a hobby motor, and accept that the first one will be bad. Measure the backlash by holding the output and rocking it, then redesign to reduce it. Reference builds are on Instructables and Hackaday if you want a starting geometry
Link: https://www.instructables.com/OpenCycloid-3D-printed-Open-Source-Robotic-Actuato/
4. Build a real robot arm
This is the capstone of the month, and it is the single best hardware purchase in this entire roadmap
The SO-101 is an open-source 5-DOF arm plus gripper from TheRobotStudio and Hugging Face, designed to be built as a leader and follower pair so you can hand-guide one and have the other mirror it
That teleoperation setup is what lets you record demonstrations, which is what month six is built on
Official bill of materials, verified in the repo: $229.88 US for a leader and follower pair, $121.94 for a single follower arm, excluding 3D printing
Link: https://github.com/TheRobotStudio/SO-ARM100
Where to buy, verified prices:
- Seeed Studio SO-ARM101 Pro servo kit, $277.99, motors and control boards without printed parts
Link: https://www.seeedstudio.com/SO-ARM101-Low-Cost-AI-Arm-Kit-Pro-p-6427.html
- Seeed Studio printed parts set, $30.99, if you have no printer
Link: https://www.seeedstudio.com/SO-ARM101-3D-printed-Enclosure-p-6428.html
- Robonine SO-ARM101 complete kit, $349.00, shipping from Delaware
Link: https://robonine.com/shop/so-arm101-black-robotic-arm-kit/
- WowRobo via OpenELAB, $325.99 printed parts plus servos, $419.99 unassembled full kit, $489.99 fully assembled
Link: https://openelab.com/products/wowrobo-robotics-so-arm101-diykit
Cheaper alternatives at every tier:
- $0: everything in the LeRobot stack runs in MuJoCo simulation before hardware exists, which is the answer if you cannot import anything
- $50 to $80: the EEZYbotARM MK2, free STLs, built from MG996R hobby servos and printed parts. It teaches linkage kinematics rather than servo-bus protocols Link: https://www.thingiverse.com/thing:1454048
- $122: a single SO-101 follower arm if you print the parts yourself. You lose teleoperation and keep the entire software path
- $199.99: Hiwonder xArm 1S, the cheapest arm with intelligent bus servos that report position and voltage Link: https://www.hiwonder.com/products/xarm-1s
Practice task: build the SO-101, calibrate every servo, and teleoperate the follower with the leader. Then design and print your own gripper fingers to replace the stock ones, in TPU, and test them on three objects of different shapes. The arm is the platform for months five and six, and the custom fingers are the part that proves you can design as well as assemble
Month 3 Milestone
By the end of this month you should be able to:
- Model a part from a datasheet in CAD with fully constrained sketches
- State your printer's real clearance numbers from measurement rather than guesswork
- Design a part specifically for FDM, accounting for orientation, overhangs and layer adhesion
- Choose PLA, PETG, ABS or TPU for a given part and justify it
- Explain what backlash is and demonstrate it on something you built
- Show a working robot arm you assembled, calibrated and modified with your own parts
⏩---------------------------------------------------------------------⏪
Month 4: ROS 2, simulation, and building robots the way companies do
Your goal this month: build a robot in ROS 2, simulate it, and make it map a room and navigate autonomously
Everything up to now was you building robots your way
ROS 2 is how the industry builds them, and it is the single most requested skill in robotics job listings
The best part of this month is that you can do all of it with no hardware at all, on a normal laptop, with no NVIDIA GPU. Say that to yourself twice, because the belief that robotics requires expensive equipment is the main reason people never start
What to learn
1. Which ROS 2 to install, and the ROS 1 trap
ROS 2 releases every May. Even years are LTS with five years of support, odd years get about eighteen months
As of September 2026 the picture is:
- Lyrical Luth, released May 2026, EOL May 2031, targets Ubuntu 26.04. The current LTS
- Jazzy Jalisco, released May 2024, EOL May 2029, targets Ubuntu 24.04
- Kilted Kaiju, EOL 31 December 2026. Do not start here
- Humble Hawksbill, EOL May 2027. Legacy
Start on Jazzy. Lyrical is newer and is what you would pick for a new production project, but as of now almost every course, book and YouTube series still targets Jazzy, and it has more than two and a half years of support left. Move to Lyrical once your tutorial stack catches up
ROS 1 is dead. Noetic reached end of life on 31 May 2025 and there is no successor. Enormous amounts of highly-ranked tutorial content is ROS 1, so learn to recognise it instantly: if you see catkin_make, roscore, rosrun, rospy or XML-only launch files, close the tab. ROS 2 uses colcon build, has no master, and uses ros2 run and Python launch files
2. ROS 2 core concepts
Resources:
1. Official ROS 2 Tutorials (free)
Link: https://docs.ros.org/en/jazzy/Tutorials.html
The canonical reference, structured exactly around nodes, topics, services, actions, parameters, launch files, tf2 and URDF. It is reference-grade rather than pedagogy, so pair it with video
2. The Construct (free tier, paid from €39.97/month)
Link: https://www.theconstruct.ai/
Everything runs in a browser-based ROS environment with simulated robots, which removes the single biggest friction point for beginners: no Ubuntu dual-boot, no install weekend, no GPU. The free tier includes three complete courses
3. Edouard Renard, ROS 2 for Beginners, Level 1 (Udemy, roughly $10 to $20 on sale)
Link: https://www.udemy.com/course/ros2-for-beginners/
Thirteen hours in both Python and C++ covering nodes, packages, topics, services, custom interfaces, parameters and launch files. Never pay list price, Udemy discounts almost permanently
4. Articulated Robotics, Josh Newans (free)
Link: https://articulatedrobotics.xyz/tutorials/
The best free end-to-end narrative anywhere: design a robot, write the URDF, simulate it, add ros2_control, put it on a Raspberry Pi with a lidar, then SLAM and navigate. Uniquely good on ros2_control, which almost every other resource fumbles
5. MOGI-ROS, a full university course (free, Apache 2.0)
Link: https://github.com/orgs/MOGI-ROS/repositories
A real semester-length syllabus on ROS 2 Jazzy with Gazebo Harmonic, running from pub/sub through URDF, sensors, navigation and MoveIt 2 arms, with working code for every week
6. Automatic Addison (free)
Link: https://automaticaddison.com/tutorials/
Recipe-style guides organised by distro, and notable for already carrying Lyrical tracks alongside Jazzy. This is where you go for "how do I write an action in Jazzy" rather than a full course
What to focus on:
- Nodes, topics, services and actions, and knowing which of the three a given problem needs
- Custom message and service definitions
- Parameters and YAML config files
- Launch files in Python, and passing arguments and remapping topics
- colcon workspaces and package layout
- ros2 bag for recording and replaying, which is how you debug anything that only fails occasionally
Honest gap worth naming: DDS and QoS settings are covered badly by every resource I could find. No course does it well. When you hit mysterious "my topic publishes but nothing receives" problems, the answer is almost always a QoS mismatch, and you will be reading the official Concepts pages rather than a tutorial
Practice task: build a multi-node system with no robot and no simulator at all. A sensor publisher, a processing node, a service-based configuration node and a parameterised aggregator, with your own custom .msg and .srv, wired together in a Python launch file that takes arguments. Record it with ros2 bag and replay it. This costs nothing and it proves you understand the graph rather than that you can run turtlesim
3. URDF, TF and describing a robot
Resources:
1. Articulated Robotics, Coordinate Transforms for Robotics (free)
Link: https://articulatedrobotics.xyz/category/coordinate-transforms-for-robotics
A dedicated series on frames and transforms, which is the concept that blocks most people's understanding of URDF
2. Edouard Renard, Level 2: TF, URDF, RViz, Gazebo (Udemy, roughly $10 to $20 on sale)
Link: https://www.udemy.com/course/ros2-tf-urdf-rviz-gazebo/
The single best URDF resource, covering xacro macros, robot_state_publisher, RViz configuration and Gazebo plugins, ending in a mobile base with an arm on it
3. Official URDF tutorial with robot_state_publisher (free)
The canonical walkthrough, available in both C++ and Python variants
Common issues to learn:
- Confusing joint_state_publisher with robot_state_publisher. Fix: the first invents joint positions, the second computes transforms from them
- Missing inertial tags. Fix: your robot explodes or sinks through the Gazebo floor without them, so always include mass and inertia
- A missing static transform to the lidar frame. Fix: this causes more beginner SLAM failures than any algorithm problem
- Writing 400 lines of XML by hand. Fix: use xacro macros from day one
Practice task: design your own robot in xacro, not TurtleBot. A differential-drive base, a sensor mast and a two-DOF pan-tilt head, with correct inertias and separate collision and visual geometry. Drive the joints with joint_state_publisher_gui and view the full TF tree in RViz. A screenshot of your own robot in RViz is the most legible signal in a beginner portfolio
4. Simulation
The Gazebo naming history confuses everyone, so here it is cleanly
Gazebo Classic, versions 1 to 11, reached end of life in January 2025. It was rewritten and briefly called Ignition Gazebo, then renamed back to plain Gazebo in an announcement in April 2022, with every ign command becoming gz. If a tutorial types roslaunch gazebo_ros or ign gazebo, it is out of date
Current releases are named alphabetically: Fortress, Garden, Harmonic, Ionic, Jetty
Install the version paired with your ROS 2 distro or you will fight build errors: Humble pairs with Fortress, Jazzy pairs with Harmonic, Kilted with Ionic, Lyrical with Jetty
Resources:
1. Gazebo documentation and tutorials (free)
Link: https://gazebosim.org/docs/latest/getstarted/
Building your own robot, moving it, SDF worlds, sensors, and spawning a URDF
2. MuJoCo (free, open source)
Link: https://mujoco.readthedocs.io/en/stable/overview.html
The fastest and most accurate contact dynamics available, CPU-first so it needs no GPU, and it is the research standard for locomotion and manipulation learning
3. NVIDIA Isaac Sim (free download)
Link: https://docs.isaacsim.omniverse.nvidia.com/6.0.0/installation/requirements.html
Photoreal simulation and synthetic data generation, and read that requirements link before getting excited: the minimum is an RTX 4080 with 16GB VRAM, and data-centre cards without RT cores such as the A100 and H100 are not supported at all
Decision framework:
- Learn Gazebo first, because it is the only simulator natively wired into ROS 2 and it runs on the laptop you already own
- Go to MuJoCo when you want reinforcement learning or locomotion, and it still needs no GPU
- Go to Isaac Sim or Isaac Lab only when you have the RTX hardware and a specific reason
- Skip PyBullet, which has had no release since 2022 and whose maintainers closed the issue tracker
- Watch Genesis but do not build a portfolio on it yet, since v1.0 is fresh and it has no ROS 2 integration
Practice task: put your xacro robot from the last section into Gazebo, add a lidar plugin and a camera plugin, and build a custom SDF world with obstacles for it to sit in. Confirm the sensor data appears on ROS 2 topics and renders in RViz
5. ros2_control
This is the topic most self-taught candidates have never touched, which makes it the fastest way to differentiate yourself
Resources:
1. ros2_control documentation (free)
Link: https://control.ros.org/rolling/index.html
Where URDF meets actuation: hardware interfaces, controller manager, and the <ros2_control> tags that go in your xacro
2. Articulated Robotics, ros2_control on real hardware (free)
Link: https://articulatedrobotics.xyz/tutorials/mobile-robot/applications/ros2_control-real/
The only resource that walks the simulation-to-real-hardware transition properly
Practice task: add <ros2_control> tags to your robot, configure diff_drive_controller and joint_state_broadcaster through YAML, and drive it in Gazebo with keyboard teleop. Then write an action server that drives a commanded distance and reports progress, with feedback and cancellation. Actions plus ros2_control in one project is a genuinely strong portfolio piece
6. SLAM and navigation
Resources:
1. Nav2 Getting Started (free)
Link: https://docs.nav2.org/rolling/getting_started/index.html
Launches Nav2 in simulation in under five minutes, with a pre-configured VS Code dev container that removes all install pain
2. Nav2 Tutorials (free)
Link: https://docs.nav2.org/rolling/tutorials/
Covers SLAM, keepout zones, speed limits, collision monitoring, docking, GPS navigation, and writing your own planner, controller or behaviour-tree node
3. SLAM Toolbox (free, open source)
Link: https://github.com/SteveMacenski/slam_toolbox
The currently supported ROS 2 SLAM library, with synchronous, asynchronous, lifelong and localization-only modes, and multi-robot support
4. RTAB-Map for ROS 2 (free, open source)
Link: https://github.com/introlab/rtabmap_ros
Appearance-based RGB-D and stereo SLAM with loop closure, for when you have a depth camera rather than a lidar, or want a 3D map
What to focus on:
- The difference between mapping and localizing, and when to switch SLAM Toolbox into localization mode
- Odometry quality, because SLAM Toolbox needs it and a smeared map is almost always an odometry problem rather than an algorithm problem
- Costmap tuning: inflation radius, obstacle layers, and the local versus global split
- Behaviour trees, which is how Nav2 orchestrates everything and the part beginners fail to grasp
Hardware for real SLAM, three tiers:
- $0: Gazebo with a simulated lidar. Do the entire SLAM and Nav2 curriculum here first
- $250 to $450: DIY: RPLIDAR C1 at $69, a Raspberry Pi 4 or 5, a differential-drive base with encoders, a motor driver and a battery. Most learning per dollar, and the most yak-shaving
- $300 to $535: a ready platform. Hiwonder MentorPi M1 from $299.99 runs ROS 2 Humble on a Pi 5 with lidar and a depth camera. Waveshare's UGV Rover ROS 2 kit at $534.99 splits a Pi host and an ESP32 real-time controller, which is how real robots are actually architected
Link: https://www.hiwonder.com/products/mentorpi-m1
Link: https://www.waveshare.com/ugv-rover-ros2-kit.htm
Practice task: run SLAM Toolbox in your Gazebo world, teleop around it, save the map, then switch to localization mode and send Nav2 goals from RViz. Tune the costmaps until it stops clipping corners. Then screen-record it. A video of a robot autonomously navigating a map it built itself is the most compelling artifact a self-taught roboticist can produce
Month 4 Milestone
By the end of this month you should be able to:
- Write ROS 2 nodes in both Python and C++ that use topics, services and actions
- Describe your own robot in xacro with correct frames, inertias and collision geometry
- Simulate that robot in Gazebo with working lidar and camera sensors
- Configure ros2_control and drive the robot through a controller rather than raw commands
- Build a map with SLAM Toolbox and navigate autonomously with Nav2
- Diagnose a broken TF tree, which is the most common failure in the entire stack
⏩---------------------------------------------------------------------⏪
Month 5: The maths that makes robots actually work
Your goal this month: understand and implement the control and perception underneath everything you have built
Up to now you have used libraries that did the hard parts for you
This month is where you learn what they were doing, because the difference between someone who can configure Nav2 and someone who can fix Nav2 when it misbehaves is exactly this material
You do not need all of it at research depth. You need working fluency in control, enough kinematics to reason about an arm, and enough vision to get 3D information out of a camera
What to learn
1. Control theory, starting with PID
You already tuned a PID controller by feel in month two. Now learn why it worked
Resources:
1. Understanding PID Control, MATLAB Tech Talks with Brian Douglas (free)
Link: https://www.mathworks.com/videos/series/understanding-pid-control.html
Seven parts covering what PID is, integrator windup, derivative filtering, tuning, and manual versus automatic tuning. The fastest route from zero to a controller that works this week
2. Brian Douglas, Control System Lectures (free)
Link: https://www.youtube.com/@BrianBDouglas/playlists
Intuition-first explanations across PID, state space, robust control and drone control, and the best fit for someone with no formal controls course behind them
3. The Fundamentals of Control Theory, Brian Douglas (free, Creative Commons)
Link: https://engineeringmedia.com/books
The written companion to the videos, and a coherent narrative rather than scattered lessons
4. Control Bootcamp, Steve Brunton (free)
Link: https://www.youtube.com/playlist?list=PLMrJAkhIeNNR20Mz-VpzgfQs5zrYi085m
Thirty-nine videos and the right entry point to state space, controllability, observability, LQR and the Kalman filter
5. Feedback Systems, Åström and Murray (free PDF)
Link: https://fbswiki.org/wiki/index.php/Feedback_Systems:_An_Introduction_for_Scientists_and_Engineers
The rigorous textbook, released free by Princeton University Press, for when you want the proper version without paying
What to focus on:
- What each of P, I and D physically does, and the failure mode of each
- Integrator windup, and why your arm slams when it comes off a limit
- Why the derivative term amplifies sensor noise and needs filtering
- Steady-state error, and when an integrator is the fix versus when gravity compensation is the fix
- Feedforward, which is the cheapest performance improvement most people never add
Practice task: take the balancing robot from month two and implement three controllers on the same hardware: P only, PD, then PID with feedforward. Log the step response of each to a CSV, plot all three, and write up which one you would ship and why. That plot is worth more in an interview than any certificate
2. State space, LQR and MPC
Resources:
1. Understanding Model Predictive Control, MATLAB Tech Talks (free)
Link: https://www.mathworks.com/videos/series/understanding-model-predictive-control.html
Seven parts from why to use MPC through adaptive and nonlinear variants, and how to make it run fast enough to be real
2. Underactuated Robotics, Russ Tedrake, MIT (free)
Link: https://underactuated.csail.mit.edu/index.html
This is where control theory becomes robotics: pendulums, cart-poles, walking, running and humanoids, with dynamic programming, LQR, Lyapunov analysis and trajectory optimisation. Free notes, free PDF and lecture videos
What to focus on:
- Representing a system as state, input and output rather than a transfer function
- Why LQR is just a principled way of choosing gains
- What MPC buys you, which is constraints, and what it costs, which is compute
- Underactuation, and why a robot with fewer actuators than degrees of freedom needs completely different thinking
Practice task: implement LQR for a simulated cart-pole in Python, then implement the same thing with a hand-tuned PID and compare how each handles a disturbance. Tedrake's notes give you the model, so you are implementing rather than deriving
3. Kinematics and dynamics
Resources:
1. Modern Robotics, Kevin Lynch, Northwestern (free book, code and videos)
Link: http://hades.mech.northwestern.edu/index.php/Modern_Robotics
The free preprint of the standard textbook, plus companion libraries in Python, MATLAB and Mathematica and full video lectures. It uses screw theory and product-of-exponentials rather than DH parameters, which is cleaner and now the industry norm
2. Modern Robotics Specialization (Coursera, free audit available)
Link: https://www.coursera.org/specializations/modernrobotics
The same material as a structured six-course sequence with assessment, if you need deadlines to finish things
3. Robotics Toolbox for Python, Peter Corke (free, MIT)
Link: https://github.com/petercorke/robotics-toolbox-python
Forward kinematics, Jacobians, numerical IK, trajectory generation and fifty-plus real robot models including Franka and UR, so you learn by running code against real arms
4. QUT Robot Academy, Peter Corke (free)
Link: https://robotacademy.net.au
Over 200 video lessons of under ten minutes each, labelled by prerequisite level, and the best source of short atomic explanations of DH parameters, Jacobians and pose representation
What to focus on:
- Homogeneous transforms and composing them, which is the language of everything
- Forward kinematics, which is easy, and inverse kinematics, which is not
- The Jacobian, and what a singularity physically means when your arm suddenly cannot move sideways
- Workspace limits, and joint limits versus reachability
- Trajectory generation, and why you interpolate in joint space sometimes and Cartesian space other times
Practice task: compute the forward kinematics of your SO-101 arm by hand from its link lengths, then verify against the Robotics Toolbox. Then write a numerical IK solver that moves the end effector to a commanded XYZ, and watch what it does near a singularity. Feeling the arm lose a degree of freedom is what makes the concept stick
4. Perception and computer vision
Resources:
1. FREE OpenCV Bootcamp (OpenCV.org official, free)
Link: https://courses.opencv.org/courses/course-v1:OpenCV+Bootcamp+CV0/about
The official two-to-three hour course from OpenCV themselves, covering image manipulation, filtering, edge detection, tracking and the DNN module. Start here rather than a paid course
2. OpenCV Camera Calibration tutorial (official docs, free)
Link: https://docs.opencv.org/4.x/dc/dbb/tutorial_py_calibration.html
The canonical walkthrough with full Python code, from chessboard corners to undistortion to re-projection error. Every robotics engineer must be able to do this from memory
3. Cyrill Stachniss lectures, University of Bonn (free)
Link: https://www.ipb.uni-bonn.de/online-training-robotics/
Full university lecture recordings on mobile sensing, photogrammetry and SLAM, and the best free source on the geometric side: projective geometry, bundle adjustment, EKF and graph SLAM
4. Open3D point cloud tutorials (free)
Link: https://www.open3d.org/docs/release/tutorial/geometry/pointcloud.html
Voxel downsampling, normal estimation, ICP registration, plane segmentation and clustering, with far less friction than PCL for anyone already in Python
What to focus on:
- Camera intrinsics and distortion, and doing a real calibration with a printed chessboard
- Pinhole projection, and the difference between image coordinates and world coordinates
- Depth from stereo versus structured light versus time-of-flight
- Point cloud basics: downsampling, plane fitting to find a table, clustering to find objects on it
- Why lighting changes break vision pipelines that worked yesterday
Practice task: calibrate an actual camera with a printed chessboard, save the intrinsics, then write a script that detects a coloured object and estimates its position in 3D relative to the camera. Then move the lighting and watch it fail, and fix it. That failure-and-fix write-up is portfolio material
5. Manipulation and MoveIt 2
Resources:
1. MoveIt 2 Getting Started (free, open source)
Link: https://moveit.picknik.ai/main/doc/tutorials/getting_started/getting_started.html
The official entry point, and the docs recommend Jazzy on Ubuntu 24.04 for the smoothest experience
2. Pick and Place with MoveIt Task Constructor (free)
The most useful manipulation tutorial in ROS 2, teaching how to decompose a task into stages and implement grasp generation, IK and collision management
3. Robotic Manipulation, Russ Tedrake, MIT (free)
Link: https://manipulation.csail.mit.edu/
Twelve chapters connecting hardware, kinematics, perception, grasping, planning and control into one coherent stack, and it now teaches model-based and learned approaches together, which is exactly how the industry now works
4. Contact-GraspNet, NVIDIA (free code)
Link: https://github.com/NVlabs/contact_graspnet
Six-DOF grasp generation in cluttered scenes from a depth map, and the standard baseline for learned grasping
Practice task: get MoveIt 2 planning motions for a simulated arm, add collision objects to the planning scene, and execute a pick and place. Then make it fail by placing an obstacle in the only viable path and observe how the planner behaves. Understanding planner failure is more valuable than watching it succeed
Month 5 Milestone
By the end of this month you should be able to:
- Implement and tune a PID controller and explain every term from measured data
- Describe a system in state space and implement LQR on a simulated plant
- Compute forward kinematics by hand and solve IK numerically
- Explain what a singularity is by pointing at a robot doing it
- Calibrate a camera and turn a pixel into a 3D position
- Plan and execute a collision-free pick and place in MoveIt 2
⏩---------------------------------------------------------------------⏪
Month 6: Robot learning, specialisation, and becoming hireable
Your goal this month: pick one direction, build a portfolio piece in it, and start applying
You now have the whole stack: electronics, embedded, mechanical, ROS 2, control and perception
This month has two halves. The first is the frontier, which is teaching robots from demonstrations rather than programming them. The second is turning everything you have built into something that gets you hired
Part one: modern robot learning
This is the part of robotics that changed completely in the last two years, and it is the reason there is so much capital in the field
1. LeRobot
LeRobot is Hugging Face's PyTorch library for real-world robotics, and it is the open hub the whole low-cost robot-learning world has converged on
The workflow is: teleoperate, record, train, deploy. You drive the robot by hand, demonstrations are saved as synchronised video and action data, a policy learns to imitate them, then it runs on its own
Resources:
1. LeRobot documentation (free)
Link: https://huggingface.co/docs/lerobot/index
The main docs, covering the full pipeline and every supported robot
2. LeRobot repository (free, Apache 2.0)
Link: https://github.com/huggingface/lerobot
Over 26,000 stars, and the place to read how the policies are actually implemented
3. Hugging Face Robotics Course (free, no hardware required)
Link: https://huggingface.co/learn/robotics-course/unit0/1
Runs entirely on simulated environments and public datasets, so you can do the whole thing before buying anything. Roughly 30 to 45 minutes per unit
4. SO-101 setup guide (free)
Link: https://huggingface.co/docs/lerobot/so101
The exact port-finding, motor-setup, calibration and recording commands for the arm you built in month three
What to focus on:
- The record-train-deploy loop end to end, on your own arm
- Dataset quality, because a policy trained on sloppy demonstrations is a sloppy policy
- ACT, which the docs recommend as the starting policy, and why predicting chunks of future actions works better than predicting single steps
- Diffusion Policy, which represents the policy as a denoising process and reported a 46.9% average improvement over prior methods across twelve tasks
Practice task: record 50 demonstrations of a single simple task on your SO-101, such as picking up a cube and dropping it in a bin, train an ACT policy, and deploy it. It will work maybe half the time. Then record 50 more demonstrations covering the failure cases and retrain. Document the success rate before and after. That number, and the fact that you measured it, is the portfolio piece
2. Vision-language-action models
These are the foundation models of robotics, and knowing which ones you can actually run matters
- π₀, π₀-FAST and π₀.₅ from Physical Intelligence, Apache 2.0, weights open, pretrained on 10,000+ hours of robot data. The repo warns honestly that these were developed for their own robots and transfer is not guaranteed
Link: https://github.com/Physical-Intelligence/openpi
- OpenVLA, 7B parameters, fully open, trained on 970,000 robot episodes from Open X-Embodiment, and the best-documented open VLA to read the code of
Link: https://openvla.github.io/
- GR00T N1.7 from NVIDIA, code Apache 2.0 with weights under the NVIDIA Open Model License, which is a distinction often reported wrongly. Needs 16GB+ VRAM for inference
Link: https://github.com/Nvidia/Isaac-GR00T
- SmolVLA from Hugging Face, compact and designed for affordable hardware, which is the right one to fine-tune on an SO-101 rather than reaching for a 7B model
Link: https://huggingface.co/lerobot/smolvla_base
- RT-2 from Google DeepMind is historically important and has no public weights, so study the paper and use one of the above for practice
3. Reinforcement learning for robotics
Resources:
1. MuJoCo Playground (free, Apache 2.0)
Link: https://github.com/google-deepmind/mujoco_playground
GPU-accelerated environments for locomotion, manipulation and vision tasks with four Colab tutorials, and far easier to get running than the alternatives. Start here
2. NVIDIA Isaac Lab (free, BSD-3)
Link: https://github.com/isaac-sim/IsaacLab
Sixteen robot models and thirty-plus pre-built training environments, integrating RSL RL, skrl, RL Games and Stable Baselines. The industry standard for legged and humanoid sim-to-real, and it needs the RTX hardware from month four
3. CS 285, Deep Reinforcement Learning, Sergey Levine, UC Berkeley (free)
Link: https://rail.eecs.berkeley.edu/deeprlcourse
The best RL course available, and Levine is a robotics researcher so the framing is robotics-native throughout, covering imitation learning, policy gradients, actor-critic, model-based and offline RL
Practice task: train a quadruped locomotion policy in MuJoCo Playground from one of the Colab tutorials, then change the reward function and observe how the gait changes. You do not need hardware and you do not need a GPU beyond what Colab gives you free
Part two: pick a direction
Three directions genuinely exist. Pick one, and let the other two stay at literacy level
Direction 1: Robot learning and embodied AI
Best if you want the frontier companies and the highest ceiling
Focus on: LeRobot, VLA fine-tuning, imitation learning, RL, simulation, PyTorch
This is the highest-paid track and also the most competitive, and it is where a real dataset you collected yourself is worth more than any credential
Direction 2: Autonomy and mobile robotics
Best if you want the largest number of available jobs
Focus on: ROS 2, Nav2, SLAM, perception, sensor fusion, C++
Controls engineer and field service engineer together are over 20% of all robotics postings, and this direction serves both
Direction 3: Embedded, mechatronics and integration
Best if you want to work immediately, including as a contractor
Focus on: firmware, motor control, real-time systems, PLCs, functional safety, system integration
This is the least glamorous and the most consistently employable, and it is where the technician-to-engineer path actually runs. Note that 66% of robotics projects report delays caused by certification, so functional safety knowledge is a genuine and underserved specialism
4. Your portfolio
I looked at what recruiters in this field actually say they screen for, and the pattern is consistent
High signal:
- GitHub repos with logged metrics and a commit history that shows iterative debugging, not a finished demo dropped in one commit
- Evidence of real-robot deployment with reliability data, not simulation only
- Public datasets on the LeRobot Hub, where there are already tens of thousands of community datasets
- Contributions to the packages employers depend on: ROS 2 core, Nav2, MoveIt, Isaac Lab, LeRobot
- Systems integration work joining sensors to actuators to planning to control, with video and clear documentation
Red flags they name explicitly:
- Still on end-of-life ROS 1 with no migration evidence
- Claimed projects that cannot survive three follow-up questions
- A pure deep-learning background with no kinematics or embodiment understanding
- Tutorial completion certificates, which are weighted far below real contributions
Practice task: take your three best projects and rewrite their READMEs. Each one needs a video at the top, a wiring or architecture diagram, the actual numbers you measured, and a section titled "what broke and how I fixed it". That last section is the single highest-value thing in a self-taught portfolio, because it is the part that cannot be faked from a tutorial
5. Interviews
Robotics interviews are not software interviews, and leetcode is a much weaker predictor here
Expect: inverse kinematics questions, PID and feedback loops, sensor fusion and Kalman filters, SLAM concepts, path planning including RRT, and C++ versus Python trade-offs
Expect also, at good companies: a simulation-based debugging exercise where they hand you a MuJoCo or Isaac scene with a deliberately broken controller, a ROS 2 architecture problem scoped to the real job, and a long conversation about a specific past failure and how you diagnosed it
Glassdoor has 1,721 robotics engineer interview questions on file from 877 companies if you want to read real examples
Link: https://www.glassdoor.com/Interview/robotics-engineer-interview-questions-SRCH_KO0,17.htm
Practice task: have someone interrogate you about your own repo for twenty minutes. Not the concepts, your specific code. Why that gain, why that sensor, what happens if the battery sags, what did you try before this worked. If you cannot answer three levels deep, the project is not ready to be on your CV
Month 6 Milestone
By the end of this month you should be able to:
- Record a demonstration dataset and train a policy that runs on your own hardware
- Explain the difference between behaviour cloning, ACT and diffusion policy
- Name which VLA models have open weights and which do not
- State which of the three directions you are pursuing, and why
- Show three portfolio projects with video, metrics and a documented failure analysis
- Answer three levels of follow-up questions about any line of your own code
⏩---------------------------------------------------------------------⏪
CONCLUSION
What you can expect after these 6 months???
I am going to be honest, because the honest version is the only version worth reading
This roadmap will not make you a senior robotics engineer in six months
Senior in this field means five or more years of deploying real-time systems on physical robots, and every job listing I checked says so explicitly
What it will make you is someone who can build, debug and ship working robots, who understands the stack from the electrical layer up to the learned policy, and who has the physical portfolio to prove it
That is enough to get you into the field, and the field is where the compounding happens
The demand picture, honestly
I want to give you the real numbers rather than the recruiting-blog numbers, because several widely-quoted robotics statistics do not survive checking
The capital is real. Physical AI startups raised $47.4B in H1 2026 across 521 deals, more than 2022 to 2024 combined, per Crunchbase. Narrower robotics-only funding hit $18.8B by late June 2026, against $15B for all of 2025
The individual rounds are real. Neura Robotics raised $1.4B, Skild AI $1.4B, Apptronik $520M, and Figure carries a $39B post-money valuation per The Robot Report's 2026 outlook
But hiring is lagging the capital, and you should know that. North American robot orders grew only 2.0% in units in H1 2026 per A3. US installations fell 9% in 2024 per the IFR. The BLS occupational code containing robotics engineers projects 1 to 2% growth, not the 10% figure you will find quoted in career articles with no source behind it
And robotics is a much smaller labour market than software. BLS projects 106,100 annual openings for software developers against roughly 57,200 for mechanical, electrical and industrial engineers combined
So the accurate claim is not "robotics is booming, everyone will get hired"
It is that money is arriving faster than qualified people are, that the shortage is concentrated in specific specialisms, and that the entry tier is unusually open to people without degrees
One number that makes that concrete: the largest robotics job category by posting volume is Automation and Robotics Technician at 20.3% of 3,113 postings, and 68% of robotics technician roles are satisfied by an associate's degree or a certificate per O*NET
What it pays
Full-time in the US, and note that sources disagree substantially, so I am giving you the range and the source rather than one flattering number:
- O*NET/BLS median: $122,930 for robotics engineers, which is the only official figure here
- Entry level: roughly $80k to $100k per Payscale and Salary.com, higher at coastal and well-funded employers
- Mid level, 3 to 6 years: $120k to $165k at conventional employers
- Senior: $160k to $230k mainstream
- Frontier physical-AI companies pay well above that. A live Figure listing for Helix AI Engineer, Robot Learning posts $200,000 to $400,000 base, and their perception role posts $200,000 to $350,000
- Robot foundation model specialists: $280k to $475k total comp per recruiter placement data, though that is recruiter-reported rather than survey data and is heavily equity-weighted
Outside the US, to calibrate: Germany around €70,000 median total per Glassdoor, Switzerland around CHF 95,000, UK base £32,000 to £50,000, India around ₹653,000
Freelance and contract:
- Robotics engineers on Upwork list $22 to $70/hour, clustering $30 to $50
- ROS project work on Upwork is priced per deliverable: $500 to $1,200 for a node implementation, $1,200 to $2,500 for launch configuration, $4,500 to $7,000 for a sensor integration pipeline, $7,000 to $12,000 for a full system architecture
- ZipRecruiter puts ROS developers at an average $52.84/hour
And the number that makes integration a career rather than a task: in a robot cell, the robot itself averages about 25% of the total project cost. The other three quarters is engineering, safety and integration. A $35k arm becomes an $80k working system, and that $45k gap is what you are selling
Entry points that need no degree and no experience:
- Teleoperation and data collection averages $28.24/hour, with most between $22.12 and $32.93. Figure posted a Humanoid Robot Operator role at $25 to $35/hour with no degree requirement stated, and Weave Robotics posted at $25/hour
- Robotics technician median $73,900 per BLS, typically entering with an associate's degree
Be clear-eyed about the first one: that pay band is mostly in the most expensive metros in the US, often on-site and physically demanding. It is a genuine foot in the door at frontier companies, and it is not a comfortable living in San Francisco
Now here is what I actually want you to take away from all of this
Build the projects, do not read about them. Pick one build from each month and actually make it. The line follower, the balancing robot, the arm, the ROS 2 navigation stack, the trained policy. Break them, fix them, film them, push them to GitHub. Every recruiter source I checked said the same thing: portfolio-first sourcing beats keyword search, and the projects that get people hired are the ones with logged metrics and a visible debugging history
Write down what broke. This is the specific advice I would give if you only take one thing from this article. Anyone can post a working demo. Almost nobody documents the four things that failed first and how they diagnosed each one. That write-up is the closest thing to proof that you can actually engineer, and it is the reason your repo survives the third follow-up question in an interview
Start before you feel ready. Apply for the technician role, take the teleoperation shift, contribute the small fix to Nav2, message the founder of the three-person robotics startup. The gap between "I am learning robotics" and "I work in robotics" is almost entirely a gap of nerve, and nobody in this field will ever tell you that you have studied enough
Six months of two focused hours a day is enough to change what you are able to do with your hands and your head
The hardware is cheaper than it has ever been, the software is open, the courses are free, and the people who can actually make machines work are genuinely scarce
Go build something that moves
Hope this was useful for you my fam ❤️