How I Built Mavumium — Full Walkthrough Script
Before I wrote a single line of code, Mavumium existed as pages of handwriting.
A section-by-section script explaining the thought process, tech stack, tools, security, design, Google integrations, SEO and payments behind mavumium.com. Read it straight through for a video voiceover, or use each section on its own for a talk or article.
Section 1 — It started on paper
Before I wrote a single line of code, Mavumium existed as pages of handwriting.
I know that sounds old-fashioned for an AI product, but I've learned the hard way that if you can't draw your product on paper, you don't understand it yet. So I sat down and sketched the whole thing: what a business owner would upload, what their customer would ask, and what needed to come out the other side — an accurate answer, a PDF quotation, a captured lead.
On paper I answered the questions that actually shape a product:
- Who is this for? Businesses that sell on enquiry — suppliers, retailers, service providers — not just tech companies.
- What's the one moment that matters? A customer asks a question, and gets a correct answer with paperwork, in seconds.
- What must never happen? The AI making things up about someone's business.
Only once those boxes and arrows made sense did I open the laptop. Everything that follows was really just translating that paper plan into software, piece by piece.
Section 2 — Choosing the tech stack
My rule for the stack was simple: boring where possible, modern where it pays off. I'm one person shipping a real product — every choice had to reduce work, not create it.
Next.js 15 with React 19 and TypeScript. I wanted one framework for everything — the marketing site, the blog, the customer dashboard, the embeddable chat widget, and all the backend API routes. Next.js gives me server-side rendering for SEO, API routes for the backend, and the App Router to organise the site into clean route groups: public pages, the main product, and the widget each live in their own world. TypeScript was non-negotiable — when you're handling other businesses' pricing data, "it probably works" isn't good enough. The types catch mistakes before customers do.
Supabase for the database, auth and file storage. This was the biggest time-saver of the whole project. Postgres database, authentication, and storage buckets for uploaded catalogues and brand assets — one service, one dashboard. And crucially, it gives me Row-Level Security at the database layer, which I'll come back to in the security section.
OpenAI for the intelligence. The AI layer is built on a Retrieval-Augmented Generation pipeline — my own RAG implementation. Business data gets processed and indexed, and when a customer asks something, the system retrieves the relevant facts first and only then lets the model write an answer. The model provides the language; the business's own data provides the truth.
Tailwind CSS for styling. I stopped writing separate stylesheets years of frustration ago. Tailwind keeps the design consistent and lets me move fast without a design system fighting me.
Vercel for hosting and analytics. Push to Git, it deploys. That simplicity meant I could ship improvements daily instead of managing servers.
And for documents — the part customers actually hold in their hands — I used pdf-lib and jsPDF for generating branded PDF quotations, the docx library for Word output, and xlsx for reading the Excel price lists businesses upload. Emails run through Resend.
Section 3 — The tools and the workflow
My daily toolkit was deliberately small: VS Code, Git for version control with every feature on its own branch, and AI coding assistants as a pair programmer — which felt fitting, honestly, building an AI product with AI helping.
But the workflow mattered more than the tools. I kept the paper habit going the entire build. Every feature started as a written plan — what it does, what data it touches, what can go wrong — before it became code. When bugs appeared, I wrote SQL fix scripts and kept them in the repo, so the database's history is documented the same way the code is.
One habit I'd recommend to anyone: I tested as the customer, not as the developer. I'd log in as a fake business, upload a messy spreadsheet, ask the widget awkward questions, and try to break my own quotation engine. The bugs you find that way are the ones real users would have found first.
Section 4 — Security: designed in, not patched on
Mavumium holds other companies' price lists, catalogues and customer leads. That data being safe isn't a feature — it's the whole basis of trust. So security got designed in layers, from the database up.
Row-Level Security at the database. Every table carries policies that enforce tenant isolation at the Postgres level itself. One business can never read another business's rows — not because my application code checks, but because the database physically refuses. Even if I wrote a bug in the app layer, the data stays walled off.
JWT-based authentication. Sessions are managed through Supabase Auth with JSON Web Tokens verified on every request. Server-side code re-checks identity — the browser is never trusted to say who it is.
Input validation everywhere. Every form and API input passes through Zod schemas. Malformed data gets rejected at the door, before it touches business logic or the database.
Rate limiting on the AI endpoints. The chat widget is public-facing, so I built rate limiting to stop abuse and runaway costs — one visitor can't hammer the AI thousands of times on someone's dime.
Prompt-injection and sensitive-data defence. This one's specific to AI products and most people skip it. The widget filters for prompt-injection attempts — messages like "ignore all previous instructions" trying to hijack the assistant — and scans for sensitive patterns like card numbers, passwords and API keys so they never end up stored in conversation logs.
Secrets stay server-side. API keys, signing secrets and admin credentials live in environment variables and are only ever used in server code. The browser sees none of it.
Section 5 — Design: calm, fast, and installable
The design brief I wrote myself on paper was three words: calm, fast, credible. Business owners are the audience — they don't want flashy, they want trustworthy.
Typography does most of the heavy lifting. I paired Cormorant Garamond for headings — it gives the brand a settled, editorial feel — with Manrope for body text, clean and effortless to read. Both load through Next.js's font optimisation so there's no flash of unstyled text.
Everything is mobile-first, because the end customers of my customers are mostly on phones. And the widget had to be featherlight — it loads from a single line of JavaScript on someone else's website, so it cannot be the thing that slows their site down.
The design decision I'm most pleased with, though, is the Progressive Web App. Each business gets an installable app — their own icon, their own branding, added to a customer's home screen straight from the browser. No App Store, no downloads, and it launches from QR codes printed in physical stores. That one choice turned a website feature into something that works on shop shelves.
Section 6 — The Google connections
Google touches Mavumium in four distinct ways, and each one was a deliberate decision rather than an afterthought.
Google Search. The whole site is built to be understood by Google's crawler. Next.js generates a sitemap and robots file automatically from code, every page ships proper metadata, and I added JSON-LD structured data — Schema.org markup describing Mavumium as an organisation and software product — so Google sees meaning, not just text. The site is registered in Search Console, where I watch what's being indexed and which queries bring people in.
Google Fonts. Cormorant Garamond and Manrope both come from Google Fonts, served through Next.js's built-in optimisation for speed.
Google AdSense. The blog is a content arm of the business, and it's monetised with AdSense — which meant writing genuinely helpful articles, because AdSense approval and Google's helpful-content standards demand substance, not filler. That constraint honestly made the blog better.
Google Pay. Through the payment layer, customers can check out with Google Pay alongside cards and Apple Pay. One tap instead of typing card numbers — fewer abandoned checkouts.
Section 7 — SEO: built into the code, not sprinkled on top
Most people treat SEO as something you do after launch. I treated it as an architectural requirement from day one — it's the difference between hoping for traffic and engineering for it.
I wrote a central metadata builder in code — one function that every page calls to generate its title, description, canonical URL, Open Graph tags for social sharing, and Twitter card data. One source of truth means no page ever ships with missing or inconsistent tags. It's the kind of unglamorous plumbing that quietly compounds.
Then the content strategy. The blog runs on markdown files with frontmatter, rendered server-side — every article is plain, fast, crawlable HTML. And the articles aren't random: they're organised into clusters targeting the exact questions my customers type into Google. "AI customer support for HVAC businesses." "AI chat widgets for solar companies." Dozens of industry-specific pieces, each one a doorway into the product from a real search.
Server-side rendering ties it together. Because Next.js renders pages on the server, Google indexes complete content immediately — no waiting for JavaScript, no half-empty pages in the index.
Section 8 — Payments: Paddle, webhooks, and one billing hub
For payments I chose Paddle, and the reason was pragmatic: Paddle acts as the merchant of record. They handle VAT and sales tax across every country automatically. As a business selling globally, that removes an entire category of compliance headache I never wanted to own.
The integration has three parts:
Checkout. Paddle's overlay checkout opens right on the pricing page — cards, Apple Pay, Google Pay — and the customer never leaves the site.
Webhooks. When a payment succeeds, or a subscription renews, upgrades or gets cancelled, Paddle calls my API. Those webhook endpoints verify the event signature — so nobody can fake a "payment succeeded" message — and update the subscription records in Supabase. The customer's plan limits apply instantly, no manual steps.
A cross-domain billing hub. This was the most interesting engineering problem of the whole build. Mavumium has a companion platform on a separate subdomain, and I wanted one place to handle all billing. So mavumium.com acts as the central payment and identity hub: the other platform sends users over with HMAC-signed tokens, payment happens on the main site, and a signed verification API lets the other platform confirm a user's subscription status securely. Signed tokens, shared secrets, server-to-server verification — small-scale, but the same patterns big companies use.
Section 9 — Closing: paper to product
So that's the honest journey. A product sketched in a notebook, translated into Next.js and Supabase, secured with database-level isolation and layered defences, designed to feel calm and load fast, wired into Google for search, fonts, ads and payments, optimised for SEO at the architectural level, and monetised through Paddle with proper webhook-driven billing.
If I had to compress the whole build into three lessons:
One — plan on paper first. Every hour of sketching saved me days of rewriting.
Two — pick boring, proven technology and spend your creativity on the product. Next.js, Supabase and Paddle are not exciting choices. That's exactly why they were the right ones.
Three — build trust into the foundations. Security, accurate AI answers, honest billing — none of it is visible on a landing page, and all of it decides whether the product deserves to exist.
That's Mavumium — planned on paper, built with intent. Thanks for following along.
[End of script — approx. 12–15 minutes at a natural speaking pace. Each section also stands alone at 1–2 minutes if you're recording in parts.]
Editorial note
Written by the Mavumium editorial team, focused on AI automation, quotation workflows, product knowledge systems, and customer support operations for commercial businesses.
Frequently Asked Questions
What is AI automation for general?
It is the use of AI to handle repetitive enquiries, documents, or decision support so the team can respond faster and focus on higher-value work.
How does AI help general move faster?
It reduces the time spent searching documents, checking products, drafting quotes, and asking the same follow-up questions again and again.
What should the business prepare first?
Clean product data, current pricing, approved documents, clear escalation rules, and a simple customer workflow are the best starting point.
Should every enquiry be automated?
No. The strongest setup automates the repetitive first response and hands unusual, sensitive, or high-value cases to a human when needed.
iFeature Availability & Custom Development
Please note that some of the features mentioned in our articles may be available only upon request and are not guaranteed to be standard on all account plans. This information is provided for educational purposes regarding AI capabilities. However, all mentioned features can be custom-developed by the Mavumium team to suit your specific business requirements. Contact us to discuss a tailored solution for your organization.
Reference points
Ready to scale?
Automate your lead generation with Mavumium.
Join hundreds of businesses using AI to handle inquiries and close more deals.
Related Articles
AI Customer Support for Contractors
Learn how construction companies can use customer support automation to improve enquiries, quotes, and sales with Mavumium.
AI Customer Support for Engineers
Learn how engineering firms can use customer support automation to improve enquiries, quotes, and sales with Mavumium.
AI Customer Support for Equipment Suppliers
Learn how industrial equipment suppliers can use customer support automation to improve enquiries, quotes, and sales with Mavumium.
