Computer engineering student · Georgia Tech

Anuj
Kakkad

I build embedded software and firmware at the boundary between hardware and software, where a physical signal becomes data, a system makes a decision, and careful engineering turns an idea into something dependable.

Focus
Firmware & drivers
Next
Summer 2027 internship
Based
Atlanta, Georgia
Charcoal line drawing of a disassembled mechanical pencil
Ideas begin as marks on paper.

A / ABOUT ME

Engineer, maker, and careful observer

The person behind the projects

I am a computer engineering student at the Georgia Institute of Technology who enjoys understanding systems all the way from their physical inputs to the software that controls them.

That interest has taken me through embedded software, firmware, device drivers, hardware test automation, and computer vision. In each setting, I have been drawn to the same kind of question: how do you make a complex technical system observable, testable, and trustworthy? I like work that requires both low-level attention and a wider systems view—reading a datasheet, tracing a timing issue, designing an interface, and then stepping back to ask whether the whole product behaves the way a person expects.

My experiences have also shown me that good engineering is collaborative. A reliable solution is not only correct code or a clean circuit; it is also clear documentation, thoughtful abstraction, reproducible testing, and communication that helps a team make decisions. I have learned to value the moments when an experiment disproves an assumption, because those moments turn uncertainty into useful evidence.

Outside of engineering, chess and charcoal drawing shape the way I think. Chess trains me to examine consequences before acting, while drawing makes me slow down and notice proportion, texture, and detail. Both practices reward iteration. They remind me that strong technical work is rarely produced in one pass; it develops through observation, revision, and a willingness to look again.

B / RÉSUMÉ & EXPERIENCE

Experience

Charcoal drawing of a test instrument connected to a laptop

Intuitive

Software Engineering Intern

Developed a custom C driver for a high-voltage insulation tester using SCPI-over-serial with 1 kHz real-time monitoring. I implemented a mutex-synchronized background thread and 8,192-sample circular buffer, reduced mutex hold time to sub-microsecond duration, and created platform-agnostic thread and mutex abstractions for Windows and Linux. Direct serial communication reduced query latency by 45%, from 5.1 ms to 2.8 ms, compared with the vendor IVI driver using NI-VISA.

CSCPIWin32POSIX
Charcoal sketch of a compact circuit-board test fixture

Moderna

Technical Development Co-op

Developed C#/.NET drivers for an Advantech USB-5860 digital I/O controller with edge detection and debouncing. I built a state-machine test automation system with more than fifteen states, processing 300 tests per day across six stations, and implemented a simulated hardware abstraction layer that reduced hardware-dependent testing cycles by 50%. The system published measurements to Snowflake through RESTful APIs, while Jenkins automated builds and installer generation.

C#.NETJenkinsSnowflake
Charcoal sketch of a microscope and microfluidic slide

Sulchek BIOMEMS & Biomechanics Lab · Georgia Tech

Undergraduate Researcher

Built and trained a convolutional neural network in Python to detect cell clogging in microfluidic devices from microscopy imagery, achieving 97% accuracy on a 3,000-image dataset. I also implemented the image-preprocessing pipeline, including data augmentation and a train-validation split.

PythonTensorFlowComputer vision

C / CAREER GOALS

From here to there

A roadmap designed to evolve

My near-term goal is to get an embedded software or firmware internship for Summer 2027. Long term, I want to design reliable embedded platforms where low-level software, device interfaces, and hardware constraints are considered together.

I am especially interested in roles that sit between hardware and application software: understanding a device’s electrical and timing requirements, building the driver or firmware that exposes its capability, and creating tests that make the full system dependable. I am using coursework, project work, research, and internships as structured experiments that reveal which problems and team environments bring out my best work.

  1. 01

    Now · Build depth

    Strengthen the fundamentals

    Deepen my understanding of data structures, digital design, object-oriented programming, operating systems, and embedded development. Continue practicing C/C++, Python, Bash, and low-level debugging while documenting what I learn.

  2. 02

    Next · Connect disciplines

    Ship complete systems

    Build projects that combine sensing, real-time software, algorithms, and hardware-aware optimization. Treat testing, measurement, and communication as design requirements rather than afterthoughts.

  3. 03

    College · Learn in context

    Seek high-feedback experiences

    Pursue internships, research, and engineering teams where I can learn from experienced designers, contribute to real deliverables, and see how technical tradeoffs change under schedule, safety, and product constraints.

  4. 04

    Long term · Own the interface

    Design trustworthy embedded platforms

    Grow into an engineer who can move between device behavior, firmware, system integration, and validation, helping teams build efficient products whose behavior can be explained, tested, and trusted.

D / DISCOVERY PROJECT FEATURE

Chess Specs

Embedded computer vision chess assistant

Charcoal concept drawing of smart glasses with a camera connected to an embedded board
Original project concept illustration · camera → board → move

Chess Specs explores a simple question with a difficult engineering answer: can a wearable embedded system watch a physical chessboard, understand the position, and recommend a move without sending the problem to the cloud?

Platform
ESP32-S3
Software
C / C++, ESP-IDF, FreeRTOS
Input
640 × 480 camera frames
Methods
Vision, state tracking, minimax
Chess Specs system architecture Camera frames flow through square change detection and board-state reconstruction into a chess search engine, which returns a recommended move to the user interface. 01 / SEECamera 02 / NOTICEChanges 03 / THINKSearch 04 / RESPONDMove
System architecture diagram created for this project feature.

01

The problem

Most digital chess tools start with a position that is already represented as data. Chess Specs starts with an ordinary physical board. A wearable camera must identify changed squares, maintain the game state, and recommend a move using embedded hardware. Lighting, camera angle, hand movement, and similar-looking pieces can create noise, while the software must preserve move order and reject stale results. The central challenge is separating perception, game state, search, and concurrency into responsive, testable components.

02

The process

I organized the system around four stages: see, understand, think, and coordinate. The camera captures 640 × 480 frames on an ESP32-S3. Because the board geometry is known, the software can compare individual square regions over time instead of solving a completely unconstrained vision problem. Starting from the standard position also lets chess rules help translate visual changes into legal moves.

The search stage uses minimax, alpha-beta pruning, iterative deepening, and material and positional evaluation. Iterative deepening produces a quick result first and improves it while time remains. FreeRTOS tasks and queues coordinate vision, search, and the interface. Each board position receives a version so a result is applied only when it matches the current state.

03

The outcome

The result is an end-to-end architecture for observing a physical board, reconstructing moves, and generating an on-device recommendation. Clear boundaries between perception, state tracking, search, and coordination make errors easier to trace. The project also shows the tradeoff of edge computing: lower latency, greater privacy, and offline operation in exchange for tighter memory and processing limits.

04

Reflection & next steps

This work strengthened my interest in hardware/software co-design because camera resolution, state representation, and search strategy all affected system behavior. It also showed me that interfaces and synchronization are central design decisions. The next iteration will test varied lighting and viewing angles, measure end-to-end latency, and build a repeatable move-detection dataset. Confidence scoring will help the system recover when an observed move is ambiguous.

E / TOOLKIT

What I work with

Programming

C, C++, C#, Java, Python, Bash

Platforms

Embedded Linux, FreeRTOS, ESP-IDF, Windows, Linux

Hardware

ESP32-S3, digital I/O controllers, I²C, SPI, UART

Software

CMake, GDB, Git, .NET, TensorFlow/TFLite, Jenkins, Snowflake

Communication

Design proposals, technical reports, presentations

Coursework

Data structures and algorithms, digital design logic, object-oriented programming

F / CONTACT

Let’s build something thoughtful.

I am seeking an embedded software or firmware internship for Summer 2027 and welcome conversations about device drivers, real-time systems, hardware-software integration, and embedded computer vision.