DEV Community: Koushik Raghavan

From Bugs to Better: Improving My Project with Sentry

Koushik Raghavan — Thu, 20 Aug 2026 16:21:31 +0000

This is a submission for DEV's Summer Bug Smash: Smash Stories powered by Sentry.

Fixing Critical Bugs and Improving Reliability with Sentry

Koushik Raghavan — Thu, 20 Aug 2026 16:01:03 +0000

This is a submission for DEV's Summer Bug Smash: Clear the Lineup powered by Sentry.

Project Overview

MovieSync is a real-time cinema venue dashboard designed to help cinema teams display and manage intermission information efficiently.

The application provides a simple dashboard for managing movie and venue information in real time. It was built with React, Vite, and Vanilla CSS, containerized using Docker, and deployed on Google Cloud Run with Nginx serving the production frontend.

Bug Fix or Performance Improvement

While developing and deploying MovieSync, I encountered issues related to application reliability, error handling, and production deployment.

The main goal was to identify the root causes of these problems, fix them properly, and make the application more reliable in a production environment.

I focused on improving error handling, resolving application issues, and ensuring that the containerized application started correctly and served traffic reliably on the required Cloud Run port.

Code

GitHub Repository: https://github.com/kvk1999/moviesync2.0

My Improvements

I first reproduced the issues and investigated the application behavior to identify their root causes.

I then made the necessary code and configuration changes to improve the application's reliability.

The improvements included:

Fixed application errors identified during development.
Improved error handling and debugging.
Verified frontend behavior after making the changes.
Improved production deployment configuration.
Used Docker multi-stage builds to create a production-ready application.
Configured Nginx to serve the React SPA correctly.
Ensured the application listens on the port required by Cloud Run.
Tested the application after deployment to verify that the fixes worked correctly.

These changes made MovieSync more stable and easier to monitor and maintain.

Best Use of Sentry

I integrated Sentry into MovieSync to improve application observability and make it easier to identify and investigate errors.

I used Sentry's Error Monitoring to capture application errors and inspect the relevant stack traces and context.

Sentry helped me:

Detect errors that were not always obvious during local development.
Identify where failures were occurring.
Investigate errors using the available debugging information.
Verify the application's behavior after implementing fixes.
Improve the overall reliability of the application.

Instead of relying only on manual testing and console logs, Sentry provided a centralized way to monitor application errors and investigate issues.

Best Use of Google AI

Gemini-powered Cinema Assistant — staff can ask questions such as “Which movies have an intermission in the next hour?” and Gemini uses MovieSync's available data to provide a useful answer.

Namma Kadai Voice Assistant

Koushik Raghavan — Sat, 15 Aug 2026 16:27:49 +0000

Building Namma Kadai: A Voice AI Assistant for Indian Local Commerce

Introduction to the Agent

Meet Namma Kadai (Our Shop), an intelligent, multilingual voice assistant designed specifically for Indian local commerce, street vendors (such as PM SVANidhi beneficiaries), self-help groups (SHGs), and micro-entrepreneurs.

The Problem: Many local vendors, artisans, and small shop owners face digital friction when managing online ONDC catalogues, tracking orders, navigating microloan schemes, or checking market logistics due to complex UI interfaces and language barriers.
The Track: Indian Local Commerce & Grassroots Empowerment.
Who It Is For: Street vendors, handicraft artisans, small retail shop owners, and local buyers.
Why Voice Matters: Voice eliminates the literacy and digital hurdles of traditional text-heavy apps. Vendors can speak naturally in their preferred language while managing inventory, checking real-time weather for outdoor market setups, or looking up financial support schemes hands-free while running their shops.

Important Features Built (The 10-Day Journey)

The project brings together a comprehensive suite of tools and agentic workflows tailored for grassroots commerce:

Core Voice AI Pipeline & Architecture: Established the foundation using LiveKit, Deepgram for multi-language speech-to-text (STT), Murf AI for text-to-speech (TTS), and Google Gemini as the core language model.
Persistent Database Memory: Configured an SQLite backend to manage returning caller profiles, language preferences, past order history, and automated call-outcome analytics.
Dynamic Multilingual Processing: Implemented real-time language detection and voice switching to seamlessly navigate English, Tamil, Tanglish, and Hindi.
Live Weather Integration: Integrated the Open-Meteo API to give local vendors real-time temperature, wind, and rain conditions for market setups and delivery logistics.
Specialized Security & Handoffs: Built a dedicated Cyber Safety & Fraud Prevention Specialist agent for instant handoffs during cybercrime or scam reports, alongside compliant human-help escalation workflows.
Linphone VoIP Integration: Configured open-source SIP client and softphone connectivity via Liblinphone to route traditional telephony and audio streams cleanly into the agent infrastructure.
Digital Storefront & Cataloguing: Developed ONDC-aligned digital catalogue management to help local artisans and MSMEs structure product inventory and display items seamlessly.
Microloans & Financial Schemes: Integrated dedicated conversational flows and guidance for accessing government support programs like PM SVANidhi, PM Vishwakarma, Udyam Registration, and MUDRA loans.
Outbound Workflows: Implemented automated outbound calling capabilities for proactive vendor coordination, delivery confirmations, and market updates.
Polish & Feedback Collection: Finalized strict turn-detection controls, VAD tuning, and a graceful sign-off feedback collection system to ensure an intuitive user experience.

Overcoming Development Challenges

One of the trickiest hurdles faced during development was managing dynamic language detection and real-time TTS voice switching without clipping user interruptions or breaking the conversation flow.

The Problem: When callers seamlessly mixed Tamil keywords with English (Tanglish), the default text-to-speech model occasionally mispronounced words or defaulted back to a rigid accent, making the interaction feel robotic.
What Was Tried: Initially, static language configurations were tested, but they failed during code-switched dialogues. Next, custom keyword sets and Unicode character range checks (Baloo Thambi 2 script tracking) were added to the transcription event listener.
The Solution: By catching user transcripts mid-stream via LiveKit's user_input_transcribed event, the agent evaluates incoming text against a Tamil/Tanglish keyword dictionary and dynamically invokes session.tts.update_options(voice="ta-IN-anisha") on the fly. This resulted in smooth, natural code-switching audio responses.

Guide: How to Build Your Own Voice Agent

To build and run a similar real-time voice agent, you need four foundational components:

Speech-to-Text (STT): Transcribes audio streams into text in real time (e.g., Deepgram Nova-3).
Large Language Model (LLM): Handles reasoning, tool-calling, and conversational logic (e.g., Google Gemini 2.5/3.5 Flash).
Text-to-Speech (TTS): Converts the LLM text output back into natural spoken voice (e.g., Murf AI Falcon).
Real-Time Transport & Orchestration: Manages audio tracks, WebRTC connections, and VAD (Voice Activity Detection) using LiveKit and Silero VAD.

Setup Instructions

Clone and Install Dependencies:

git clone https://github.com/kvk1999/murf-livekit-starter.git
cd murf-livekit-starter
pip install -r requirements.txt

Configure Environment Variables: Create a .env.local file in your root directory. Never commit this file or expose your API keys publicly.

LIVEKIT_URL=wss://voicebharat-ak7frth8.livekit.cloud
LIVEKIT_API_KEY=API8e2v252xYx47
LIVEKIT_API_SECRET=1yHXG66xvIQofEUUccsKbv67fXCMHlsBzllZ2aeYNnFA
MURF_API_KEY=ap2_e5b802b4-231e-4d24-b7f9-150fb7fdd204
DEEPGRAM_API_KEY=db3ac822d4044ea4f737047a9f9114975294fea8
GOOGLE_API_KEY=AQ.Ab8RN6KJojfAGacYzk5rqvfnCHOeMjkhzvlxJyqq8c8ZeOLOpA

# Linphone & SIP Trunking (Task 6)
LINPHONE_SIP_URI=sip:koushik9900@sip.linphone.org
SIP_OUTBOUND_HOST=sip.linphone.org
LIVEKIT_SIP_TRUNK_ID=ST_fxqmyQZCSwkB
LIVEKIT_SIP_OUTBOUND_TRUNK_ID=ST_fxqmyQZCSwkB
SIP_TRUNK_ID=ST_fxqmyQZCSwkB
OTEL_SDK_DISABLED=true

Run the Agent:

python agent.py dev

Test the Conversation: Connect via the LiveKit web sandbox or configure a Linphone softphone client using your SIP credentials (sip:koushik9900@sip.linphone.org) to dial into your agent room and test live voice interactions.

Building ElectGuide in Public: Simplifying the Election Process for Everyone

Koushik Raghavan — Wed, 22 Apr 2026 13:33:00 +0000

Building ElectGuide in Public (with Antigravity) 🗳️🚀

We’ve all faced this…
When elections come around, many people aren’t sure about the process — where to start, what steps to follow, or what timelines matter. It can feel confusing and overwhelming.

That’s where the idea of ElectGuide came from.

The Problem

Election information is often scattered, complex, or hard to understand.
People want to participate, but the lack of clarity becomes a barrier.

The Idea

I built ElectGuide, an interactive assistant that simplifies the election journey.
It helps users understand the process step-by-step — from eligibility to voting day — in a clear and easy way.

No confusion. Just clarity.

Tech Stack

React + Vite for a fast frontend
Clean UI with simple, accessible design
Docker for containerization
Google Cloud Run for serverless deployment
Antigravity to accelerate development

How I Built It

I focused on simplicity and usability.
The goal was to break down complex election information into small, easy-to-follow steps.

The assistant guides users interactively, making it feel less like reading instructions and more like a conversation.

Deployment

Dockerized the app and deployed it on Google Cloud Run for scalability and reliability.

Where Antigravity Helped

Antigravity made a big impact by:

Speeding up development
Helping structure the assistant logic
Reducing friction in building and deploying

It helped turn an idea into a working product much faster.

Key Features

Interactive election guidance
Step-by-step process explanation
Clean and responsive UI
Accessible and beginner-friendly
Deployed and live

What’s Next

Add region-specific election data
Real-time updates and reminders
Multilingual support
Mobile-friendly PWA version

Final Thought

Building ElectGuide made me realize how impactful simple clarity can be.
Sometimes, making information easier to understand is just as powerful as building something complex.

MovieSync: Redefining Intermissions with Live Crowd Data

Koushik Raghavan — Mon, 20 Apr 2026 15:52:40 +0000

Building MovieSync in Public (with Antigravity) 🎬🚀

We’ve all faced this…
You step out during a movie break, thinking you’ll grab snacks or use the washroom quickly — but end up stuck in long queues. Short break, long wait.

That’s where the idea of MovieSync came from.

The Problem

Intermissions are limited, but there’s zero visibility on crowd levels. You just guess… and sometimes regret it.

The Idea

I built MovieSync, a real-time dashboard that shows how crowded different areas are inside a venue.
Simple color signals help you decide instantly:

🟢 Low crowd
🟠 Medium
🔴 High congestion

No guesswork. Just smarter decisions.

Tech Stack

React + Vite for a fast, lightweight frontend
Vanilla CSS (no heavy UI libraries)
Docker (multi-stage build)
Nginx for serving the app
Google Cloud Run for serverless deployment
Antigravity to speed up development & workflow

How I Built It

I focused on keeping things simple and clean.
Instead of using UI frameworks, I designed everything from scratch using glassmorphism styles, smooth transitions, and subtle animations.

Since I didn’t have real sensors, I created a simulation that mimics real-time data (like WebSockets). The dashboard updates dynamically to reflect crowd density.

Deployment

Used Docker with a multi-stage build:

Node → build optimized assets
Nginx → serve the app on port 8080

Deployed on Google Cloud Run for automatic scaling.

Where Antigravity Helped

Antigravity made a big difference by:

Speeding up initial setup
Making UI iterations faster
Simplifying deployment flow
Reducing overall complexity

It helped me move faster from idea → working product.

Key Features

Real-time crowd dashboard
Lightweight and responsive UI
Dockerized production build
Serverless deployment
Built in public

What’s Next

Real IoT integration
WebSocket backend
Predictive crowd insights
Mobile PWA version
Multi-theatre support

Final Thought

This project showed me how quickly you can build something useful using the right tools. Building in public also made the journey more real and accountable.

What are you building right now? 🚀