# How to Vibe Code Your Own Proofling (and Stop Paying for It)

> The AI agent that collects testimonials & video reviews while you sleep

- Site: https://proofling.com
- Category: SaaS / Marketing Automation
- Platforms: Web app
- Verdict: **Solid side project** (78/100 vibecodeable)
- Estimated effort: 2-3 weeks part-time

## Verdict

You can build a functional personal clone of Proofling in a couple of weeks, but email deliverability and video processing edge cases will test your patience.

Proofling is a classic micro-SaaS with a well-scoped core loop: listen for a webhook, schedule a delayed email, collect a text/video review via a public token link, store explicit consent metadata, and render a wall of proof. Because this is for personal use, you can skip Stripe billing entirely and manually seed customer lists or hook up your own test Stripe keys. The real engineering hurdles are not the CRUD dashboard or the wall embeds—they are setting up bulletproof transactional email delivery (SPF/DKIM) so reminder threads land in inboxes, and handling browser-side video recording uploads with server-side Whisper transcription without blowing up serverless timeouts.

### What you can't replicate

- The original maker's existing distribution and early adopter community
- The exact domain authority and SEO footprint

## What it does

Automated testimonial and video review collection agent for SaaS founders. Connects to payments or manual lists, triggers timed email requests, handles a single polite follow-up, captures consent with metadata, keeps negative feedback private, and publishes approved proofs to a hosted Wall of Proof or embeds.

### Core features

- Stripe webhook integration for automatic trigger detection on payment or upgrade events
- Delayed email scheduling and single-retry follow-up sequence engine
- Public-facing link-only response form supporting text and video recording with auto-captions
- Consent logging (capturing IP, user agent, approved text metadata)
- Private inbox isolation for negative or unapproved feedback
- One-tap moderation workflow (pending / approved states)
- Hosted Wall of Proof rendering and iframe/script website embeds
- AI-readable static export generation (proof.json and proof.md)

## The business

### Pricing

- Free: $0
- Founding Pro Monthly: $16/mo
- Founding Pro Yearly: $192/yr

Founded 2026.
Team size: Solo developer.

## The hard parts

- Email deliverability and reputation protection (SPF/DKIM/DMARC configuration to avoid spam folders)
- Durable background queue scheduling for precise time-delayed requests and follow-ups
- Video recording capture, browser-side chunk encoding, storage management, and automated captioning

## How to vibe code Proofling

### Prerequisites

- Node.js (free): Runtime environment for the Next.js full-stack framework.
- GitHub (free): Code repository and deployment source for Vercel.
- Resend Account (Free tier (3k emails/mo)): Transactional email API for sending testimonial requests and follow-ups.

### Recommended AI tools

- Claude Code: Primary agentic coding agent for multi-file scaffolding, database schemas, and API route implementation.
- Cursor: IDE for reviewing diffs, fixing UI layout bugs, and refining Tailwind CSS components.

### Stack

- Frontend: Next.js (App Router) with Tailwind CSS and shadcn/ui
- Backend: Next.js Server Actions and API Routes with Inngest for durable background queues
- Database: Neon (Serverless Postgres) with Drizzle ORM
- Auth: better-auth for self-hosted secure email/password workspace access
- Payments: Skipped for personal use (or test mode Stripe)
- Other: Resend for transactional emails, OpenAI API (Whisper) for video review auto-captions, UploadThing for video and attachment file storage

### Hosting

- Vercel (Hosting Next.js frontend, serverless API routes, and cron scheduling.): $0/mo (Hobby Tier)
- Neon (Storing relational data, customer records, reviews, and consent logs.): $0/mo (Free Tier)

### Build guide

1. **Scaffold Project, Database Schema, and Auth** — Initialize the Next.js project with Tailwind CSS, set up Drizzle ORM connected to Neon Postgres, and configure better-auth for single-user workspace access.

```
Create a new Next.js project with Tailwind CSS and TypeScript. Set up Drizzle ORM with Neon serverless postgres connection. Define database schemas for users, workspaces, customers, testimonial_requests (storing status: pending, sent, reminder_sent, replied, closed), reviews (storing quote, rating, author_name, author_title, author_company, video_url, is_private, is_approved, consent_ip, consent_userAgent, createdAt), and embed_tokens. Integrate better-auth with email/password authentication and ensure database migrations run successfully. Create a clean dashboard shell layout with sidebar navigation for Campaigns, Inquiries, Wall of Proof, and Settings.
```

2. **Customer Import & Stripe Webhook Ingestion** — Build CSV/manual customer list insertion and an optional Stripe webhook listener to automatically create customer records and schedule testimonial request triggers.

```
Build a customer management module in Next.js. Implement a manual form and a CSV upload parser to add customers (name, email, product name, metadata). Create an API endpoint `/api/webhooks/stripe` that listens for `checkout.session.completed` or `customer.subscription.updated` events, securely verifies signatures, extracts customer details, and inserts them into the database. Upon successful customer creation, trigger a scheduling function that calculates the configured delay (e.g., 3 days after payment) and queues the initial testimonial request email job.
```

3. **Email Sequencing Engine with Inngest** — Implement durable background jobs using Inngest to send timed testimonial requests via Resend and handle the single gentle follow-up reminder.

```
Integrate Inngest into the Next.js project to handle durable background workflows for testimonial requests. Create a background function that triggers after the user-defined delay, checks if the customer has already replied, renders a personalized email template using Resend, and sends the ask. If the customer does not reply within 4 days, queue a second Inngest step to send the single polite reminder thread, then close the sequence. Ensure all emails include clear opt-out language and local time formatting logic.
```

4. **Public Token-Gated Review Submission Page** — Create a clean, distraction-free public web form accessible via secure tokens where customers can submit text quotes or record guided video reviews.

```
Build a public response page at `/review/[token]` that does not require authentication. The page should render a clean, minimalist layout displaying the founder's brand/product name, a personalized greeting, and prompt questions (e.g. 'What changed after using the product?'). Provide inputs for rating, star display, text review, and a video recording component using browser MediaRecorder API. When submitted, capture the client's IP address and user agent for consent metadata, upload any recorded video to UploadThing storage, save the review record as pending, and display a polite thank-you state.
```

5. **Video Transcription & Moderation Inbox** — Process uploaded video reviews with OpenAI Whisper for auto-captions and build a one-tap moderation dashboard for reviewing pending responses.

```
Build an automated background worker that picks up newly uploaded video reviews, sends the audio stream to the OpenAI Whisper API to generate transcripts and captions, and saves them to the review record. Create a moderation inbox dashboard in the app (`/dashboard/inquiries`) displaying pending responses. Show customer context, payment match verification badges, consent logs (IP and user agent), and review content. Add 'Approve & Publish', 'Keep Private', and 'Delete' actions that update the database state instantly.
```

6. **Wall of Proof, Embed Widgets, and AI Exports** — Build a hosted public Wall of Proof page, script/iframe embed widgets for external websites, and JSON/Markdown export generators.

```
Build a public hosted Wall of Proof page at `/wall/[workspaceSlug]` that renders all approved reviews in clean testimonial cards with verified buyer badges. Create an embed widget generator that provides an HTML snippet `<script>` or iframe loading approved reviews dynamically on external sites. Finally, build API endpoints `/api/proof.json` and `/api/proof.md` that output structured, machine-readable collections of all approved customer testimonials for AI crawlers and assistants.
```

### Cost vs paying

**Starting costs (one-time):**

- Custom domain (optional): $12/yr
- Total: ~$12 one-time

**Ongoing costs (monthly):**

- Vercel Hobby & Neon Free DB: $0/mo
- Resend (Free Tier up to 3k emails): $0/mo
- OpenAI Whisper & UploadThing API usage: ~$2-5/mo
- Total: ~$3-5/mo

- Paying for the SaaS instead: $16 - $24/mo
- Build time: 25-35 hours
- AI tool credits: $20 (Claude Pro / Cursor subscription)
- Break-even: 1 month

## Sources

- [Proofling Official Website](https://proofling.com)
- [Proofling Pricing Page](https://proofling.com/pricing)
- [Startup Fame - Proofling Profile](https://startupfa.me/p/proofling.com)