Rujuta
Gandhi

Most AI trading demos are either toy examples with no real architecture, or black-box systems with no explainability. I wanted to build something that demonstrates genuine AI PM thinking: a production-grade agentic system with documented tradeoffs, risk management guardrails, and a self-improving feedback loop — all running live on real market data.

A dual-strategy autonomous paper trading bot that runs 24/7 on Render, scanning US stocks and crypto every hour. The Conservative strategy ($1,000, Bridgewater-style discipline) and Aggressive strategy ($1,000, Citadel-style momentum) operate in parallel on separate Alpaca paper accounts. Claude makes every buy/sell/hold decision using a weighted 9-signal scoring engine. A dynamic screener replaces the fixed stock list — fetching the most active and highest-momentum US stocks from Alpaca each cycle so the bot always trades what's actually moving. A self-tuning end-of-day review fires at 4:05pm ET — Claude analyzes the day's trades and adjusts RSI thresholds, ATR multipliers, and strategy mode for the next session. Phase 7 adds adaptive macro regime detection — the bot reads VIX, SPY vs 200-day MA, and a quantitative spike trigger to switch between four strategy modes every cycle.

• Claude over Finnhub for sentiment — Pre-computed sentiment scores can't distinguish "beat earnings but weak guidance" from "clean beat." Claude reads actual headlines and reasons about nuance. Same cost per call, better signal quality.
• Weighted scoring engine over vote counting — RSI and MACD are both momentum indicators — they correlate. Treating them as independent votes inflates confidence. Built a point-weighted system (news +3, congressional +2, regime +2, each technical +1) so signal quality determines weight, not just count.
• Two separate Alpaca paper accounts — One shared $2,000 account means kill switches fire at the wrong portfolio threshold and strategies compete for cash. Separate accounts give each strategy true independence and accurate floor monitoring.
• Earnings guard as a hard veto — No amount of bullish signals justifies holding into an unpredictable binary event. Alpaca's earnings calendar API blocks new positions within 2 days of earnings regardless of score.
• Manual crypto stop-loss in code — Alpaca doesn't support bracket orders for crypto. Rather than removing stop protection, implemented a state-persisted stop-loss checker that runs every cycle and triggers a market sell if price breaches the ATR-based stop.
• Health endpoint to avoid Render spin-down — Free tier Web Services sleep after inactivity. Added a lightweight HTTP health server running in a background thread so cron-job.org pings keep the bot alive 24/7.
• Whole shares for stocks — Alpaca doesn't support bracket orders on fractional shares. Rounded position sizes to whole shares to enable automatic stop-loss and take-profit on all stock trades.
• Self-tuning daily review loop — Static bots don't learn. Claude reviews its own trade log at 4:05pm ET, identifies what worked and what didn't, and outputs JSON parameter adjustments with safety bounds checking to prevent runaway values.
• SendGrid over Gmail SMTP — Render's free tier blocks outbound SMTP. Switched to SendGrid HTTP API (Mail Send only, restricted key) which works on all Render tiers and is more secure by design.
• Phase-based build with eval gates — Built in 7 phases, each with its own test file before proceeding. 22 checks in test_dry_run.py, 35 in test_signals.py, 25 in test_phase5.py, 22 checks in test_phase6.py, 33 checks in test_phase7.py — all passing before deployment.
• Adaptive regime strategy over static personas — Instead of always running the same Bridgewater or Citadel persona, both strategies now read live macro conditions (VIX, SPY vs 200MA, VIX spike) every cycle and switch between four modes: MOMENTUM, MEAN_REVERSION, DEFENSIVE, and MACRO_EVENT. Conservative holds cash in DEFENSIVE and MACRO_EVENT — Claude is never called. This eliminated the core failure mode of a momentum bot running in a bear market.
• ETF short selling over single-stock shorts — In DEFENSIVE mode, Aggressive can short SPY or QQQ only. Single-stock shorts (GameStop-style squeezes) are explicitly banned. ETF shorts are liquid, can't squeeze, and provide clean bear market exposure without catastrophic tail risk.
• Combined portfolio kill switch — Individual strategy floors ($700 Conservative, $600 Aggressive) protect each account in isolation. Added a combined check: if total equity across both accounts drops below $1,700 (−15% on $2,000), both strategies halt immediately. Catches scenarios where neither individual floor triggers but combined losses are significant.
• Dynamic screener over fixed stock list — Instead of always scanning the same 10 stocks, the screener fetches the most active and highest-momentum US stocks from Alpaca each cycle. UBER is permanently included. AMZN is permanently excluded due to trading restrictions — enforced at the config level and tested in the Phase 6 test suite.
• Reddit + StockTwits social sentiment — Retail momentum often appears on social media before price moves. Both APIs are free with no authentication required. Claude scores the combined signal (+2 bullish / -2 bearish) as the 9th weighted signal in the scoring engine.

My goal was to build a real agentic system — not a demo — and document every architectural decision. I wanted hands-on exposure to LLM-as-decision-maker patterns, risk management architecture, financial APIs, and the practical tradeoffs of running AI systems in production. The most important lesson: prompt framing matters as much as model choice. Telling Claude it's a "former Bridgewater portfolio manager who survived the 2008 crash" produces materially different risk reasoning than a generic system prompt.

• Phase 7 — shipped: Adaptive regime detection (MOMENTUM / MEAN_REVERSION / DEFENSIVE / MACRO_EVENT), ETF short selling in bear markets, combined $1,700 portfolio kill switch, VIX + SPY/200MA macro trigger — 33 tests passing.
• Dashboard V3: Signal scorecard per trade and news headlines panel — requires Supabase decision logging so data persists across Render services.
• Real money deployment: After 4–6 weeks of paper trading validation with documented Sharpe ratio, win rate, and regime-adjusted returns.
• Options layer: Aggressive strategy V3 — calls/puts on high-conviction signals for leveraged upside with capped downside.

Over 1.5 million Gujarati-Americans live in the US. Most diaspora children hear Gujarati at home but have no engaging, age-appropriate tool to learn it actively. Existing apps like Duolingo weren't built for Indic languages or pre-readers. Parents want their kids to connect with their heritage — but there was no Babu for Gujarati.

A mobile-first web app for children who cannot yet read. Babu (a cartoon monkey) speaks every word aloud in authentic Gujarati using Sarvam Bulbul v3 — a model trained on Indic languages. Children swipe right for "Got it" and left for "Again" on picture-only flashcards, practice pronunciation with real-time feedback, then take a picture-choice quiz. 95 words across 6 topics. V2.3 adds pronunciation checking: the child says the word, and Babu responds with animated reactions, star ratings, and optional phoneme-level feedback.

• Switched from ElevenLabs to Sarvam Bulbul v3 in V2.1 — sends native Gujarati script (સફરજન) instead of romanized text (Safarjan), producing authentic pronunciation instead of an anglicized accent.
• Moved all API keys to Supabase Edge Functions — nothing sensitive is exposed in the browser. The app calls two proxy endpoints; the backend holds all credentials.
• Flashcard content migrated from hardcoded JS to a Supabase database table — new words can be added without touching code.
• Pre-generated all 95 audio files as static MP3s via GitHub Actions CI/CD — audio plays in under 100ms with no API calls at runtime. This matches the architecture used by Duolingo and Rosetta Stone.
• Three-tier audio fallback: static MP3 → Sarvam Edge Function → Web Speech API — the app degrades gracefully if any layer fails.
• Swipe gesture replaces Got it / Again buttons — instinctive for touchscreen-native children. Tapping the card replays the word — no speaker button needed.
• Review cards loop before the quiz starts — children who struggled with a word get a second chance before being tested on it.
• Quiz distractors sourced from the same stack only — a fruits quiz never shows a color or family emoji.
• Quiz audio sequencing fixed — congrats plays immediately on correct answer, new word plays only after navigating to the next question. Wrong answer says "Try karo!" then pauses before repeating the word.
• Consistent jungle green background across card, quiz, and reward screens — matches Duolingo's approach of keeping the learning environment visually stable.
• Topic cards show Gujarati transliteration below the English name — toggling the script switch shows native script instead.
• V2.3 Silence Detection: Recording auto-stops after 1.5 seconds of silence using AudioContext volume monitoring — children no longer need to manually tap the mic button twice. Volume threshold set at 30 (configurable) with a hard 6-second limit to prevent accidental long recordings.
• Star-based feedback over colors: Replaced confusing green/amber/red mic button with a universal 5-star rating system (5 stars = 75%+ similarity, 3 stars = 50-75%, 1 star = <50%). Stars are consistent with the quiz reward system and avoid color-blindness issues.
• Babu character reactions: Animated emoji responses based on performance — Babu jumps for perfect pronunciation (75%+), nods for good attempts (50-75%), and scratches his head for struggles (<50%). Reuses quiz screen animations for visual consistency.
• Sound feedback via Web Audio API: Programmatic tone generation (chime/beep/boop) provides instant auditory reinforcement without requiring MP3 files. Sounds work even when the child looks away from the screen.
• Phoneme feedback toggle: Optional detailed feedback mode (off by default) shows character-by-character comparison with red/green highlighting and phoneme-specific pronunciation tips. Progressive disclosure keeps the UX simple for younger kids while offering educational depth for advanced learners.
• Sarvam Saaras ASR v3: Topic-based routing sends numbers through verbatim mode + Transliterate API (2 calls) to preserve "પંદર" → "pandar" instead of "15". All other topics use translit mode (1 call) for romanized output.

My learning goal with this is ultimately to create a mobile app and gain exposure to AI voice technology. I want to continue my exposure and understanding of Supabase, infrastructure, and server costs that I learned in USPS chatbot.

• V3: Add authentication / login features and store progress history; add additinal topics
• V4: Add practice conversations or stories
• V5: iOS App Store via Capacitor wrapper, payments for app download
• V6: Parent dashboard, cross-device sync, community flag review,move to different server

USPS customers frequently complain that it is hard to find the answer to their questions. The information exists in USPS FAQ documentation, but customers cannot navigate to the correct page. The opportunity: an AI agent that answers accurately from trusted content and knows when to escalate.

A RAG-powered conversational chatbot that scrapes and indexes 286 real USPS FAQ articles, retrieves the most semantically relevant content for each question, and streams a grounded plain-language response token by token. V2 adds conversation memory across 3 turns, a pre-flight intent classifier that asks one clarifying question when the topic is ambiguous, response summarization capped at 100 words, and graceful escalation with phone and chat contact options when the agent reaches its limits.

• Used Firecrawl over BeautifulSoup — USPS FAQs are JavaScript-rendered via Salesforce Experience Cloud, which returns empty pages to traditional scrapers
• Switched from sentence-transformers to Voyage AI (voyage-3) after evals showed sentence-transformers failed on the most common USPS queries — Hit Rate@5 jumped from ~80% to 100%
• Set similarity threshold at 0.3 after running a 20-question golden set (10 common + 5 niche + 5 escalation) — LLM-as-Judge scored 4.93/5 faithfulness, 4.73/5 relevance
• Chose Supabase pgvector over Pinecone to reduce infrastructure complexity and stay free-tier compatible for a V1
• Deployed on Render free tier with a cron-job.org keep-alive ping every 10 minutes to prevent cold starts
• SSE streaming over standard JSON response — tokens stream to the browser as Claude generates them. Animated typing dots show until the first token arrives, then text renders word by word. Two response headers prevent Render's nginx proxy from buffering the stream.
• Pre-flight intent classifier — a lightweight Claude call (temperature 0) runs before retrieval to decide if a clarifying question is needed. This preserves the forced tool_choice guardrail on the main agent loop. Named-service questions (Priority Mail, First-Class, etc.) skip the classifier entirely to reduce latency.
• Turn counter owned by the frontend — the client sends turn_number with every request and only increments after a real answer is received. Clarifying exchanges store in history but don't consume a turn, so context is preserved without shortening the conversation window.
• Citation pill replaces inline URL — Claude was choosing which URL to include in its prose, sometimes picking a lower-relevance article. Removing the inline URL instruction and relying solely on the meta source_url (always the highest similarity score chunk) gives users one correct, consistent source per answer.
• Supabase RPC functions secured with SET search_path = public — fixed a mutable search_path security advisory. Dropped three legacy embedding functions that were flagged but no longer called by any code.
• Chose Supabase pgvector over Pinecone to reduce infrastructure complexity and stay free-tier compatible. Deployed on Render free tier with a cron-job.org keep-alive ping every 10 minutes to prevent cold starts.

I wanted to vibe-code a conversational AI chatbot end-to-end — with hands-on exposure to tools like Firecrawl, Supabase, Claude Code, and Git — while thinking through the full product lifecycle: data acquisition, embedding strategy, retrieval quality, agent design, hosting tradeoffs, cost constraints, and frontend UX. The goal was to develop sharp instincts for where AI adds value, where it breaks, and what decisions a PM needs to make at every layer of the stack.

• Stream clarifying questions
• Speech to text and text to speech to interact with the bot
• Review groundedness since Claude is answering some questions based on it's own knowledge base

People face complex decisions every day — career moves, business strategies, major purchases — but lack a structured way to think them through. Generic pros/cons lists are shallow. Consultants are expensive. Most people just wing it.

Easy Decision Maker uses Google Gemini to automatically transform vague prompts into structured, professional-grade analytical frameworks — including Comparison Tables, SWOT Analysis, and PESTLE Analysis. The AI selects the right framework based on your input, and a Clarification Gate pauses generation when prompts are too vague to ensure high-quality outputs.

• Retired lower-value frameworks (SOAR, Porter's 5 Forces) to reduce cognitive overload
• Added server-side rate limiting (10 req/day) to control API costs and ensure sustainability
• Designed mobile-first with auto-expanding inputs for on-the-go decision making
• Built strict JSON schema validation to guarantee 100% structured output integrity

My learning goal with this page was to use Google AI studio and vibe code an app. The AI created many errors with button usage and wasn't inherently mobile-friendly, showing me where to focus more of my time in Google AI Studio.

Most PM portfolios are static PDFs or generic LinkedIn profiles — they don't show how a product manager thinks, builds, or ships. As someone pivoting into AI PM roles, I needed a living showcase that could host real, interactive demos and be updated quickly without a full engineering setup.

A single-file, zero-dependency portfolio site hosted on GitHub Pages under my own namespace (rujutagandhi.github.io). It features a scrollable layout with sections for About, Experience, Education, Skills, and AI Demos. Each demo has a card grid entry and a detailed modal with product context — problem, decisions, and tech stack. The entire site lives in one HTML file, making it easy to maintain and version-control.

• Single-file architecture — No build pipeline, no dependencies. Push one file to GitHub and it's live instantly. Reduces friction for continuous updates.
• Modal-based demo detail — Instead of separate pages per demo (which would need routing), modals keep the user in context and load instantly with no extra network requests.
• Demo-card pattern — Standardized Problem / What I Built / Key Decisions / Tech Stack structure signals PM thinking rigor, not just developer output.
• GitHub Pages hosting — Free, SSL-secured, and tied to the professional namespace rujutagandhi.github.io. Zero ops overhead.
• AI-assisted development with Claude — Used Claude as a co-pilot for design and code generation, demonstrating practical AI tool fluency to hiring managers.

While working on AI Demo's, I will always have a learning goal. Through this website, I wanted to learn and demonstrate use of Github & Github CLI and Claude (Projects, Prompting). This AI Demo website was developed in combination with the two. I also leveraged previous HTML/CSS knowledge to make further edits without Claude use to be mindful of token usage.