When we started our Innovation Project this season, we knew pretty quickly that a LEGO robot wasn’t going to cut it. We needed something with more reach, more precision, and more degrees of freedom than the SPIKE Prime kit could give us. So we did something a little crazy for a middle school team:
We decided to build our own robot arm — the SO-101, an open-source 6-axis robotic arm from Hugging Face’s LeRobot project.
And almost immediately, we ran into the question every robotics team eventually faces:
Servos or steppers?
Here’s how we figured it out — and why you should care, even if you’re just building with LEGO.
What We Actually Needed
Our robot had to do a few different things — moving, manipulating objects, and positioning sensors precisely. Without giving away too much about the Innovation Project itself (we’re saving that for the big reveal), the core requirement was this:
It had to hit exact positions, repeatedly, without drifting.
If our arm was off by even a few degrees on each move, the errors would stack up across the whole task. By the time it got to the end of a sequence, it’d be way off target. We needed something that knew where it was at all times — not something that just hoped.
That requirement basically wrote the answer for us. But we still tested both, because that’s what engineers do.
Steppers: Predictable, But Not Smart
Stepper motors move in fixed steps — usually 1.8 degrees per pulse. You send 200 pulses, the motor turns exactly once. Send 50 pulses, it turns a quarter. Clean and predictable.
This is why steppers are everywhere in 3D printers and CNC machines. The print head needs to move to exactly this XY coordinate, every single time, with no variation. Steppers are perfect for that.
But here’s the catch: steppers are open-loop. They don’t have feedback. They just trust that every pulse caused a step. If something blocks the motor — say, the arm bumps into something, or the load is too heavy — the motor “skips” a step, and now it thinks it’s somewhere it isn’t.
When we tested steppers briefly, this is exactly what happened. The moment we added weight to the arm or it caught on something, we lost our reference position. The only way to recover was to reset the whole arm to a known starting position and try again. For a project where every movement builds on the last one, that was a dealbreaker.
Servos: They Actually Pay Attention
A servo motor is the opposite — it’s a closed-loop system. It has a sensor (usually an encoder or potentiometer) that constantly tracks where it actually is, compares that to where it’s supposed to be, and corrects in real time.
You tell a servo “go to 45 degrees” and it doesn’t just turn until it thinks it’s done — it verifies. If something pushes against it, it pushes back. If it overshoots, it corrects. It’s like the difference between throwing a dart with your eyes closed (stepper) versus throwing one while watching where it lands and adjusting (servo).
The SO-101 we built uses six STS3215 bus servos — high-torque servos with magnetic position feedback. Each joint of the arm knows its exact angle at all times. When we tell the arm to move to a specific position, every motor verifies it got there.
For us, this was the whole game. Closed-loop feedback meant:
- We could trust the position every single time
- We could recover from disturbances without resetting
- We could chain movements together without errors stacking up
- We could even train the robot through demonstration — physically moving the arm and having it remember the positions, because the encoders captured everything
The Trade-offs (Because There Always Are Some)
Servos aren’t a free win. Here’s what we gave up:
- Cost. Servos are more expensive than steppers, especially the kind with strong torque and reliable feedback. The STS3215 motors in our SO-101 aren’t cheap.
- Complexity. Each motor has its own microcontroller, communication protocol, and ID on a shared bus. Setting up six of them is a lot more involved than wiring up steppers.
- Wear. Servos have more moving parts in the feedback system. They’re more prone to wear out under heavy use. The SO-101 documentation even recommends keeping spare motors on hand. (We learned this the hard way.)
But for precision-critical work, the trade-offs were worth it.
What We Learned (That Applies To Any Robotics Project)
Even if you’re not building a custom robot arm, the lesson here matters:
The “right” motor depends entirely on what you’re optimizing for.
- Need exact, repeatable rotation with no feedback loop needed? → Stepper.
- Need precise positioning that recovers from errors? → Servo.
- Need continuous spinning at a steady speed? → Neither, honestly — use a regular DC motor.
The LEGO SPIKE Prime motors most FLL teams use are also servos, by the way. That’s why you can program them with “rotate 720 degrees” and trust the result. The encoder inside is doing the same job our STS3215 motors do — just smaller and built into a LEGO-friendly package.
The Bottom Line
We picked servos because our Innovation Project lives and dies on precision. We can’t afford to drift. We can’t afford to skip a step and never know it. We needed motors that paid attention — and that’s exactly what servos do.
Testing both before deciding mattered too. It would’ve been easy to just pick servos because that’s what the SO-101 design called for, but actually trying steppers gave us a real understanding of why the design called for servos. That’s the difference between using a tool and understanding a tool.
Stay tuned — we’ll share more about the Innovation Project itself soon. For now, just know that somewhere in our workshop, six tiny servo motors are doing some very precise work.