Inspiration

Like a lot of builders, we kept running into the same painful wall: you pour weeks into shipping a product, deploy it... and then nothing. No users, no traffic, no visibility. The product works — but nobody knows it exists, and small businesses rarely have a marketing team or the budget to fix that.

We realised the hard part isn't building the software anymore — it's being seen. So we built Groville: an AI growth agent that does the growth work a small business can't afford to hire for, while keeping the owner fully in control.

What it does

Groville is an AI growth agent for Nigerian SMEs. It:

  • Reads your website (and Google Search Console data) and takes real screenshots of your pages the way a visitor sees them.
  • Finds the single biggest reason you're losing customers — unclear pricing, weak messaging, missing search visibility — and ranks the gaps.
  • Drafts the fix — an SEO article, social posts, or on-page changes.
  • Waits for your approval. Nothing is ever published automatically.
  • Executes the approved action, then measures and reports the real result — and learns from it for next time.

The core promise is honesty: Groville only drafts, the owner approves, and it never reports a number it didn't actually measure. It's a growth team you can trust, for businesses that could never afford one.

How we built it

  • Frontend: Next.js (App Router) + TypeScript + Tailwind CSS + shadcn/ui + Framer Motion — a landing page plus dashboard screens (Opportunities, Campaign Draft, Analysing, Results, Connections, Onboarding) in first-class dark and light themes, with a first-person, opportunity-first agent UX.
  • Backend: A Flask API with a Supabase (Postgres) database, cookie-session auth, and Redis + Celery for the heavy asynchronous jobs (website analysis, screenshotting, campaign generation).
  • Visual analysis (PixelRAG): headless Playwright Chromium captures full-page screenshots, tiles them into WebP, and a vision LLM scores the page against competitors.
  • AI layer: an OpenAI-compatible LLM pipeline (via OpenRouter) for text drafting, structured scoring, and the grounded editing of real files.
  • Connections: GitHub and Google Search Console integrations, plus a BMONI-powered payments/subscription flow for pricing.
  • The agent loop: analyze → opportunity → draft → owner approves → execute → measure → learn, with every executed step recorded as a real measurement and a learning.

What we learned

We learned that shipping is where the real engineering starts. Specifically:

  • Deployment is its own discipline — cold starts on free tiers, environment variables, cross-origin cookies, and worker/queue setup caused more bugs than the features themselves.
  • "Free" has hidden limits — token-per-minute caps, request quotas, and providers that reserve your whole balance up front. We learned to design around them instead of fighting them.
  • Debugging in production — reading logs, tracing 500s and 402s back to a single missing environment variable or an encryption-key mismatch.
  • Security-first defaults matter — row-level access, server-side-only API keys, and encrypted OAuth tokens.
  • Provider abstraction pays off — isolating the AI provider behind one swappable layer meant we could switch providers without rewriting the app.

Challenges we ran into

  • LLM provider limits: our first provider's free tier capped requests at a token-per-minute limit too small for real code edits. We migrated the whole pipeline to an OpenAI-compatible provider (OpenRouter) with a model fallback chain so a single model going down never breaks the app.
  • The "402 reservation trap": when a request omitted a max-tokens limit, the provider reserved a model's entire output window against our balance and rejected it. Our vision/analysis step kept failing until we bounded the token budget on every call — a fix that needed zero extra credits.
  • Unreliable structured output: free models ignored strict JSON schemas and returned malformed or truncated JSON. We switched to a simpler JSON mode plus tolerant parsing so the pipeline survives messy responses.
  • Memory-heavy screenshots: running headless Chromium to screenshot sites kept hitting memory limits on free hosting. We added memory-safe flags, WebP tiling, and a 3-image cap per analysis.
  • Database migration and auth: moving to Supabase/Postgres, and chasing down session-cookie 401s caused by mixing localhost and 127.0.0.1, plus connection endpoints that 500'd on missing OAuth credentials.
  • Holding the honesty line: it was tempting to fake impressive metrics or auto-publish for a flashier demo. We deliberately kept the guardrail — draft only, owner approves, never fabricate a result — because trust is the whole point.

Accomplishments that we're proud of

  • A working end-to-end agent loop — not a mockup — that analyses a real site, drafts a fix, and measures the result after approval.
  • 20+ early users on the live product.
  • 2nd place at the NACOS National BuildX Hackathon.
  • An honesty boundary enforced in code, not just promised in a pitch.

What's next for Groville

  • Meet SMEs where they are: WhatsApp notifications and local languages (Pidgin, Yoruba, Hausa, Igbo).
  • More channels and automation as the agent earns trust to do more — always within the honesty boundary.
  • A local data moat: the more Nigerian businesses Groville helps, the smarter it gets for that market specifically.

Built With

Share this project:

Updates

Submission history