Make a capsule. Write a message, add the sender and recipient details, then choose a future delivery date and time. You can also select an occasion, attach a photo, or add an optional 4-digit PIN.

Delivery and privacy. The website says each capsule stays private and unopened until its delivery date, then is sent automatically by email. It also says no one, including the site team, can read it before it is due.

After it arrives. The recipient can open the capsule, save it as a keepsake, or reply by sending a capsule of their own.

The Problem. People around me — family, neighbours, relatives in smaller towns — would either ignore symptoms for weeks or spend hours searching Google, only to come out more anxious and confused than before. They weren't looking for a diagnosis. They just wanted someone to help them make sense of what they were feeling and tell them whether it was serious enough to see a doctor.

Why I built it. I've watched family members dismiss symptoms they should have acted on, and panic over ones that were completely harmless — simply because they had no way to get a calm, informed second opinion without booking an appointment. I wanted to build something that felt less like a search engine and more like asking a knowledgeable friend — one who speaks plainly, doesn't overwhelm you with medical jargon, and knows when to say "go see a doctor today" versus "this sounds fine, monitor it."

How it works. Dr. Asati is powered by a large language model fine-tuned with health-focused prompting. Every response is deliberately kept conversational — no bullet-point walls of text, no cold clinical language. I spent a lot of time on the prompt design to make sure it never overstates certainty, never dismisses symptoms without reason, and always reminds users that it's a first step, not a final answer.

What it does for you. Describe your symptoms in plain language and Dr. Asati will help you understand what they might indicate, what questions to bring to your doctor, what warning signs to watch for, and whether something needs attention today or can wait. It won't replace a doctor — but it'll make sure you walk into that appointment informed instead of scared.

What I learned. Building in the health space forces you to think hard about responsibility. Every design choice — how confident the tone sounds, what words you use, when to escalate — carries real weight. It made me a more careful engineer.

The Problem. Every major messaging app today treats your phone number as the price of entry. WhatsApp, Telegram, Signal — all of them ask for it upfront. That's fine if you want a permanent contact. But sometimes you just want to have a quick, private conversation with someone without swapping personal details or creating an account that lives forever.

Why I built it. I kept running into situations — online communities, new acquaintances, collaborations — where I wanted to message someone without the friction of "add me on WhatsApp." I wanted a tool that was genuinely zero-friction: no sign-up, no download, no phone number. Just open a link and talk. So I built one.

How it works. Megmee uses Firebase Firestore for real-time message sync and implements end-to-end encryption so messages are encrypted on your device before they ever reach the server. The server never sees your plaintext. I built live presence indicators so you can see when someone is typing, and designed the UI to feel as clean and instant as a native app — despite running entirely in the browser.

What you get. Create a room, share the link, start chatting. End-to-end encrypted, real-time, no account required, no phone number, no install. Works on any device with a browser. When you're done, close the tab — no trace left.

What building it taught me. Megmee was the project where real-time architecture finally clicked for me. I had to think hard about data modelling for live sync, keeping Firestore costs near zero on the free tier, and how to design security rules that actually hold up. It taught me more about how the web works under the hood than any course ever could.

The Problem. Most people have something worth saying — they just struggle to say it well. The existing landscape gives you two bad options: tools like ChatGPT that write the whole thing for you (and it sounds like ChatGPT, not you), or grammar checkers that fix typos but leave your ideas untouched. There's almost nothing that sits in the middle — something that sharpens your thinking, helps you structure ideas, and makes your writing sound like the best version of you.

Why I'm building it. I noticed that the best writing advice — "cut this sentence," "this paragraph buries your main point," "this word is doing no work" — rarely comes from tools. It comes from good editors and thoughtful readers. Eranatis is my attempt to make that kind of feedback available to anyone, not just people with access to editors. I want it to feel like a collaborator, not a ghostwriter.

How I'm building it. The core challenge is preserving voice. I've spent significant time on the prompting layer — making sure Eranatis suggests and questions rather than overwrites. The interface is deliberately minimal: a clean editor where AI suggestions appear as options, not automatic replacements. You stay in control of every word.

What it will do for you. Whether you're writing a cold email, a college essay, a blog post, or a business proposal — Eranatis will help you move from a rough idea to a finished piece faster, flag where your argument loses momentum, suggest stronger word choices, and tighten your structure. The goal: your ideas, expressed better.

Where it's at. Eranatis is actively in development. The core writing experience is live — I'm currently working on deeper context awareness and personalisation features that adapt to your individual writing style over time.

The Problem. Medical bills in India are notoriously opaque. Hospitals routinely charge several times the fair rate for procedures, and most patients pay without question — either because they don't know what the fair price is, or because they don't feel empowered to push back. The information asymmetry is enormous: a well-connected patient or healthcare advocate knows exactly what to demand. Everyone else just pays.

Why I built it. This hit close to home. Watching family members get handed hospital bills with no way to verify whether the charges were legitimate — and no idea what recourse they had — made me angry. The data to fight these overcharges exists publicly (CGHS rates, state health scheme benchmarks) but it's buried in government PDFs that nobody knows about. I wanted to take that data, make it searchable, and give people the exact words to use when they dispute a bill.

How it works. I built a pricing database from CGHS (Central Government Health Scheme) rates and mapped them across city tiers, since costs in Mumbai are different from costs in a Tier-2 city. The audit engine uses fuzzy procedure matching — so "knee replacement" and "total knee arthroplasty" resolve to the same benchmark — and flags any line item that exceeds the fair-price threshold for your location. Gemini then takes the flagged items and generates a formal dispute letter and a phone script tailored to your specific bill, ready to send or read out.

What it does for you. Upload or paste your bill, select your city tier, and BillGuard will tell you which procedures were overcharged, by how much, and what the benchmark price is. Then it hands you a ready-to-send dispute letter and a phone script — so you can fight back immediately, with evidence, in language that hospitals take seriously.

What I learned. The hardest part wasn't the AI — it was the data. Building a reliable pricing database from inconsistent government PDFs, then writing a fuzzy matcher good enough to handle the chaos of real-world medical billing terminology, took far longer than expected. It taught me that for civic tech, the data layer is everything.

The Problem. Scam messages are getting frighteningly good. The days of obvious "Nigerian prince" emails are long gone — modern phishing copies real brand emails pixel-for-pixel, spoofs legitimate-looking domains, and uses psychological pressure ("your account will be suspended in 24 hours") to bypass your better judgment. Most people have no quick, private way to check a suspicious message before clicking a link or typing in a password.

Why I built it. Every existing tool I found either required you to create an account, upload your message to a server, or wait for a slow scan. None of that is acceptable when you're holding a message that might contain your bank credentials. I wanted something that runs entirely in your browser — instant, private, zero data leaving your device — that could give a plain-language verdict in seconds.

How it works. ScamSentry runs a layered heuristic analysis entirely on your device. It checks sender email addresses for lookalike domains (e.g. "paypa1.com" vs "paypal.com"), flags free email providers impersonating brands, scans message text for urgency patterns ("act now", "verify immediately"), threats, generic greetings, and explicit requests for passwords or OTPs. For links, it checks for raw IP addresses, missing HTTPS, redirect chains via shorteners, and domain age signals. Each signal is weighted and combined into a 0–100 trust score with a plain-language explanation of exactly what triggered it.

What it does for you. Paste a suspicious email, message, or link — or drag in a .txt, .eml, .msg, or .html file — and ScamSentry gives you a trust score, a risk verdict (Safe / Suspicious / Likely Scam), and a breakdown of every red flag it found. No account, no sign-up, no data ever sent anywhere. Works on any device with a browser.

What I learned. Building a heuristic engine is humbling. You quickly realise that clever scams will always slip through pattern-matching — which is why I was careful to frame ScamSentry as a "helpful first check," not a security guarantee. Getting the trust score calibrated so it doesn't cry wolf on legitimate emails — but still catches real threats — required a lot of tuning and real-world test cases. The UX lesson: when dealing with security tools, plain language and honest limitations build more trust than false confidence.

The Problem. Most people who want to eat healthier run into the same wall: calorie apps are tedious, nutrition labels are confusing, and generic meal plans don't fit real life. Healthy eating advice is everywhere — but personalised, actionable guidance that adapts to what you actually eat is almost nowhere.

Why I built it. I wanted to build something that removed the friction from tracking entirely. No manual calorie counting, no lookup tables, no meal plans that assume you cook every meal from scratch. NutriTrackk is designed to meet you where you are — tell it what you ate, and it handles the rest.

How it works. The app is powered by the Grok API, which handles natural-language food input — so you can say "a bowl of dal and two rotis" and it understands. It extracts nutritional data, tracks it against your daily goals, and surfaces trends over time so you can see where your diet is actually falling short, not just guess.

What it does for you. Log meals in plain language, see a real-time breakdown of calories, protein, carbs, and fat, and get personalised suggestions to hit your goals. The interface is clean and fast — built so that tracking takes seconds, not minutes, making it something you'll actually keep doing.

What I learned. Working with the Grok API pushed me to think carefully about how to handle ambiguous food descriptions without frustrating the user. The challenge isn't the happy path — it's what happens when someone logs "some snacks" or a regional dish the model hasn't seen often. Graceful degradation and smart clarifying prompts ended up being the most important UX decisions in the whole project.

What it is. CanGraphyFi is a small browser tool built around a simple idea: chart-making can begin with a quick sketch. Instead of starting with a form or a table, you get a paper-style canvas where you can draw the shape you have in mind.

How it works. The interface keeps the controls focused on the drawing itself. You can choose a plain, grid, dotted, or lined paper background, then use the pen, bar, circle, or line tools. The canvas supports both mouse and touch input, so the interaction also works on a phone or tablet.

The useful part. After sketching a baseline and the marks for a chart, you can convert the drawing into a chart and then return to the sketch when you want to keep working. Undo and clear actions make it easy to experiment without worrying about ruining the canvas.

Why I like the idea. This project is intentionally focused. It does not try to be a full analytics platform or pretend that a quick sketch replaces careful data work. It explores a more direct, visual way to start thinking about charts — draw first, then turn the idea into something more structured.

What it is. Roast My Code is a terminal-based code review tool with a deliberately fun interface. You give it a file or pipe code into it, and it checks the code for patterns that often lead to bugs, security risks, or harder-to-maintain code. The roast is only the presentation — each comment is connected to a real rule-based finding.

How to use it. The default output is Hinglish, with English and bilingual modes available through command-line flags. It can review a file path such as roast-my-code app.js, or read code from standard input, for example cat app.py | roast-my-code --en. It runs locally and does not need an API key or environment variable.

What it checks. The detectors cover JavaScript/TypeScript, Python, and common cross-language patterns. They look for things such as hardcoded secrets, loose equality, leftover console or print statements, eval or exec, innerHTML risks, empty error handlers, unhandled network calls, SQL built through string concatenation, unsafe property access, long functions, magic numbers, duplicate code, and TODO or FIXME leftovers.

The two releases. The package has been published in two npm releases, 1.0.0 and 1.0.1, while the GitHub repository keeps the project source and detector rules together. I am keeping both releases under one portfolio entry because they are versions of the same CLI rather than separate products.

An honest limitation. This is a regex and heuristic-based analyzer, not a full AST parser or a replacement for a senior code review. That means it can miss edge cases and may produce an occasional false positive. The useful part is its speed and accessibility: it gives developers a quick first pass, with the line number and a suggested fix, before they move on to deeper review.