ShopGuard

AI-powered behavioral wellness that helps you think twice before you buy.

Comment

ShopGuard - Devpost Project Story

Inspiration 💡

It started with a 2 AM shopping cart incident.

One of our team members woke up to a credit card notification for $347 worth of "essential" skincare products she'd bought at midnight while doom-scrolling TikTok after a stressful work deadline. The products arrived. They sat unopened for weeks. Sound familiar?

We realized impulse purchases aren't really about the products—they're about our emotions.

Americans spend over $3,800 per year on impulse purchases. That's a vacation, six months of groceries, or a meaningful investment in mental health. Yet existing solutions (budgeting apps, browser blockers) focus on restriction rather than reflection. They tell you "no" without helping you understand "why."

We wanted to build something different: an AI companion that meets you where you are emotionally and helps you make purchasing decisions you'll feel good about tomorrow.

That's how ShopGuard was born.

What It Does ✨

ShopGuard is a behavioral wellness platform that prevents impulse purchases through emotional awareness and AI-powered intervention.

Core Features

1. Emotional Check-Ins Track your mood (1-10 scale) and emotional state daily. Our AI analyzes patterns to identify when you're most vulnerable to impulse spending (stress, boredom, FOMO).

2. AI-Powered Purchase Intent Classification Before buying, add the item to ShopGuard. Our Intent Classifier (powered by Llama 3.3 70B) analyzes the purchase and categorizes it:

  • 🟢 NEED - Essential purchase (groceries, medicine)
  • 🟡 WANT - Planned, thoughtful desire
  • 🔴 EMOTIONAL - Impulse driven by feelings, FOMO, or marketing

3. ShopBuddy - Your AI Shopping Companion A conversational AI assistant that:

  • Asks thoughtful questions ("Would you still want this if it wasn't on sale?")
  • References your emotional state ("I noticed you're stressed today...")
  • Gently challenges impulses without judgment
  • Can create cooling-off periods automatically

4. Cooling-Off Periods High-risk purchases enter a 7-day waiting period. Revisit when emotions have settled. If you still want it—great! If not, you've saved money and regret.

5. Progress Tracking Dashboard shows money saved, purchases avoided, emotional triggers, and behavioral improvements over time.

How We Built It 🛠️

Architecture

We built ShopGuard as a production-ready microservices application using modern AI infrastructure:

Backend - Raindrop Serverless Platform

  • 9 microservices for scalability and separation of concerns
    • api-gateway - HTTP routing, JWT verification, CORS (17 endpoints)
    • auth-service - User registration, login, password hashing
    • purchase-intent-service - Purchase tracking and management
    • checkin-service - Emotional mood tracking
    • cooling-off-service - Impulse prevention timers
    • analytics-service - Behavioral metrics and dashboard
    • intent-classifier - AI-powered purchase classification
    • sentiment-analyzer - Emotional risk assessment
    • shopping-assistant - Conversational AI (ShopBuddy)

Database - Raindrop SmartSQL

  • 6 relational tables (users, purchase_intents, checkins, cooling_off_items, progress_metrics, trigger_patterns)
  • Proper indexing and foreign key relationships
  • Migration-based schema management

AI - Raindrop SmartInference (Llama 3.3 70B)

We built 3 specialized AI agents, all powered by Llama 3.3 70B:

  1. Intent Classifier

    • Analyzes purchase description, cost, context
    • Returns classification (need/want/emotional) + confidence score + reasoning
    • Temperature: 0.3 for consistent categorization

  2. Sentiment Analyzer

    • Processes mood ratings and written check-in notes
    • Calculates emotional risk score (-100 to +100)
    • Identifies triggers (stress, anxiety, boredom)
    • Temperature: 0.5 for nuanced emotional understanding

  3. Shopping Assistant (ShopBuddy)

    • Context-aware conversational AI with personality
    • Accesses user's emotional state and purchase history
    • Can take actions: create purchase intents, add cooling-off periods
    • Friendly, funny tone—not preachy or judgmental
    • Temperature: 0.7 for natural, warm responses
    • Safety guardrails: stays on-topic, redirects medical questions

Cloud Storage - Vultr Object Storage

  • S3-compatible object storage for user data exports
  • GDPR-compliant data portability (/users/export endpoint)
  • Pre-signed URLs with 1-hour expiration for security
  • Bucket: shopguard-data in New York region (ewr1)

Frontend - React + TypeScript

  • Fully responsive design (mobile + desktop)
  • Real-time chat interface with typing indicators
  • Toast notifications for user feedback
  • Auto-refresh when AI takes actions
  • Deployed on Netlify

Authentication - JWT

  • HS256 signing algorithm
  • 24-hour token expiration
  • Secure password hashing with bcryptjs (10 salt rounds)
  • User data isolation enforced at database query level

Tech Stack Summary

  • Runtime: Raindrop (V8-based serverless)
  • Language: TypeScript (strict mode, 100% type safety)
  • AI Model: Llama 3.3 70B via Raindrop SmartInference
  • Database: SmartSQL (SQLite with AI capabilities)
  • Storage: Vultr Object Storage (S3-compatible)
  • Frontend: React, TypeScript, Vite
  • Deployment: Raindrop (backend), Netlify (frontend)
  • Tools: Claude Code (AI pair programming), Git/GitHub

Challenges We Faced 🧗

1. Giving AI a Personality Without Being Annoying

Challenge: Early versions of ShopBuddy sounded either too robotic ("I have detected an emotional purchase") or too patronizing ("Are you sure you need that? 🤔").

Solution: We iterated on the system prompt extensively, adding:

  • Conversational filler ("Ooh," "Hmm," "Let's get real for a sec...")
  • Empathy without judgment ("Sometimes when we're stressed, retail therapy feels like self-care, right?")
  • Humor ("Sales are sneaky! 🎯")
  • Open-ended questions instead of lectures
  • Temperature: 0.7 for natural variation

Result: ShopBuddy now feels like texting a supportive friend, not a financial advisor.

2. Making AI Take Actions (Not Just Talk)

Challenge: Initially, ShopBuddy could only chat. Users had to manually create purchase intents after the conversation, breaking the flow.

Solution: We implemented an action system where ShopBuddy can:

  • Parse special action markers in AI responses ([ACTION:ADD_TO_COOLING_OFF])
  • Automatically create purchase intents with cooling-off periods
  • Trigger database writes and UI updates
  • Notify users with toast messages

Technical Implementation:

// ShopBuddy can return action markers
if (aiResponse.includes('[ACTION:ADD_TO_COOLING_OFF]')) {
  await createPurchaseIntent({
    itemName,
    estimatedCost,
    coolingOffPeriod: 7
  });
  showToast('Added to your dashboard with a 7-day cooling-off period!');
}

Result: Seamless conversational experience where AI doesn't just advise—it acts on your behalf.

3. Designing for Vulnerability, Not Shame

Challenge: Impulse buying is tied to emotions people often feel ashamed about (stress, anxiety, loneliness). How do we address this sensitively?

Solution:

  • Framed as "behavioral wellness" not "spending control"
  • No guilt-tripping language ("bad purchase," "failed")
  • Neutral labels: "avoided" not "resisted," "emotional" not "impulsive"
  • Progress tracking celebrates wins, doesn't punish mistakes
  • AI tone is warm and non-judgmental

Result: Users feel supported, not scolded.

4. SmartSQL Database Schema Design

Challenge: Balancing normalized database design with performance for analytics queries.

Solution:

  • 6 tables with proper foreign keys for data integrity
  • Denormalized progress_metrics table for fast dashboard queries
  • Strategic indexes on user_id + created_at for common filters
  • Parameterized queries to prevent SQL injection

Learned: SmartSQL's AI capabilities made query optimization easier than expected—we could ask it for query suggestions!

5. Vultr Integration for GDPR Compliance

Challenge: We needed to integrate a Vultr service meaningfully, not just for hackathon requirements.

Solution: Built a user data export feature that:

  • Gathers all user data (profile, purchase intents, check-ins, analytics)
  • Uploads JSON to Vultr Object Storage
  • Generates pre-signed download URLs (1-hour expiration)
  • Provides true data portability (GDPR Article 20)

Technical Win: Vultr's S3-compatible API made integration seamless with AWS SDK.

6. Microservices Communication on Raindrop

Challenge: How do 14 independent services communicate without HTTP overhead?

Solution: Raindrop's environment bindings allow in-process service-to-service calls:

// From purchase-intent-service → intent-classifier
const result = await env.INTENT_CLASSIFIER.classify({
  itemName: 'Viral face cream',
  estimatedCost: 89,
  context: 'TikTok ad, on sale'
});

Result: Lightning-fast inter-service communication without network latency.

Accomplishments That We're Proud Of 🏆

1. Shipped a Production-Ready App in Under 2 Weeks

We didn't just build a demo—we built a fully functional, deployed application with authentication, database, AI agents, and a polished UI. It's live, it's fast, and judges can actually use it.

2. Built 3 Specialized AI Agents with Distinct Personalities

Our Intent Classifier, Sentiment Analyzer, and Shopping Assistant (ShopBuddy) each have different temperatures and system prompts optimized for their specific tasks. ShopBuddy genuinely feels like chatting with a friend, not a bot.

3. Achieved True Microservices Architecture

9 independent services communicating seamlessly on Raindrop. We proved that microservices don't have to be complex—with the right platform, they're cleaner and more maintainable than a monolith.

4. Solved a Real Human Problem

This isn't a toy project. Impulse buying affects millions of people and costs them thousands annually. We built something that could genuinely improve financial and emotional wellness.

5. Integrated Vultr Meaningfully, Not Just for Requirements

Instead of tacking on Vultr as a checkbox, we built a GDPR-compliant data export feature that provides real value. Users can download all their data with one click—true data portability.

6. Created AI That Takes Action, Not Just Advice

ShopBuddy doesn't just talk—it can create purchase intents, add cooling-off periods, and update your dashboard. This "agentic AI" approach makes the experience seamless and magical.

7. Learned to Ship Fast Without Sacrificing Quality

TypeScript strict mode, proper database schema, JWT authentication, error handling, responsive design—we didn't cut corners. Fast shipping + quality engineering is possible.

8. Built Something We'd Actually Use

The ultimate validation: multiple team members are now using ShopGuard for real purchases. When your own team becomes your users, you know you've built something valuable.

What We Learned 📚

Technical Learnings

  1. AI Temperature Matters for UX

    • 0.3 for classification (consistency)
    • 0.5 for sentiment analysis (nuance)
    • 0.7 for conversation (warmth)

  2. Raindrop's SmartInference is Powerful Llama 3.3 70B handled all three AI tasks (classification, sentiment, conversation) with impressive reasoning quality—and at a fraction of GPT-4's cost.

  3. Microservices ≠ Complexity With Raindrop's service bindings, we got the benefits of microservices (scalability, clear separation) without the typical overhead.

  4. TypeScript Strict Mode Saves Time Caught dozens of bugs at compile-time that would've been painful in production.

  5. Serverless Deployment is Magic raindrop build deploy -s → 14 services deployed globally in under 2 minutes. No Docker, no Kubernetes, no headaches.

Product Learnings

  1. People Want Understanding, Not Restriction During user testing, participants preferred "Why do you want this?" over "You can't buy this."

  2. Emotional Context Changes Everything Linking purchases to mood data revealed patterns users didn't know they had ("I always shop late at night when I'm stressed").

  3. AI Can Be a Coach, Not a Cop ShopBuddy's conversational approach felt supportive. Traditional budgeting apps felt punitive.

Personal Growth

  1. Hackathons Teach Speed + Scope Management We initially planned 20+ features. Ruthlessly cutting to the core 5 made the app actually shippable.

  2. AI Pair Programming (Claude Code) is a Superpower We built this entire app—9 microservices, frontend, AI agents—in under 2 weeks with Claude Code as our pair programmer.

  3. Good Documentation = Good Teamwork With 4 team members, our Markdown docs (COLLABORATION.md, DEPLOYMENT_STATUS.md) kept everyone aligned.

What's Next for ShopGuard 🚀

Short-Term (Next 3 Months)

  • Browser Extension: Intercept shopping sites in real-time and trigger ShopBuddy before checkout
  • Mobile App: iOS/Android native apps for on-the-go check-ins
  • Credit Card Integration: Plaid API to automatically detect purchases and prompt reflection

Long-Term Vision

  • AI-Suggested Alternatives: "Instead of $89 face cream, try this $15 option with better reviews"
  • Accountability Partners: Share goals with friends, celebrate avoided purchases together
  • Advanced Analytics: Heatmaps of trigger times, pattern prediction ("You tend to shop on Sundays after 8pm")
  • Gamification: Badges, streaks, challenges to make mindful spending fun
  • Therapist Integration: Optional sharing of emotional data with mental health professionals

Business Model (Freemium)

  • Free Tier: 10 check-ins/month, basic AI chats, purchase tracking
  • Premium ($4.99/month): Unlimited check-ins, advanced analytics, priority AI responses, browser extension
  • Enterprise ($99/month): White-label for employee wellness programs

Impact We Hope to Make 🌍

Behavioral wellness is social good.

If ShopGuard helps just 1,000 users avoid 2 impulse purchases per month, that's:

  • $600,000+ saved annually (avg. impulse purchase = $25)
  • Reduced consumer debt and financial stress
  • Less clutter, more intentional living
  • Improved emotional awareness and self-regulation

Beyond money, we're building emotional intelligence tools that help people understand why they do what they do. That skill extends far beyond shopping.

We believe the best purchase is the one you didn't regret.

Try It Yourself 🛡️

Live App: https://shopguard.netlify.app Demo Credentials: [email protected] / helloworld12345 GitHub: https://github.com/andreinagines/shopguard

Built With ❤️

  • Raindrop Platform (SmartSQL, SmartInference, Microservices)
  • Vultr Object Storage
  • Llama 3.3 70B
  • React + TypeScript
  • Claude Code
  • Lots of late nights and "just one more feature" moments

Team: [email protected] • [email protected]

"Shop smarter, not harder. Shop with intention, not impulse." 🛡️

Built With

Share this project:

Updates