reKibble

• 

  Architecture Diagram

Inspiration

My local pet supply store is run by an amazing guy. He's the dad of my kids' friend, and I watched him work his way up from being a barista next door to owning his own shop. He knows my pets by name, and I am fiercely loyal to his business.

But I saw his struggle firsthand. He doesn't even have a website, telling me that platforms like WordPress are "too technical" and that he's a shop owner, "not an app builder." Because he has no online presence, I can't check if he has my dogs' food in stock. More than once, I've shown up to an empty shelf and had to make last-minute rice and chicken for my dogs, fighting the urge to just give in and subscribe to Chewy or Amazon.

I don't want to cheat on my local store. I want to support the human running it.

I built reKibble to solve this exact problem. It's a platform for the owners who know our pets' names but can't compete with the convenience of online giants. It's a tool that gives them the power of Amazon, with the personal touch they already provide, all in under five minutes, no technical skill required.

What it does

reKibble is an AI-powered business partner that gives local pet stores the tools to fight back against online giants. In under five minutes, a non-technical store owner can:

• Instantly Generate a Website: Our AI Content Agent writes their marketing copy, and our AI Market Analyst suggests a curated, locally-tuned product catalog.
• Automate Customer Retention: A proactive AI Refill Agent runs on a schedule, predicts when a customer's pet is running low on food (based on purchase history and pet profiles), and initiates a conversational SMS flow to secure the next sale.
• Manage Orders Simply: Owners receive real-time SMS alerts for new orders and can confirm stock, handle out-of-stock ETAs, and notify shoppers with a single click from their mobile-friendly dashboard.

For the shopper, it's a magical convenience. For the store owner, it's a digital employee that automates retention and guarantees repeat business.

How I built it

reKibble is a professional, multi-tenant, full-stack application built entirely on a serverless Google Cloud architecture.

• Backend: A Node.js/Express API deployed as a Cloud Run service. This is the "brain" that contains a suite of specialized AI agents built using the Gemini API for content generation, market research, and advanced conversational intent recognition. It uses a secure authentication middleware to protect all sensitive endpoints.
• Frontend: A dynamic, multi-tenant Next.js application, also deployed on Cloud Run. It uses Server-Side Rendering for fast, dynamic store pages and Client-Side Rendering for all interactive owner and shopper experiences.
• Database: Google Firestore is our single source of truth, with a multi-database setup (dev and prod) for professional environment separation. We use native indexed queries for scalable, real-time data fetching.
• Automation: Cloud Scheduler is our "alarm clock", securely triggering our AI agent endpoints on a daily schedule using OIDC tokens for authentication. I chose to use Cloud Scheduler with an HTTP target, not Cloud Run Jobs, because our agent tasks are short-lived.
• CI/CD & Security: All deployments are automated via Cloud Build and cloudbuild.yaml files. All secrets (API keys for Twilio and Google AI) are securely managed in Secret Manager, following the principle of least privilege for all service accounts.
• Other Services: We also integrated Firebase Authentication for user management, the Google Maps Platform (Maps, Places, Geocoding APIs) for our "Smart Map" discovery tool, and the Twilio API for all conversational SMS workflows.

Challenges I ran into

This project was a marathon of debugging real-world cloud complexity, all while "vibecoding" with an AI pair programmer. What started as a smooth ride quickly became a lesson in the friction between vibes and guardrails.

The biggest challenge was navigating the intricate web of Google Cloud IAM permissions. Every 403 Forbidden and 500 Internal Server Error was a masterclass in the difference between permissions for a user, a Cloud Build service account, and a Cloud Run service account. I had to become the "adult in the room," refusing my AI partner's suggestions to use a "sledgehammer fix" (like granting broad admin access) just to make an error go away.

We also fought a brutal, multi-day battle with a silent bug that turned out to be a single, missing environment variable in a deployment, a mistake that cascaded into a series of misdiagnoses. And at one point, I did let the AI "help" clean the repo. It suggested rm -rf frontend/. I thought, "It can't mean that literally." Spoiler: it did.

Accomplishments that I'm proud of

I'm incredibly proud of building a complete, end-to-end, production-ready SaaS platform in just a few weeks. The "Magic Onboarding"—where a store owner can go from nothing to a fully-generated, AI-powered e-commerce site in under five minutes—is a huge accomplishment. But the feature I'm most proud of is the autonomous, proactive refill system. The fact that an AI agent, running on a schedule in the cloud, can analyze data, make a prediction, and initiate a natural, human-like conversation with a customer to secure a sale is the realization of my initial vision.

What we learned

This project was a deep dive into professional cloud architecture and the realities of building with AI. The key takeaway is that vibecoding doesn't replace judgment; it amplifies it.

• Be the Adult in the Room: AI pair programmers are incredible for accelerating development, but they lack context and a sense of consequence. I learned that the human developer must be the one who refuses insecure shortcuts, asks "why" before running a command, and takes ultimate responsibility for the architecture.
• Infrastructure is Code (and It's Not Portable): While my containerized app was theoretically portable, I learned that a project's true "Cloud DNA"—its IAM policies, event models, and secret management—is deeply fused with its platform. Abstracting this for multi-cloud requires intentional design from day one.
• The Power of a Clean Data Model: I learned this firsthand. Refactoring the database to use a dedicated, indexed zipCode field instead of a text search wasn't just a "best practice"—it was the difference between a slow, unscalable feature and a fast, professional one.
• Guardrails Matter: Building with powerful, pay-as-you-go services means you're one typo away from an infinite loop of API calls. I learned the critical importance of setting up billing alerts and usage triggers in both Google Cloud and Twilio as a non-negotiable safety net. Vibing responsibly is the new mantra.

What's next for reKibble

reKibble is more than just a hackathon project; it's a real tool for a real business. Our next steps are focused on our beta customer:

• Full Stripe Integration: Implement the "Premium Plan" to allow stores to accept online payments directly through the refill SMS, completing the convenience loop.
• Custom Domains: Implement custom domains for shop owners.
• Shopping Cart: Build a multi-item shopping cart for the storefront to handle larger orders.
• Growth: Onboard our first beta customer!

Built With

• artifact-registry
• cloud-build
• cloud-iam
• cloud-run
• cloud-scheduler
• express.js
• firebase-authentication
• firestore
• google-ai-platform
• google-maps
• javascript-(es6+)
• next.js
• node.js
• secret-manager
• vertex-ai-(gemini-2.5)