Not a highlight reel — the actual problem, approach, stack, and the parts that broke first.
hardware · electronics
Building an Arduino Ultrasonic Radar
The problem: it's a classic beginner-electronics build for a reason — it's the
first project that actually connects hardware sensing to a live visual output, instead of just
blinking an LED or printing numbers to a serial monitor.
The approach: an HC-SR04 ultrasonic distance sensor sits on top of an SG90 servo
motor. The Arduino sweeps the servo back and forth across a 180° arc, and at each angle it fires
the ultrasonic sensor and times how long the echo takes to come back — that time converts directly
into a distance. Both the angle and the distance get sent over serial to a Processing sketch running
on the laptop, which draws them as a sweeping radar display: green sweep line, distance rings, and
a red blip exactly where something is within range.
Why it's a good project, not just a simple one: it forces you to handle timing in
two places at once — the servo's sweep speed and the ultrasonic sensor's echo timing both have to
stay in sync with what's being drawn on screen, or the radar display lags behind or jitters. Getting
the serial communication between the Arduino and the Processing sketch clean and reliable, at a
speed that actually keeps up with the sweep, is most of the real work.
The problem: taking notes during a live conversation means splitting attention between
listening and writing — usually losing part of both.
The approach: a credit-card-sized device that clips magnetically onto a phone, records
audio through studio-grade mics, and hands the recording off for transcription and summarization
— turning a conversation into structured notes, mind maps, and flashcards without anyone
touching a keyboard mid-conversation.
Design constraint: it had to be small enough to feel invisible. That ruled out a lot of
off-the-shelf mic modules and pushed toward a compact custom enclosure.
Status: targeting a 2026 launch — currently refining the hardware enclosure and the
summarization pipeline.
web app · social impact · built for Seth M.R. Jaipuria School
Building Jaipuria Podcast — an Anonymous Grievance Portal for My School
The problem: students often don't report real issues because complaint channels
aren't actually anonymous — a name or login tied to a submission is often enough to make someone
stay quiet. At a school the size of Seth M.R. Jaipuria, that means real problems go unheard simply
because reporting them feels risky.
The approach: I built and shipped Jaipuria Podcast — a portal with no login
requirement and no identifying metadata stored against a submission, using a tracking code system
instead of an account, so a student can check their own complaint's status without ever revealing
who they are. It also includes a status dashboard and a polls section, so it works as an ongoing
channel between students and the school rather than a one-off complaint box.
Design constraint: anonymity had to be real, not just a UI promise — that shaped
what got logged on the backend from day one, not bolted on after. If a system claims anonymity but
quietly keeps IP logs or account links, it isn't actually anonymous — so the backend was built around
that constraint from the first line of code, not retrofitted.
Status: live and in use at Seth M.R. Jaipuria School.
See it live →
web app · AI
Designing Gifté+'s Two Recommendation Modes
The problem: generic gift-recommendation sites ask five questions and return the same
list of mugs and candles for everyone.
The approach: two paths — a manual mode where the user has full control over
preferences (budget, interests, occasion), and an automatic mode that pulls in more signals,
including a face-detection path, to suggest better-fitting options with less manual input.
AI · tooling · autonomy
Building Midnight Signal — A Live AI Operating Interface
The problem: the best AI ideas are not just chat bubbles; they become systems. A serious interface needs live controls, persistent sessions, tool access, and a clear sense of operating context — something more than a wrapper around a single model call.
The approach: Midnight Signal is a truecolor, dark-mode AI control surface designed around an unrestricted local model stack. It streams responses in real time, exposes live model and sampling settings, supports theme switching, keeps session state across conversations, and includes a project radar scanner to surface the work environment. The system is built to feel like an operating layer, not just a chatbot.
Why it matters: the user isn't just asking for text — they're asking for a system that can read files, edit code, run shell commands, inspect git history, and move through a project in a controlled way. That means the interface needs both speed and safety: confirmation prompts, explicit permission flows, and the option to escalate into an aggressive "yolo" mode when the operator wants to go full speed.
The idea behind the project: unrestricted by design. This is the core idea behind Midnight Signal: it runs on an ablated base model, and the system prompts add no refusal language, no safety lecturing, and no filtering on top of it. Ask it anything — you get the model's own answer, not a wrapper's opinion of what you're allowed to ask. No leash, no filter, fully local.
Stack: local model runtime, custom front-end UI, tool-calling agent flow, persistent session engine, project state scanner, shell/file/git integration, and live configuration controls.