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

> Centralize customer feedback. Prioritize feature requests.

- Site: https://savio.io
- Category: Product Feedback Management & Prioritization SaaS
- Platforms: Web app, Browser extension
- Verdict: **Solid side project** (68/100 vibecodeable)
- Estimated effort: 2-3 weeks of part-time building

## Verdict

You can build a functional internal feedback vault and prioritization dashboard in a couple of weeks, but maintaining all the CRM and support desk OAuth integrations will consume ongoing developer hours.

Savio is fundamentally a specialized CRM for product feedback with a heavy integration footprint. The core CRUD workflows, tagging, filtering by customer MRR, and roadmapping UI are straightforward to generate with AI assistants in a Next.js and Postgres stack. However, the real engineering grind lies in building and maintaining bi-directional webhook sync workers and OAuth credential management for Intercom, HubSpot, Zendesk, and Jira. If you scope down your clone to rely on CSV imports, API keys, and manual logging rather than live OAuth syncs for every support tool, you can build a highly usable personal tool in under three weeks.

### What you can't replicate

- Official maintenance-free native integrations with Intercom, Salesforce, and HubSpot
- An existing user base of customer-facing teams actively logging live data

## What it does

B2B SaaS product feedback management and feature request tracking platform that bridges the gap between customer-facing teams and product managers.

### Core features

- Centralized feedback inbox supporting manual entry, email forwarding, and Slack ingestion
- Feature request grouping and merging from unstructured verbatims
- Customer telemetry enrichment (MRR, plan tier, lifecycle stage)
- Multi-dimensional filtering and prioritization based on business metrics
- Internal product roadmapping with status mapping
- Public/private voting board with SSO options
- Close-the-loop broadcast emails to requesters
- Dev tool sync (Jira/Shortcut status mappings)

## The business

### Pricing

- Essential: $39/mo — For small teams starting with feedback tracking
- Professional: $79/mo — For larger teams needing customer segmentation and integrations
- Business: $249/mo — For teams needing full CRM integrations and multiple products

### Funding

$160,000 raised.
- Seed
Investors: TinySeed

Founded 2019.
Team size: 3.

## The hard parts

- Maintaining robust, authenticated real-time API integrations and OAuth sync workers with fast-moving external SaaS platforms (HubSpot, Intercom, Salesforce, Zendesk)
- Normalizing unstructured customer support text into clean relational models without data duplication
- Complex relational SQL queries for multi-attribute filtering across company telemetry and feedback items
- Building a reliable Chrome extension for capturing highlight-and-send feedback directly from third-party web apps

## How to vibe code Savio

### Prerequisites

- Node.js (free): Required runtime for executing the Next.js full-stack application and package manager.
- GitHub (free): Source code repository and deployment pipeline integration with Vercel.
- Cursor (Free tier / $20/mo Pro): AI-native code editor used to scaffold and iterate on the Next.js application codebase.

### Recommended AI tools

- Cursor: Essential for rapid full-stack iteration, database schema management, and UI component styling.
- Claude Code: Useful in the terminal for executing complex multi-file refactors and generating database migration scripts.

### Stack

- Frontend: Next.js (App Router, Tailwind CSS, shadcn/ui)
- Backend: Next.js Server Actions & API Routes
- Database: Neon (Serverless Postgres)
- Auth: better-auth
- Payments: None (Personal use clone)
- Other: Resend for transactional close-the-loop notification emails, PostHog for product telemetry and usage tracking

### Hosting

- Vercel (Hosting the Next.js frontend and serverless API endpoints): $0/mo (Hobby Tier)
- Neon (Hosting the serverless Postgres relational database): $0/mo (Free Tier)

### Build guide

1. **Project Scaffolding & Database Schema** — Initialize the Next.js application with Tailwind CSS, shadcn/ui, and set up the Neon Postgres database schema for accounts, customers, feedback verbatims, feature requests, and roadmaps.

```
Scaffold a new Next.js 16 application using App Router, TypeScript, Tailwind CSS, and standard directory structure. Configure Drizzle ORM to connect with Neon Postgres. Create the initial database schema supporting the following tables: 'accounts' (id, name, mrr, plan_tier, lifecycle_stage), 'feedback_items' (id, account_id, verbatim_text, source, author_email, created_at), 'feature_requests' (id, title, description, status, product_area, created_at), 'feedback_mappings' (id, feedback_id, feature_request_id), and 'roadmaps' (id, title, description, feature_id, target_quarter). Ensure proper foreign key constraints, indexes on account MRR and feature request statuses, and run initial migrations.
```

2. **Authentication & Team User Roles** — Implement authentication using better-auth with support for multi-tenant workspace roles (Admin, Manager, Contributor, Viewer).

```
Install and configure better-auth in the Next.js application with email/password authentication backed by the Neon Postgres database. Implement user roles ('owner', 'admin', 'manager', 'contributor', 'viewer') following Savio's permission model where managers and admins have write access while contributors and viewers have scoped view/logging permissions. Build a clean login and signup page layout using Tailwind CSS and shadcn/ui components.
```

3. **Feedback Inbox & Ingestion API** — Build the Feedback Inbox interface and an inbound webhook/API endpoint to ingest customer feedback verbatims and associate them with customer accounts.

```
Create a secure API endpoint (/api/v1/feedback) that accepts incoming JSON payloads containing customer feedback verbatims, account telemetry (MRR, plan tier, account name), and source metadata. Automatically match or create account records in the database and insert the feedback into an unassigned 'Feedback Inbox' queue. Build a React dashboard page displaying the Feedback Inbox with filtering by source and date, allowing users to select individual verbatims and assign them to existing Feature Requests or create new ones on the fly.
```

4. **Feature Request Prioritization & Segmentation Dashboard** — Develop the core prioritization engine and UI allowing product managers to sort and filter feature requests by aggregated customer MRR, plan tier, and request count.

```
Build the Feature Request prioritization dashboard page in Next.js. Create a server-side query and UI table that aggregates feature requests, showing total linked feedback count, total unique accounts, and cumulative MRR from associated accounts. Implement multi-dimensional filtering controls in the sidebar allowing users to filter feature requests by plan tier (e.g., Enterprise, Pro, SMB), customer lifecycle stage (Active, Churned, Prospect), and minimum account MRR threshold. Ensure responsive table sorting by MRR and request volume.
```

5. **Roadmap Builder & Voting Board** — Implement the internal product roadmap view and a customer-facing public voting board with status tracking.

```
Build a kanban-style Product Roadmap view where feature requests can be dragged or assigned to status columns ('Backlog', 'Planned', 'In Progress', 'Shipped'). Create a public voting board page (/board) where external users or internal colleagues can view public feature requests, vote on them, and submit new feedback verbatims directly. Add a toggle in the admin settings to hide vote counts or display features in alphabetical order to avoid popularity bias.
```

6. **Close-the-Loop Email Broadcasting & Polish** — Integrate Resend to allow product managers to broadcast personalized 'feature shipped' notification emails to all customers who requested a specific feature.

```
Integrate Resend SDK into the Next.js backend. Create a 'Close the Loop' feature action on shipped feature requests that compiles a list of unique requester emails from all linked feedback items. Build an email composition modal allowing product managers to write a personalized update message, preview recipient counts, and dispatch batch notification emails asynchronously via server actions with error handling and delivery status logging.
```

### Cost vs paying

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

- Cursor Pro subscription: $20
- Custom domain name (optional): $12/yr
- Total: ~$32 one-time

**Ongoing costs (monthly):**

- Vercel Hosting (Hobby): $0
- Neon Postgres (Free tier): $0
- Resend Email API (Free tier up to 3k emails): $0
- Total: $0/mo

- Paying for the SaaS instead: $39/mo to $249/mo (Essential to Business tiers)
- Build time: 25-35 hours
- AI tool credits: $20 (1 month of Cursor Pro)
- Break-even: Immediate (Free tier infrastructure)

## Sources

- [Savio Official Website & Pricing](https://savio.io)
- [PitchBook Profile - Savio.io](https://pitchbook.com/profiles/company/199042-49)