Smart Gym: making home workouts safer with sensor gloves

The problem

Each year, roughly 1.5 million Canadians over the age of 12 pick up a sport- or exercise-related injury serious enough to limit their day-to-day life. When the pandemic hit, home workouts exploded — eBay reported a 1980% jump in dumbbell sales and fitness-app downloads grew 46% in a single quarter — but the one thing that used to keep people safe quietly disappeared. The trainer watching your form was gone.

Fitness apps could tell you what to do. None of them could tell you whether you were doing it safely. That gap was the whole opportunity behind Smart Gym, my electrical and computer engineering capstone at the University of Waterloo.

Smart Gym as a consumer product — a daily score, workout history, an exercise library, and a profile, not a raw engineering demo.

What we built

I pushed our team to treat Smart Gym as a real consumer fitness product rather than a lab prototype. That meant three pieces had to work together:

Smart gloves that captured motion while you lifted
A backend that recognized the exercise and graded your form
A mobile app that turned all of it into a score and feedback you’d actually want to open

A pressure sensor in the palm told the system when a set was underway, the gloves streamed motion data, the backend classified the movement and scored technique, and the app surfaced your score, history, and where your form was breaking down.

The team was Ganan Sivagnanenthirarajah, Gokul Unnikrishnan, Shahil Patel, Stefan Caloian, Varan Narendran, and Vignesh Ravindran.

Designing the app

I owned the product direction — what the system should feel like, not just what it should do. The app centered on a few screens: a dashboard with your recent score and friends, a workout history calendar, an explore view for discovering exercises, and a profile for records, goals, and glove management.

We started on paper. Rough sketches of what data we could capture and what feedback would actually motivate someone became wireframes, then high-fidelity screens in Adobe XD and Figma, then a working interface in React Native.

Design progression from hand sketches to wireframes to finished app screens — From napkin sketches to shipped screens. Leading this progression is where I first found the role I play now.

Inside the gloves

A pressure sensor on the palm did something deceptively important: it told the system when you were actually lifting. Apply force — grip the bar — and the sensor’s resistance drops, the glove wakes into an active tracking state, and motion capture begins. We wired it as a simple voltage divider off a 3.3V line into the microcontroller’s ADC, sized so the resistor wouldn’t wash out the sensor’s working range.

Three photos of the Smart Gym glove prototype with sensors and an Arduino mounted on the back of the hand, gripping a barbell — The working prototype: motion and pressure sensors plus an Arduino, mounted on the back of each glove.

The hard part was getting two independent gloves to agree on time. We weighed Bluetooth, GPS, and a physical trigger, but each one added weight, latency, or constraints — an Arduino can’t even run WiFi and Bluetooth at once. We landed on a lightweight UDP-based sync over the gloves’ shared WiFi: low latency, simple to implement, and portable, with the two clocks staying within microseconds of each other because both devices sat on the same network.

Pressure-sensor activation slide showing the sensor, breadboard wiring, and Arduino circuit schematic — Pressure-sensor activation: force on the palm wakes the glove into tracking, so the system only records during a set.

Recognizing exercises and scoring form

Turning raw sensor noise into “you’re doing this safely” was the core challenge. We compared a neural-network approach against something simpler: K-nearest neighbours to recognize the exercise, paired with benchmarked slope ranges to grade form — comparing the slopes of each glove’s accelerometer and gyroscope axes (Ax, Ay, Az, Gx, Gy, Gz, per glove) against a reference.

KNN won on pragmatics: far less training data and time, a single hyperparameter to tune, and — critically for wireless gloves — resilience to packet loss, because it judged the overall shape of a rep rather than every sample. The system recognized exercises like bench press, squats, bicep curls, and tricep extensions, and returned a per-hand form score that flagged movements signalling injury risk, like unwanted rotation on one side.

Slide comparing KNN versus neural networks for exercise recognition, with detection output for bench press, squats, bicep curls, and tricep extensions — We chose KNN plus benchmarked motion slopes over a neural network — simpler, cheaper to train, and robust to dropped packets.

Raw samples streamed into Firebase’s realtime database, the backend processed them into readable metrics, and the results landed in Firestore for the app to read: a workout score, a per-hand breakdown, and form notes.

Data flow from Firebase realtime database through form analysis into Cloud Firestore documents holding scores and form notes — Raw glove data in, readable workout insights out: Realtime Database → form analysis → Firestore.

The engineering tradeoffs

A capstone lives or dies on shipping something real by a deadline, so most decisions optimized for that:

React Native + Expo for the app, so one codebase covered iOS and Android instead of two — and matched the team’s existing skills.
Firebase for backend and data, which scored highest in our evaluation against AWS and GCP on cost and mobile/IoT fit, with a realtime database, Firestore, and auth out of the box.
NoSQL over SQL, because high-frequency sensor data needed fast writes, and we didn’t want a rigid schema silently dropping samples.

Recognition

Smart Gym came together as a true end-to-end prototype — gloves, backend, and app — and won Waterloo Engineering’s prize for Best Device for Physical Exercise, judged among roughly 70 final-year capstone projects.

What I took from it

Smart Gym was the first time I naturally stepped into the role I play today: turning a rough idea into a real product. I wasn’t thinking about the circuit, the algorithm, or the app in isolation. I was thinking about how the whole thing felt to the person wearing the gloves — the hardware had to be wearable, the data had to become useful feedback, and the app had to be simple enough to open mid-workout. That balance of product vision, design, engineering tradeoffs, and storytelling is still how I work.