Robotics Interview Questions and Answers for Freshers (2026)

Think of a viva in your final year. The examiner does not want the textbook recited; they want to see that you understand why things work. The quickest way to show it is "here is what happened when I tried it".

A robotics interview is a viva with a hiring decision attached. Every good answer ends with an example from a real build.

How are robotics interviews for freshers structured?

A robotics interview is a set of rounds that check whether a candidate can reason about robot hardware, control and software, write working code under time pressure, and explain their own projects in depth. The rounds vary by company, but most follow this shape.

The project deep-dive often decides the outcome, so prepare it as carefully as the theory.

Startups often merge rounds into one long technical conversation; larger companies add an online aptitude and coding test first.

Robotics fundamentals interview questions

What is a degree of freedom?

A degree of freedom (DOF) is one independent way a robot or joint can move. A rigid body in space has six: three translations and three rotations. A typical industrial arm has six joints, so it can place its tool at any position and orientation within reach.

What is the difference between open-loop and closed-loop control?

Open-loop control sends a command without checking the result, such as running a motor at 60% PWM for two seconds. Closed-loop control measures the output with a sensor and corrects the command continuously, such as using an encoder to hold 100 rpm under changing load.

What is the difference between forward and inverse kinematics?

Forward kinematics computes where the end-effector is from known joint angles; it has one answer. Inverse kinematics computes the joint angles needed to reach a target pose; it can have several answers or none. See robot kinematics for worked examples.

Why can't a differential drive robot move sideways?

Its two wheels roll forward and backward but cannot slide sideways, a non-holonomic constraint. It can reach any position, but only by turning and driving, as explained in differential drive robots.

Electronics and embedded systems interview questions

What is PWM and how does it control motor speed?

Pulse-width modulation switches a pin fully on and off at a fixed frequency and varies the fraction of time it is on, the duty cycle. The motor's inertia averages the pulses, so 50% duty gives roughly half the average voltage and a lower speed.

Why does a motor need a motor driver?

A microcontroller pin supplies a few tens of milliamps, while a motor needs hundreds or more, plus reversing. A driver such as an H-bridge switches battery current under the pin's control and shields the board from motor noise and back-EMF.

What is the difference between UART, I2C and SPI?

UART is point-to-point, I2C shares two wires by address, and SPI is fastest but needs a select line per device.

What is an interrupt and when would you use one?

An interrupt makes the processor pause its main loop and run a short handler the moment a hardware event happens, such as an encoder pulse. Use one when missing an event is costly, and keep the handler tiny.

What is switch debouncing?

A mechanical switch's contacts bounce for a few milliseconds, producing several false edges. Debouncing ignores changes for a short window after the first edge, in software or with an RC filter, so one press counts once.

Control and sensor interview questions

Explain PID control. What does each term do?

PID computes a correction from the error between target and measurement. P reacts to the present error, I removes steady error by accumulating past error, and D damps overshoot by reacting to how fast the error changes. The PID control tutorial covers tuning.

What is integral windup and how do you prevent it?

When the output is saturated, for example PWM stuck at 255 because a wheel is jammed, the integral keeps growing. When the jam clears, the huge integral causes a long overshoot. Anti-windup stops integrating while saturated, or clamps the integral. The code below shows the difference.

Why does odometry drift, and how do you reduce it?

Wheel slip, uneven diameters and tick rounding add small errors that accumulate without limit. Calibrate wheel size and track width, then fuse other sensors: an IMU for heading, a camera or lidar for absolute position.

What does a Kalman filter do?

It estimates a system's state by combining a motion model with noisy measurements, weighting each by its uncertainty. It predicts, then corrects with each new reading. See the Kalman filter tutorial for a simulation.

ROS 2 interview questions

What is the difference between a topic, a service and an action in ROS 2?

A topic is a continuous publish/subscribe stream, such as camera images. A service is a request with one reply, such as "reset odometry". An action is a long-running goal with feedback and cancellation, such as "navigate to the kitchen". The ROS 2 basics guide shows each.

What is tf2?

tf2 is the ROS 2 library that tracks coordinate frames, such as map, odom, base_link and camera_link, over time, so any node can ask "where is this point in the map frame?" without doing the maths itself.

What are QoS profiles in ROS 2?

QoS settings control delivery: reliable or best-effort, how many messages to keep, and whether late joiners get the last one. Sensor streams often use best-effort; commands and maps use reliable.

Which ROS 2 version should I use?

As of November 2026, ROS 2 Lyrical Luth (May 2026) is the newest long-term-support release, supported until May 2031 on Ubuntu 26.04. Jazzy Jalisco (May 2024) is the previous LTS, supported until May 2029, and still common in industry.

Perception and edge AI interview questions

How would you run object detection in real time on a robot?

Pick a small detector, quantise it to int8 and run it with an optimised runtime on suitable hardware, such as a Pi with an NPU or a Jetson. Lower the input resolution if needed and measure the whole pipeline. The edge AI hardware guide covers choosing a board.

What is quantisation and why does it matter on robots?

Quantisation stores weights and activations as 8-bit integers instead of 32-bit floats, making models about 4× smaller and much faster on integer hardware, usually at a small accuracy cost. Details are in model quantisation for the edge.

Robotics coding round: two exercises to practise

Interviewers often ask for a controller or an odometry update in 15 minutes. Practise both until you need no notes.

class PID:
    def __init__(self, kp, ki, kd, out_min, out_max, anti_windup=True):
        self.kp, self.ki, self.kd = kp, ki, kd
        self.lo, self.hi, self.aw = out_min, out_max, anti_windup
        self.integral, self.prev_err = 0.0, None

    def update(self, setpoint, measured, dt):
        err = setpoint - measured
        deriv = 0.0 if self.prev_err is None else (err - self.prev_err) / dt
        self.prev_err = err
        trial = self.integral + err * dt
        out = self.kp * err + self.ki * trial + self.kd * deriv
        if not self.aw or self.lo < out < self.hi:   # only integrate when not saturated
            self.integral = trial
        return min(max(out, self.lo), self.hi)

for aw in (False, True):                 # wheel speed loop, PWM limited to 0..255
    pid, speed, peak = PID(1.5, 6.0, 0.0, 0, 255, anti_windup=aw), 0.0, 0.0
    for step in range(400):              # 4 s at 100 Hz
        pwm = pid.update(100.0, speed, 0.01)
        if step < 150:                   # wheel jammed against a kerb for 1.5 s
            speed = 0.0
        else:
            speed += (0.6 * pwm - speed) * 0.01 / 0.3   # first-order motor, rpm
            peak = max(peak, speed)
    print(f"anti-windup {str(aw):5s}: integral {pid.integral:7.1f}, peak after "
          f"release {peak:6.1f} rpm (target 100), final {speed:6.1f} rpm")

Without anti-windup, the integral grows while the wheel is jammed, so after release the wheel races to full speed, 153 rpm instead of 100, and is still there 2.5 seconds later. With anti-windup it settles near the target almost at once. Mentioning this case in an interview shows you have run real motors.

import math
TICKS_PER_REV, WHEEL_D, TRACK = 360, 0.065, 0.15      # encoder, wheel diameter, wheel gap (m)
M_PER_TICK = math.pi * WHEEL_D / TICKS_PER_REV

def odometry_step(x, y, theta, d_left_ticks, d_right_ticks):
    dl, dr = d_left_ticks * M_PER_TICK, d_right_ticks * M_PER_TICK
    d, dtheta = (dl + dr) / 2, (dr - dl) / TRACK
    x += d * math.cos(theta + dtheta / 2)                # midpoint integration
    y += d * math.sin(theta + dtheta / 2)
    theta = math.atan2(math.sin(theta + dtheta), math.cos(theta + dtheta))
    return x, y, theta

pose = (0.0, 0.0, 0.0)
# 1 m straight, then turn left on the spot by 90 degrees, then 0.5 m straight
turn_ticks = round((math.pi / 2) * TRACK / 2 / M_PER_TICK)
segments = [(1763, 1763), (-turn_ticks, turn_ticks), (881, 881)]
for left, right in segments:
    for _ in range(10):                                   # report in 10 small updates
        pose = odometry_step(*pose, left / 10, right / 10)
    x, y, th = pose
    print(f"after ({left:5d}, {right:5d}) ticks: x={x:.3f} m  y={y:.3f} m  "
          f"heading={math.degrees(th):6.1f} deg")

Note the heading of 90.1° instead of 90°: rounding the turn to a whole number of ticks already introduces error, and in a real robot wheel slip adds more. That is exactly the drift question from earlier, in numbers.

Project and behavioural questions

Expect "Walk me through your best project" and "What went wrong?". Answer in four parts:

1. Goal, with a number: "follow a line at 0.4 m/s on a track with 10 cm radius turns".
2. Your design: parts, control method and why.
3. The problem you hit, and how you diagnosed it with measurements, not guesses.
4. The result: lap time, success rate or battery life, and what you would change.

If you need more projects to talk about, the robotics projects for beginners guide lists 12 with skills mapped to roles.

Key takeaways

• Robotics interviews cover fundamentals, embedded systems, control and sensors, ROS 2, perception and edge AI, plus coding and projects.
• Answer in plain words, then tie each answer to something you built.
• Practise writing PID with anti-windup and odometry updates from memory.
• Know UART, I2C and SPI, interrupts, PWM and motor drivers cold.
• Prepare your project story: goal, design, problem, result, with numbers.