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
localhostand127.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
- celery
- flask
- framer-motion
- github-api
- google-search-console
- next.js
- openai
- openrouter
- playwright
- postgresql
- python
- react
- redis
- render
- rest-api
- shadcn-ui
- supabase
- typescript
- vercel