What it is

Hey Yaara is an AI voice companion built specifically for elderly users. It listens, it responds in a warm conversational tone, and it does not demand the user learn anything new. No app navigation, no menus, no notifications competing for attention. You open it, you speak, you're heard.

It runs as a Progressive Web App — installable on any phone or tablet, no app store, no download friction. The interface is deliberately spare: one button to start talking, one to stop. Everything else is voice.

Why I built it

India has roughly 140 million people over 60. A huge share of them live alone, or with family members who are out of the house most of the day. The loneliness problem is well documented; the technology gap is too. Most "senior-friendly" apps still assume you know how to navigate a smartphone.

I wanted to see what a tool would look like if it started from voice first, not screen first. Something my own family members could use without me having to teach them.

What's broken without it

• Loneliness without a conversational outlet. Family calls are precious but rationed. A voice companion is always available, never tired, never busy.
• App fatigue and interface anxiety. Buttons, menus, gestures, notifications — all of it is friction. Voice removes the entire learning curve.
• The "I don't want to be a burden" problem. Many elderly users hesitate to ask family for help with small things. A neutral AI removes that emotional cost.
• Cognitive engagement. Light conversational stimulation has measurable benefits on cognitive sharpness in later years.

The roadmap in my head

Multilingual support is the most obvious next move — Hindi-first, then regional. Voice cloning so a user's children can record a "voice they recognise". Family hand-off — moments where the AI says "let me get your daughter on the line for this one".

And a hardware companion — a dedicated, always-listening, single-purpose device that doesn't require holding a phone.

What it is

MusicGenAI is an AI-powered music generation app. You give it a prompt — a mood, a genre, a theme — and it composes a full track with vocals, generated lyrics, and verified output. The whole pipeline runs end-to-end on a stack I built: React/TypeScript frontend on Vite, Supabase for storage and auth, and a Python microservice handling the vocal synthesis.

It's not a wrapper around someone else's model. It's a real composition tool with its own orchestration layer.

Why I built it

The first wave of AI music tools (Suno, Udio, others) showed what's possible, but they're all closed boxes — you get an output and you don't see the seams. I wanted to understand the pipeline by building one myself: prompt parsing, melody generation, lyric generation, lyric verification (a step most tools skip), vocal synthesis, and final mixing.

Beyond curiosity, this was a real PM exercise too — for any AI music product to be a sustainable business, you need control over the failure modes. You can't operate at scale if you don't know why a track came out wrong. Building the pipeline taught me where the failure modes actually live.

What's broken without it

• Existing tools are black boxes. When the lyrics drift or the vocal sounds off, you can't debug it. MusicGenAI exposes the stages so you can fix them.
• Lyric hallucination. Most generators will happily produce nonsense. The verification step catches and rewrites bad lines before the vocal layer runs.
• Indie creators want control, not magic. Songwriters who use AI as a co-writer need to nudge each stage — pick the melody first, then iterate on lyrics, then choose a vocal. The pipeline supports that.
• Cost transparency. Running your own stack means you know what every track costs to generate.

How it's built

• Frontend — Vite + React + TypeScript + shadcn/ui + Tailwind. Fast, type-safe, no friction.
• Auth & storage — Supabase, with row-level security so users only see their own generations.
• Vocal pipeline — Python microservice (Dockerised, runs separately) that handles the heavier audio synthesis steps.
• Lyric verification — A standalone TypeScript step that round-trips lyrics through a validation pass before they hit the vocal layer.
• Deployment — Vercel for the frontend with auto-deploy on push; Python service runs on its own infrastructure.

What it is

AI TeleSuite is a real-time AI sales co-pilot. It transcribes a sales call as it happens, scores the pitch against quality criteria, and surfaces conversion suggestions live to the operator. Think of it as a quiet voice in the seller's ear, trained on what good looks like.

This is the consumer-facing companion to a product I built at Times Internet — same philosophy, smaller surface area, designed for individual sellers and tiny teams rather than enterprise sales floors.

Why I built it

At ET, the original telesuite was for our high-volume assisted-sales channel — dozens of agents, structured scripts, mature ops layer. It worked beautifully and made the difference in scaling Assisted Sales from ₹15L to ₹80L MRR.

But the same problem exists everywhere outside enterprise sales floors: a freelancer running calls all day, a founder doing demos, a small startup with three SDRs. They have no coaching layer. Every call is solo, every mistake invisible, every win unrepeatable. AI TeleSuite is what happens when you take the enterprise version and strip it down to one user.

What's broken without it

• Solo sellers have no quality feedback loop. Big sales orgs have call review meetings; freelancers have a hopeful inbox.
• Pitch consistency is invisible. Without recording and scoring, you don't know whether your fifth call of the day is as sharp as your first.
• Wins are unrepeatable. If you don't know which sentences moved the needle, you can't double down on them.
• Coaching at scale is expensive. A senior sales coach costs $200/hour. AI can do the first 80% for almost nothing.

The roadmap in my head

The next step is integrations — pull objection responses from your CRM, post-call summaries to your pipeline, and a coaching dashboard that surfaces patterns across a seller's last 50 calls. The vision is a quiet, persistent improvement engine that runs in the background while you sell.

What it is

LifeEngine is an AI-powered wellness planner. You tell it your goals — fitness, sleep, nutrition, stress, focus — and it builds a daily plan around them, adjusting as you log progress. It's behind a login because the version of wellness advice that actually works is personal, and personal data needs to live behind auth.

It's my own take on a personal health engine — a brand-agnostic, personalised wellness companion that works for anyone, not tied to any one publisher's product.

Why I built it

I shipped Times Health+ subscriptions at Times Internet — paid wellness content for Indian users. The product works, but it has the same problem every content product has: the content is one-size-fits-all, even when the user's goals aren't.

LifeEngine is my answer to that — a personalisation layer that takes the same wellness library and routes the right pieces to the right user on the right day. I built it as a side experiment to see whether the personalisation actually does the work I expected it to.

What's broken without it

• Generic wellness content underperforms. A "drink more water" tip means nothing if the user is actually struggling with sleep.
• No accountability loop. Most wellness apps tell you what to do but never check if you did it. The engine builds in light daily check-ins.
• Subscription churn for content products. If the content doesn't feel made for you, you'll leave. Personalisation is a retention play, not a fancy feature.
• The expert in your pocket. The promise of AI wellness has always been "your own nutritionist + trainer + therapist". This is one honest attempt at the planner layer of that.

What I learned

Building the engine end-to-end forced me to confront a question I'd been ducking at work: where does AI personalisation actually create value in a content subscription, and where does it just look like value? The answer turned out to be more nuanced than the PRD I'd have written before — and that's exactly why I keep building these on the side.

What it is

The Third Eye is a personal AI operating system. One assistant, four personas — JARVIS, FRIDAY, E.D.I.T.H., ULTRON — sharing the same toolset: tasks, notes, knowledge-base RAG, web search, weather, news, stock quotes, multi-agent parallel reasoning, translation, location-aware suggestions, calendar, reminders, voice control.

The agents disagree about tone; they agree about answers. You pick the personality, you get the same capabilities underneath.

Why I built it

Every productivity tool I tried at work — Notion, ChatGPT, custom GPTs — solved one slice but never the whole loop: capture → memory → recall → action → review. So I built the loop. It runs on my own infrastructure, learns my context, and never asks me to copy-paste between tabs.

The Iron Man personas weren't a gimmick — they were a forcing function. If JARVIS, FRIDAY, EDITH and ULTRON all had to share the same backend, I had to design the backend right.

What's broken without it

• Tool sprawl with no memory. ChatGPT forgets, Notion doesn't reason, calendar apps don't notice patterns. Third Eye stitches them.
• One-time consent. Mic, location, camera, notifications — granted once via a single dialog, never asked again unless reset.
• Voice that actually works. Wake word on agent name OR "hey/hi", Web Speech STT with interim text, TTS matched to the active agent's persona.
• Multi-agent reasoning. ULTRON mode kicks off N parallel sub-agents on distinct angles of a hard question and synthesises — for strategy / pros-cons / "should I do X".

How it's built

A Next.js 14 App Router app on Vercel, Google sign-in via NextAuth (JWT), all data server-scoped through one authenticated API route, and a 7-provider LLM cascade behind every generation. The assistant is a real tool-calling agent, not a chat box.

• Agent tool-loop. /api/chat streams a Gemini function-calling loop with ~25 tools — tasks, notes, goals, knowledge search, web/news/weather/stocks, calendar, email, reminders, multi-agent reasoning, and a Studio asset generator. Sensitive actions (send email, etc.) are confirm-then-act; created items get a short-lived Undo.
• Personas that actually change behaviour. JARVIS / FRIDAY / E.D.I.T.H. / ULTRON each inject their persona into the system prompt and drive a matching TTS voice — same tools underneath, different character on top.
• RLS-safe data layer. The browser never talks to Supabase directly; every read/write goes through a session-authenticated server route using the service role scoped to the user's email, with Row-Level-Security enforced by a tracked migration. A "Cloud synced / Local only" badge surfaces the persistence state.
• Real RAG memory (Cortex). Uploaded docs and past exchanges are embedded into Supabase pgvector; the assistant does semantic recall + document search with citations, falling back to keyword search when embeddings aren't configured.
• Mode-aware runtime. A Personal / Professional / Enterprise switcher re-frames the assistant's priorities and scopes Tasks, Notes, Goals, Knowledge and Finance to the active mode — plus a Studio of per-mode generators (landing pages, HTML mailers, lifecycle plans, creative).
• Ambient capture + vision. Live Capture uses the Web Speech API to transcribe continuously, auto-extracts tasks into the tracker (with a Wake Lock so the mic survives), and Gemini multimodal analyzes a shared screen or webcam frame (E.D.I.T.H.-style). Gmail/Chat scraping turns inbox activity into tasks on a schedule.
• Agent safety layer. A global kill switch plus an append-only, exportable audit log of every action the agent takes, surfaced on a dedicated Activity page and a dashboard widget.
• Cinematic front-end. A Three.js arc-reactor hero and GSAP scroll-reveals (both reduced-motion-aware and paused on hidden tabs), a command-center dashboard where every feature is a live widget, and an installable PWA.

The roadmap in my head

Wake-word via Porcupine for true always-on, a native desktop capture bridge for background/screen-off listening (the one thing a browser can't do), dedicated audio/music generation, deeper permission tiers for the agent, and predictive routines ("you usually do X now"). Vision, wake-word-on-name and Gmail/Calendar tools are already live.

What it is

Mailer Architect turns a one-line brief into a fully designed, send-ready HTML email — copy, layout, hero, subject line, quality score. It's universal: it reads the context and writes the right kind of mailer for a company or D2C brand, a product, a school or college, an office team, an event invite, a task or submission reminder, a nonprofit appeal — anything a mailer could exist for. A six-tier LLM cascade handles failover: OpenAI → Anthropic → Gemini → xAI → Groq → Cerebras. When one provider exhausts quota, the next takes over inside the same request.

Why I built it

Every organisation sends email — not just marketing teams. Schools send notices, offices send updates, event hosts send invites, and everyone chases deadlines with reminders. Each one costs time at a blank page, and the cost of not sending is bigger than the cost of a mediocre first draft. I wanted one tool that gives a competent, on-tone first draft in under a minute for any context, and lets a human edit instead of starting from scratch.

What's broken without it

• One template for everything. Most generators only know "sales email." Architect detects the context — commerce, school, college, office, event, reminder, nonprofit — and adapts tone, structure and call-to-action to match.
• LLM single-point-of-failure. One provider's billing limit hits and your send dies. The cascade routes around it without anyone noticing.
• Blank-page cost. Three genuinely different-angle variants land in seconds, each quality-scored, so a human edits instead of writing from zero.
• Always answers. A deterministic engine ships fully designed HTML even with no API keys — the demo never returns an error.

The roadmap in my head

Saved brand kits (palette + logo) per sender, a performance dashboard, an AI-generated mailer calendar built from past sends, and automated scheduling. (In flight.)

What it is

A plug-and-play, brand-agnostic lifecycle engine for any D2C brand. You enter a brand name or URL; it infers the category, benchmarks the competitive set the way a SimilarWeb / SEMrush market profile would — traffic mix, channel split, typical AOV and repeat-rate bands, seasonality — and then designs the whole lifecycle live: audience segments, a 30-day campaign calendar, an on-brand sample mailer, retention automations and target KPIs. No login, no proprietary data required — it runs entirely on industry-standard baselines for the brand's peer set.

Why I built it

Most D2C teams start every lifecycle plan from a blank page and a gut feel for "what good looks like" in their category. I wanted to compress that: type a brand, and instantly see where it likely sits versus its industry — then get a concrete, ESP-ready plan grounded in those benchmarks rather than guesses. It's the generalised, any-brand expression of how I think about retention: read the data, benchmark the market, then let the plan write itself.

What's broken without it

• No baseline. Teams plan lifecycle campaigns without knowing their category's typical channel split, AOV or repeat-rate. The engine seeds every plan from industry-standard bands for the brand's peer set.
• Blank-page planning. A 30-day calendar normally starts empty. Here it arrives segment- and cadence-aware, tuned to the inferred industry's seasonality.
• Mailer cold start. Every send begins from scratch. The demo hands you an on-brand sample mailer inferred from the brand's positioning.
• Vendor lock to see value. Most tools need account access and real data before they show anything. This returns a usable plan from just a brand name.

How it's built

A single Vercel serverless engine that turns a brand name into an industry-benchmarked lifecycle plan, with a deterministic fallback so the demo never fails to respond.

• Industry-benchmark layer. The entered brand is mapped to a category and a competitive set, then profiled against competitive-intelligence-style baselines (traffic sources, channel mix, AOV and repeat-purchase bands, seasonality) — the way SimilarWeb / SEMrush characterise a market. Where a live data provider is keyed it uses it; otherwise it derives the bands from an LLM-backed industry model.
• Free multi-provider LLM cascade. The plan generator routes across free LLM providers (Groq → Cerebras → Gemini → OpenRouter), demoting on quota/auth failures so one outage never takes the demo down.
• Deterministic fallback. If every provider is unavailable, a template planner still returns a coherent, ESP-ready plan — segments, calendar, mailer and KPIs — so the demo always shows something usable.
• Brand-agnostic by design. Nothing is hard-coded to a single brand or dataset; the same engine works for any D2C name you type, drawing only on public/industry-standard signals.

Every module, live

LifeCycle-OS is not one page — it is a suite. Each module below is a working tool you can open right now, and each one reads from the same locked strategy, so a decision made in Smart Brain shows up in the calendar, the mailers, the ads and the creative briefs without being re-entered.

One source of truth, four times over

Sixteen modules only feel like one product because four small files refuse to let them disagree. They are the most reusable thing in the repository, and each exists because the alternative had already gone wrong.

• region-context.js — one active region, shared by every page. Region selection had been built on 17 of 66 pages in six different ways, none of them sharing state, so choosing UK in one place left another showing whatever its default was.
• brand-context.js — one active brand, driving tokens, fonts, title and favicon everywhere at once, so every page re-skins without knowing the file exists.
• brand-catalog.js — one catalogue resolver. Pages used to read the shipped product file directly, which meant any other workspace was quietly shown the first tenant's products as if they were its own.
• analysis-registry.js — one place that says which analysis lives where. Seven surfaces had each decided for themselves, and several analysed the same thing; nothing stated the intended arrangement, so every drift stayed invisible until two pages were opened side by side.

The roadmap in my head

Deeper live competitive-intelligence integrations (paid SimilarWeb / SEMrush pulls behind a key), category-specific benchmark libraries, a one-click export of the whole plan to popular ESPs, and a "compare two brands" mode that diffs their likely lifecycle posture side by side.

What it is

A long-form D2C marketing landing page with an all-in-one AI agent embedded right at the top. The agent starts narrating the page aloud the moment you land (selectable British voices, with play/pause and mute), holds a two-way voice conversation when you tap Talk, answers typed questions in chat, and runs a "help me choose" recommendation flow — all four sharing the same page context, so every answer is grounded in what the page is actually selling.

Why I built it

D2C landing pages are monologues — thousands of words of persuasion with no way for the visitor to ask the one question actually blocking the purchase. The best-converting sales channel is still a human who explains, listens, answers and recommends. I wanted the page itself to behave like that salesperson, without making the visitor read a word if they'd rather just listen and talk.

What's broken without it

• Reading is friction. Most visitors skim 20% of a long-form LP. Auto-narration delivers the full pitch hands-free, the way a podcast does.
• Questions go unanswered. Objections — "will this work for me?", "how is it different?" — normally send visitors to Google and they don't come back. Voice and chat answer them in the moment, on the page.
• One-size pitch. "Help me choose" turns a static offer into a guided recommendation tied to what the visitor actually needs.
• Four vendors, one widget. A narrator, a voice agent, a chatbot and a recommender are normally four separate tools with four contexts. Here one agent shares state, content and controls.

The roadmap in my head

Conversion attribution per interaction (do narration listeners or talkers buy more?), scroll-aware narration that follows the section you're reading, multilingual voices for other markets, and piping conversation transcripts into a lifecycle/retention dashboard as objection-mining data for the next campaign.

What it is

JobHunt is a free, live job-search tool. You sign in with Google, type a role and (optionally) a location, and it pulls current openings from free, keyless public job boards — Remotive, RemoteOK, Arbeitnow and The Muse — matches them to your query, de-duplicates, and hands back each with a direct link to apply. No spreadsheet, no workflow to import, no API key: just type and search.

Why I built it

Job hunting means checking board after board, copy-pasting listings, and losing track of what you've already seen. I wanted a single box where you describe the role once and the tool does the scanning for you — pulling live, real postings from several boards at once and showing them cleanly so you can go straight to applying.

Under the hood

• Gated by Google sign-in. Access runs through Supabase auth, so the tool is tied to a real Google account — light protection against abuse.
• Free public job APIs. A Vercel serverless function queries several free, keyless job boards (Remotive, RemoteOK, Arbeitnow, The Muse) in parallel at request time — no paid key, no per-minute rate limit to hit.
• Matched to your role. Results are title-matched to what you searched, de-duplicated across boards, and each carries a company, location, source and a direct apply link.
• Genuinely free. No API key anywhere — visitors never need one and there is nothing to install or run out of.
• Results you can act on. Every opening opens straight to the original posting in a new tab, so you go from search to apply in one click.

What matters most

Every listing comes straight from a real job board's own API — nothing is invented — and always links back to the original posting to confirm before applying. Because it's public, it's gated behind sign-in, so it stays honest, free and abuse-resistant.

The roadmap in my head

Saved searches and email alerts for new matches, more boards and region filters, salary and seniority signals, a "tailor my application" handoff that drafts a role-specific resume and cover letter, and a lightweight tracker so you can mark what you've applied to — all while keeping the one-box, sign-in-and-search simplicity.