Software Development Projects in DelhiSoftware Development Projects in DelhiBuilt a virtual try-on application that lets users try on garments over WhatsApp. A user sends a photo through WhatsApp, and the app returns a realistic image of them wearing the selected garment, no app download or website visit required.
Designed and built the system end-to-end, from the WhatsApp messaging integration through to the try-on generation pipeline, as a self-contained product demonstrating conversational commerce for fashion/retail use cases.
Key Challenges:
- Frictionless UX over a messaging app: WhatsApp isn't built for structured app interactions, so the flow had to feel natural through simple image and text messages, not clunky commands.
- Reliable image handling: Incoming photos vary wildly in quality, lighting, and pose, and had to be received, processed, and matched with garment images reliably.
- Fast turnaround: Users expect a near-instant reply on a messaging app, so the backend had to handle image processing and model inference without long delays.
- Stitching third-party services together: Twilio's WhatsApp API and Gradio's try-on model weren't built to talk to each other, so the app had to bridge them cleanly.
Approach:
WhatsApp integration via Twilio
-Set up Twilio's WhatsApp API to receive incoming user images and send outgoing try-on results, handling the messaging layer end-to-end.
Flask backend as the orchestration layer
-Built a Flask application to receive Twilio webhooks, manage the request flow, and coordinate between incoming user images and the try-on model.
Virtual try-on generation with Gradio
- Integrated Gradio's virtual try-on model to generate the final garment-on-user image, returning a realistic composite result.
End-to-end flow design
- Connected the pieces so a user's WhatsApp message triggers the full pipeline automatically: receive image → process → generate try-on → send result back, all within a single conversation.
Results & Impact
- A working conversational shopping experience built entirely on a messaging app users already have open every day.
- Zero-download, zero-signup try-on flow — removes the biggest friction point in getting users to try a new AI-powered feature.
- A reusable integration pattern connecting Twilio, Flask, and a generative vision model, applicable to other WhatsApp-based commerce or personalization tools.
Provided Services & Solutions
📌 Conversational App Development
📌 WhatsApp API Integration (Twilio)
📌 Backend Development (Flask)
📌 Generative AI Integration (Gradio virtual try-on model)
📌 Third-Party API Orchestration
Tech Stack: Python · Flask · Twilio WhatsApp API · Gradio
If you want an AI-powered experience built directly into a channel your customers already use, like WhatsApp, let's talk. Restaurant POS & Billing Management System
Designed and developed a complete Restaurant POS & Billing Management System to streamline restaurant order management, billing, kitchen operations, inventory, and delivery workflows.
The system provides a fast and intuitive interface for managing dine-in, takeaway, and delivery orders, with category-based menu browsing and real-time order processing.
Key Features:
🍽️ Restaurant POS & Place Order
🧾 Automated restaurant billing
🚚 Dine-in, Takeaway & Delivery management
👨🍳 Kitchen Display System (KDS)
📦 Inventory & stock management
📊 Restaurant reports & analytics
💰 GST & tax calculation
🏪 Restaurant entries & master management
📱 Delivery customer & delivery-boy management
🧮 Discounts, service charges, GST & packing charges
🔐 Admin & role-based management
⚡ Fast, responsive POS interface
Hit a classic Django trap this week and figured it's worth sharing since so many people are running into it now.
I was adding an LLM feature to a Django app. The AI call takes a few seconds, so naturally I made the view async so it doesn't block a worker while waiting. Wrote the async view, called the ORM like I always do, and boom:
SynchronousOnlyOperation: You cannot call this from an async context.
Turns out Django's ORM can't just be called normally inside async code. The classic sync API isn't safe in an event loop, so Django protects it and throws this error instead.
The fix is simpler than most people think. Since Django 4.1 the ORM has async versions of everything, same names with an "a" prefix. So objects.get() becomes await objects.aget(), create() becomes acreate(), save() becomes asave(). For loops over querysets, async for works directly. And for old sync code or third party libraries you can't change, wrap them with sync_to_async().
Why this matters right now: everyone is bolting AI features onto Django apps, and LLM calls are exactly the slow I/O that async is made for. Which means a lot of devs who never touched async Django are suddenly hitting this error for the first time.
One honest caveat: transactions still don't fully work in async mode, so if you need atomic blocks, keep that path sync and wrap it.
Anyone else made the jump to async views yet, or still happily on WSGI? Jarvis CLI is a Python-based voice assistant for Windows that enables hands-free desktop interaction through voice commands and an animated graphical interface. The assistant listens for a wake word, interprets spoken requests, and performs practical actions such as launching local applications, opening websites, searching Google or YouTube, playing media, retrieving the current time, and handling basic system commands.
The project uses a modular architecture that separates speech processing, text-to-speech, command routing, desktop actions, and the GUI layer. It includes an animated orb interface that visually represents assistant states such as idle, listening, speaking, and code-generation activity. The voice and conversational pipeline was further explored with Google Gemini integration for transcription and AI-generated responses, while the project also contains local speech-recognition work based on Vosk.
I designed and developed the assistant’s voice-command workflow, desktop automation capabilities, modular Python architecture, animated GUI, speech-processing integration, command normalization logic, and Gemini-powered conversational enhancements. The project demonstrates practical work in voice interfaces, AI assistant design, desktop automation, and human-friendly interaction flows. 
