I study e-commerce and growth marketing. I've never taken a computer science class. This week I opened a code editor on a real project for the first time, and there's now an autonomous agent running on Google Cloud that scans a product catalog every six hours, diagnoses compliance errors with Gemini, proposes fixes, and — this is the part I'm proud of — learns my brand rules when I reject its suggestions.
Here's the whole story, including the parts where everything broke.
The problem nobody in the room was solving
When the hackathon opened, I looked at what people were building: MLOps control centers, agent governance layers, dataset curation tools. Excellent projects, all of them. All built by engineers, for engineers.
I picked a different problem, because I'd lived it.
If you run e-commerce ads, you know this silent leak: Google Merchant Center quietly disapproves products. A missing GTIN. A 180-character title stuffed with keywords. A promo banner burned into a product photo. Each disapproved SKU stops serving on Shopping ads and free listings — and nobody notices, because your dashboards still show green ROAS on the products that are serving.
It's revenue evaporating with no alarm attached. Marketers discover it weeks later, in a spreadsheet, by accident.
That's the kind of pain engineers don't see, because they're not the ones staring at Merchant Center on Monday morning. It was my unfair advantage in this hackathon: I didn't need to research the problem. I needed to research how to build the solution.
What Feed Medic actually does
Five things, in a loop:
Scans autonomously. Cloud Scheduler fires every six hours. No one clicks anything. The agent works while I sleep — this was non-negotiable, because an agent you have to talk to is a chatbot, not an agent.
Diagnoses with Gemini 3.5 Flash. Each product is checked against Merchant Center rules: title length, GTIN validity, missing prices, empty descriptions.
Sees the images. A multimodal flow sends product photos to Gemini Vision to catch promotional text overlays — the -50% SOLDES badge burned into a packshot that Google will reject. Checking the image filename would have been the cheap trick. Actually looking at the image is the real feature.
Asks before acting. Nothing auto-publishes. Every fix lands in an approval queue with a confidence score and a plain-English explanation. Below its confidence threshold, the agent defers to me instead of inventing something. It refuses to guess.
Learns from my rejections. This is the one that matters. More below.
Every action is written to an audit log with a reasoning trace, so I can always answer "why did it do that?"
The feature I'd build again: an agent that learns your brand
Most feed tools apply generic Google rules. Fine — but Google's rules don't know that my brand never uses the word SOLDES in a title, or that I don't want anyone touching my GTIN fields.
So I built the loop:
- The agent proposes a fix. I reject it, and I say why — "never use promotional words like Promo or Soldes in my titles."
- A Genkit flow (learnBrandRule) turns that one-off complaint into a general, reusable rule, stored in Firestore.
- Every future diagnosis injects all learned rules into the prompt.
The first time I tested it end-to-end, I rejected exactly one fix on one product, then re-ran the diagnosis on two completely different products with the same error type. Both came back with clean titles — promotional words stripped, without me ever mentioning those products.
2 out of 2. I actually said "oh my god" out loud to an empty room.
That's the difference between a script and an agent. A script applies rules someone wrote. This one writes its own rules, from my feedback, and applies them going forward.
The three walls I hit, and what they taught me
I'm not going to pretend this was smooth. Here's what actually happened.
- My AI coding tool ran out of credits mid-build
I was coding with Cursor's free plan. Partway through building the diagnosis pipeline, premium models locked. Message: upgrade to Pro.
I tried everything to avoid paying: a second free trial (already used), the GitHub Student Pack (I'm on summer break — no longer eligible), plugging in my own API key (blocked on the free tier). I nearly switched IDEs entirely.
Then I did the math a founder would do: $20 to unblock a project I actually cared about, on a deadline I couldn't move. I paid, set a reminder to cancel after submission, and moved on.
Lesson: budget constraints are real, but at some point the cost of protecting a constraint exceeds the constraint itself.
- Gemini's free tier gave me 20 requests per day
This one nearly killed the project.
My agent needed to scan 50 products. The free tier quota on the model I'd chosen: 20 requests per day. Not 20 per minute. Per day. My scans died mid-catalog, every single run.
I tried everything a stubborn person tries. Two API keys with round-robin rotation. Batch sizes of two with 13-second pauses. Model fallback chains. Resume-safe caching. Every workaround worked slightly, and none of them solved the actual problem — I was fighting a quota designed to be a wall.The fix was strategic, not technical: I migrated from the AI Studio Developer API to Vertex AI. Same Gemini models, completely different billing path — Vertex bills your Google Cloud project, where my hackathon credits were sitting unused. Quotas: gone. Cost of scanning 50 products: a few cents.
Lesson: when you've tried five workarounds for the same wall, stop optimizing the workaround and go around the wall.
That migration is also why my README now says: no API-key free-tier roulette.
- My own security rules locked me out of my own app
Deployment stage. I wrote production Firestore rules (allow read, write: if false — nothing touches the database except my backend). Good practice. Except the local emulator loaded those same rules, and my dashboard went dark with a false for 'list' @ L8 error.
The fix was trivial once identified: separate rule files for dev and production. But here's what I want to point out — my dashboard didn't crash. It showed a clean red banner: "Database connection lost — check the Firestore emulator, then refresh."
I'd built that error state deliberately, during the reliability pass before deployment. Most hackathon projects hide their failure modes. I decided to show mine, because production-minded means handling the bad path, not pretending it doesn't exist. That decision paid me back the very first time something broke.
The stack (and why a non-developer could ship it)
- Gemini 3.5 Flash via Vertex AI — all diagnosis, vision, and rule-learning calls, authenticated with Application Default Credentials. Zero API keys in production.
- Genkit — three flows (diagnoseProduct, analyzeProductImage, learnBrandRule) with Zod-validated structured outputs. This mattered more than I expected: schema validation caught malformed model responses before they ever hit my database.
- Cloud Run — the Next.js dashboard and API routes, scale-to-zero.
- Cloud Scheduler — the six-hour heartbeat that makes it an agent instead of a tool.
- Firestore — four collections: products, fixes, brand_rules, agent_logs.
- Secret Manager — one secret, protecting the scan endpoint.
Total running cost: around €6–22/month.
And yes: I wrote this with AI-assisted coding, in Cursor. I'm saying that plainly because it's the point, not a confession. The hackathon's own page says "you don't need to be an AI researcher to participate." I took them at their word.
What I brought wasn't syntax. It was knowing which problem was worth solving, what the failure modes looked like from a marketer's chair, why the agent needed to ask permission before touching a live feed, and what number had to be on screen for someone to care. The AI wrote TypeScript. I made the product decisions — including the ones where I told it no.
Four things I'd tell myself at the start
- Pick a problem from your own life, not from a trend list. I never had to guess what mattered, because I'd felt it. That's worth more than technical firepower.
- Agents need gates, not autopilot. Nobody hands an AI write-access to the feed that pays their salary. Confidence scores, an approval queue, and an audit trail aren't friction — they're the thing that makes autonomy acceptable.
- Simulate the boring integration, ship the intelligence. I mocked the Merchant Center connector with a realistic JSON catalog matching the Content API's shape. Building live OAuth would have eaten most of the build window and demonstrated nothing about the agent. I labeled it honestly in the README and spent that time on the learning loop instead.
- Build the reset button before you need it. Once the features worked, I stopped adding and spent a full session on reliability: one command that returns the whole system to a clean demo state, with zero API calls. It let me rehearse the demo dozens of times without burning quota or nerves. Best time I spent on this project.
What's next
Feed Medic works. It's live, it's autonomous, and it learns. The obvious next steps are a real Merchant Center Content API integration, a Shopify app, and confidence-based routing so mechanical fixes auto-approve while brand-sensitive edits wait for a human.
Whether or not it places in the hackathon, I ended this build with something I didn't expect: proof that the gap between "I understand this problem deeply" and "I shipped software that solves it" is no longer measured in degrees.
If you're non-technical and you've been telling yourself you need to learn to code first — you needed to learn to build first. Those aren't the same thing anymore.
Live demo: https://feed-medic-dashboard-374954733454.europe-west1.run.app Code: https://github.com/orlane-create/feed-medic
Built solo for the Google All Things Agentic Hackathon. #AllThingsAgenticHackathon
Top comments (0)