Projects, buildable ones.

End artifact = working keyboard. Hackable layouts. Recruiter-bait if put on GitHub.

Build a ROS2 differential-drive teleop robot on Pi Zero 2W (or Gazebo sim) — the foundation for every later ROS robot.

Build a 5-stage RV32I CPU in Verilator and lockstep co-simulate against Spike.

Every STM32 tutorial online is HAL + CubeIDE clicking. This is the OPPOSITE — `arm-none-eabi-gcc` + Makefile + writing to `GPIOA->ODR` directly. The "no one teaches this" skill.

Configure Nav2 with AMCL, costmaps, and behavior trees on TurtleBot3 in Gazebo — the same stack production warehouse robots run.

Build a CMOS inverter in a free browser circuit simulator and plot its voltage transfer characteristic (VTC) to see the transistor-level behavior behind a logic gate.

Bootloader = most resumes don't have it. Real EV/automotive companies need OTA. Direct path to Bosch, Continental, Mahindra Electric roles.

Build a competition-grade sumo bot with edge detection, opponent IR detection, and aggressive motor control for college fests.

Drive a real DC motor via H-bridge using PWM generated on a Tang Nano 9K FPGA.

Tiny scope, USB device that's actually useful, you'll keep using it daily.

Run slam_toolbox in Gazebo with TurtleBot3 — same SLAM theory as physical RPLidar, zero cost, zero shipping.

Build AXI4-Lite master + slave and verify with cocotb constrained-random tests.

Knowledge transfers to USB MSC, MIDI, HID — all the same descriptor pattern.

Build a scaled-down 4-servo mini quadruped that crawls and body-sways — stepping stone to a 12-servo Boston Dynamics ambition.

Design Mealy and Moore FSM traffic light controllers and compare encodings.

EVs are huge in India. Ola, Ather, Hero, Bajaj, Mahindra all hiring motor control. FOC is the modern standard, not 6-step.

Build a phone-controlled tank robot with ESP32 Bluetooth — first impressive build that scales to vision later.

Drive a Verilator-simulated UART through a Linux PTY so minicom can echo through it.

Music + electronics combo rare on resumes. Send to FL Studio/Logic = unique demo.

Build a 3-DOF robotic arm with vision-based pick-and-place — visible problem-solving and step toward industrial robotics.

Parameterized radix-2 FFT verified against NumPy golden model with SNR thresholds.

"I work on EV stuff" claim that immediately differentiates. Show video of you sniffing dad's bike → instant interview material.

Run YOLOv5n on a laptop with ESP32-CAM streaming MJPEG — same architecture used by many startup prototypes, no Jetson budget needed.

Build a UART TX/RX with 16x oversampling and self-checking loopback testbench.

ML on microcontroller without internet. Super hot topic. Quote on resume = "trained gesture recognition model running 100% on-device in <100KB RAM."

Build a 2-axis ball-balancing platform that bridges control theory and hardware — a mesmerizing portfolio video piece.

Capture PS/2 scan codes on Tang Nano 9K and display typed characters on a 7-seg.

Visual + audio + embedded. Looks great on Instagram → drives traffic.

Implement differential-drive odometry with quadrature encoders on STM32 — the unsexy but critical robotics primitive recruiters ask about.

Build a full UVM env (driver, monitor, scoreboard, coverage) and apply it to a UART.

Real-time orientation tracking is in every drone, AR/VR, robot. Bridges embedded + signals.

Implement 2D SLAM from scratch (ICP, scan matching, occupancy grid) on KITTI and Cartographer public bag files — top-tier portfolio for robotics research.

Parameterized ALU with flags, randomized self-checking testbench against a golden model.

Anyone can use FreeRTOS. Few can write one. Recruiter sees this → "this person actually understands RTOS."

Build a vision-based object-following robot using ESP32-CAM streaming MJPEG to a laptop running OpenCV — half the cost of a Pi build.

Build VGA Pong on Tang Nano 9K, or a Verilator-based per-frame PNG-dump version.

Wave it, see floating message. Pure dopamine. Teaches real timing without expensive hardware.

Tune a quadcopter PID for stable hover in ArduPilot SITL / Webots — sim-based learning before risking a ₹6K airframe.

Build a full SoC with PicoRV32, AXI peripherals, and a UART bootloader using LiteX + Verilator.

Reflows your own PCBs (saves money on outsourced assembly). Visible deliverable, makes a YouTube short.

Run autonomous waypoint missions in ArduPilot SITL via DroneKit-Python — same MAVLink stack used by India's drone industry.

Multi-state vending machine FSM that handles coins, products, and change return.

USB MSC is everywhere (USB drives, embedded loggers, OTA). Few students write this from scratch.

Build a line follower with real PID control (P+I+D), with logged data and tuning plots — beats 90% of resume P-only builds.

BRAM-backed bitmap frame buffer driven onto VGA on Tang Nano 9K, or Verilator+PNG.

Blink an LED by writing GPIO/RCC registers directly, using only the reference manual — no HAL, no CubeIDE. The capstone that proves you understand C foundations + MMIO.

Coverage-driven testbench: drive a DUT to code + functional coverage closure.

Take a small firmware module and wrap it in host-side Unity tests, run cppcheck + a MISRA-style lint, and wire it all into CI that runs on every push.

SPI master controller verified against a mock LCD slave across all 4 CPOL/CPHA modes.

Bring an SBC up to a Linux prompt over a serial console, then cross-compile a small C app on your laptop that reads a sensor on the board. The Embedded Linux entry capstone.

Add SVA assertions + assertion coverage to a protocol interface (UART/AXI).

Build a bare-metal firmware from the command line with arm-none-eabi-gcc, a hand-written Makefile and linker script, then flash it — no IDE involved.

Verification plan + regression suite for an IP block, driven to coverage closure.

Write a loadable Linux kernel module exposing a sensor via /dev with a char-device interface, and add the device-tree node that binds it. The driver capstone.

Build a 4-bit ripple-carry adder by chaining full adders, add a magnitude comparator, and verify both with a self-checking testbench against a golden model.

Take a given schematic, build it on a breadboard with a regulator and a sensor, and verify every node with a multimeter. Bridges paper to working hardware.

Hand-solve a set of timing problems — critical path, slack, and maximum frequency — for a small pipelined datapath, then sanity-check against a tool.

Solder a small regulated supply on perfboard, verify the rail on an oscilloscope, then capture a live I2C/SPI bus on a logic analyzer. The bench-skills capstone.

Stand up a real firmware repo: Git history, a CMake build with a toolchain file, and two build targets from one source tree. Software-only, no hardware needed.

4-bit binary counter with FSM-controlled display, built gate-by-gate in a simulator.

4-bit ALU + register file built gate-by-gate in a simulator.