Voi: The Revolutionary Self-Hosted Feedback Platform You Need

Tired of expensive SaaS feedback tools that hold your customer data hostage? Voi changes everything. This minimalist, open-source powerhouse gives you complete control over your feedback management pipeline. Built with cutting-edge Next.js technology and designed for lightning-fast deployment, Voi represents the future of customer-centric development.

In this deep dive, you'll discover why developers are abandoning cloud-based solutions for this sleek alternative. We'll explore real code examples, walk through Docker deployment, and reveal pro tips for scaling Voi in production environments. Whether you're a solo founder or enterprise team, this guide delivers everything you need to launch your self-hosted feedback system today.

What Is Voi? The Minimalist Feedback Management Revolution

Voi is a minimalist self-hosted customer feedback management system engineered by the innovative team at ⚡Sieutoc. Born from frustration with bloated, expensive feedback platforms, Voi strips away complexity while preserving enterprise-grade functionality. The project leverages Next.js 16 with App Router, TypeScript for type safety, and PostgreSQL with Prisma for robust data management.

What makes Voi genuinely revolutionary is its commitment to developer experience. The stack includes Shadcn UI paired with Tailwind CSS for beautiful, customizable interfaces without the bloat. Better-Auth handles secure email OTP authentication out of the box. Every commit follows Conventional Commits specification, triggering automated releases through semantic-release.

The platform is currently in active development with breaking changes expected, yet it's already production-ready for teams willing to move fast. The demo instance at voi.up.railway.app showcases its sleek interface and intuitive workflow. Unlike proprietary tools, Voi gives you complete data sovereignty—your customer feedback stays on your infrastructure, ensuring compliance with GDPR, HIPAA, and other regulatory requirements.

Key Features That Make Voi Stand Out

Next.js 16 with App Router delivers server-side rendering excellence and optimal performance. The App Router architecture enables nested layouts, instant loading states, and reduced JavaScript bundles. Your feedback portal loads in milliseconds, creating a seamless experience for customers.

TypeScript integration provides end-to-end type safety. From API routes to database queries, every layer of the application catches errors at compile-time. This eliminates runtime bugs and accelerates development velocity, especially critical when customizing the platform for specific use cases.

Shadcn UI + Tailwind CSS combination offers unprecedented design flexibility. Unlike component libraries with rigid styles, Shadcn UI provides copy-pasteable components you fully own. Tailwind's utility-first approach lets you craft unique brand experiences without writing custom CSS. The result? A feedback portal that looks like yours, not another generic template.

PostgreSQL with Prisma ORM forms the data backbone. Prisma's type-safe queries and automatic migrations eliminate database headaches. The schema is intuitive yet powerful, supporting complex feedback categorization, user management, and analytics. Real-time data access patterns ensure your team never waits for insights.

Better-Auth with Email OTP removes password friction. Customers submit feedback using secure one-time codes sent to their email. This authentication method boosts conversion rates while maintaining security standards. No more forgotten passwords or complex registration flows.

Automated Release Pipeline powered by semantic-release transforms deployment anxiety into confidence. Every conventional commit automatically versions the application, updates changelogs, and publishes Docker images to GitHub Container Registry. This means you always know what's deployed and can rollback instantly.

Real-World Use Cases Where Voi Dominates

SaaS Startups on a Budget: Early-stage companies waste $200+ monthly on feedback tools. Voi eliminates this cost entirely while providing superior data ownership. Deploy on a $5 VPS and scale horizontally as you grow. The Docker-based architecture ensures you can migrate between cloud providers without vendor lock-in.

Digital Agencies Managing Multiple Clients: Agencies juggle dozens of client feedback channels. With Voi, create isolated instances per client using the same codebase. Customize branding for each deployment while maintaining centralized update capabilities. The lightweight footprint means you can run 20+ client portals on a single server.

Enterprise Compliance Requirements: Financial and healthcare organizations face strict data residency laws. Voi's self-hosted nature guarantees customer feedback never leaves your controlled environment. Implement custom encryption, audit logging, and access controls to meet SOC 2, ISO 27001, or internal security mandates.

Open Source Projects Building Community: Public projects need transparent feedback mechanisms. Host Voi on your infrastructure to show community members exactly how their input is handled. The minimalist design keeps focus on feedback content, not flashy marketing features. Integrate with GitHub Issues via webhooks for seamless workflow automation.

Remote Product Teams: Distributed teams struggle with scattered feedback in Slack, email, and meetings. Voi centralizes everything into a single source of truth. The modern UI feels like a consumer app, driving adoption across technical and non-technical stakeholders. Real-time updates keep global teams synchronized.

Step-by-Step Installation & Setup Guide

Prerequisites Checklist

Before starting, ensure you have:

• PostgreSQL 16+ instance (local or cloud)
• SMTP credentials from providers like SendGrid, AWS SES, or Resend
• Node.js 18+ and pnpm package manager
• Docker and Docker Compose (for containerized deployment)

Normal Installation Method

First, clone the repository and install dependencies:

git clone https://github.com/getsieutoc/voi.git
cd voi
pnpm install

Configure your environment by copying the example file:

cp .env.example .env

Edit the .env file with your actual values:

BETTER_AUTH_SECRET=your-super-secret-jwt-key-minimum-32-chars
BETTER_AUTH_URL=https://feedback.yourdomain.com
NEXT_PUBLIC_BASE_URL=https://feedback.yourdomain.com
DATABASE_URL=postgres://user:password@host:5432/voi_db

SMTP_USER=apikey
SMTP_PASSWORD=your-sendgrid-api-key
SMTP_HOST=smtp.sendgrid.net
SMTP_PORT=587
EMAIL_FROM=feedback@yourdomain.com

Start the development server:

pnpm dev

In a new terminal, run Prisma migrations to set up your database schema:

pnpm prisma migrate dev

Open http://localhost:3000 to verify installation. The first user to register becomes the administrator.

Docker Deployment Method

Create a project folder and docker-compose.yaml file:

mkdir voi-feedback && cd voi-feedback
touch docker-compose.yaml

Populate the file with the configuration from the code examples section below. Then execute:

docker compose pull
docker compose up -d

Monitor logs to confirm successful startup:

docker compose logs app

Look for "http server started on :3000" message. Navigate to http://localhost to access your instance.

Real Code Examples from the Voi Repository

Environment Variables Configuration

The foundation of any Voi deployment starts with proper environment configuration. This example shows all required variables for production:

# Authentication secret - generate with: openssl rand -base64 32
BETTER_AUTH_SECRET=topsecret

# Public URLs for auth callbacks and CORS
BETTER_AUTH_URL=https://yourdomain.com
NEXT_PUBLIC_BASE_URL=https://yourdomain.com

# PostgreSQL connection string
DATABASE_URL=postgres://user:pass@localhost:5432/voi

# SMTP configuration for OTP emails
SMTP_USER=yoursmtpuser
SMTP_PASSWORD=yoursmtppass
SMTP_HOST=yoursmtpserver
SMTP_PORT=587

# Sender email address
EMAIL_FROM=hi@yourdomain.com

Key Insights: The BETTER_AUTH_SECRET must be cryptographically strong. Use OpenSSL to generate it. The DATABASE_URL follows PostgreSQL standard format. For SMTP, port 587 typically uses STARTTLS, while 465 is for SSL. Always use environment-specific variables—never commit secrets to version control.

Docker Compose Production Setup

This production-ready Docker Compose configuration includes PostgreSQL and the Voi application:

version: "3.8"
name: voi

services:
  postgres:
    container_name: voi-postgres
    image: postgres:16-alpine  # Alpine variant reduces image size by 80%
    restart: always
    ports:
      - "5432:5432"  # Expose for external tools; remove in production
    volumes:
      - data:/var/lib/postgresql/data  # Persistent storage
    environment:
      POSTGRES_DB: postgresdb
      POSTGRES_USER: postgresuser
      POSTGRES_PASSWORD: yourpostgrespassword  # CHANGE THIS!

  app:
    container_name: voi-app
    image: ghcr.io/getsieutoc/voi:latest  # Pull from GitHub Container Registry
    restart: always
    ports:
      - "80:3000"  # Map host port 80 to container port 3000
    environment:
      BETTER_AUTH_SECRET: topsecret  # Generate unique secret
      BETTER_AUTH_URL: http://localhost
      DATABASE_URL: postgres://postgresuser:yourpostgrespassword@db:5432/postgresdb
      EMAIL_FROM: hi@yourdomain.com
      SMTP_USER: username
      SMTP_PASSWORD: password
      SMTP_HOST: smtp.yourdomain.com
      SMTP_PORT: 587
      PROJECT_NAME: Voi  # Customizes UI branding

volumes:
  data:  # Named volume for database persistence

Key Insights: The restart: always policy ensures automatic recovery after server reboots. Using postgres:16-alpine slashes resource usage. The DATABASE_URL uses the service name db as hostname—Docker's internal DNS resolution. For production, remove the PostgreSQL ports mapping and use an external managed database.

Prisma Database Migration Workflow

Voi uses Prisma for schema management. This command sequence initializes your database:

# Ensure dev server is running to access database
pnpm dev

# In another terminal, apply pending migrations
pnpm prisma migrate dev

# Optional: Seed initial data if you have a seed.ts file
pnpm prisma db seed

# Generate Prisma Client with latest schema
pnpm prisma generate

Key Insights: The migrate dev command creates a new migration file in prisma/migrations/. Always review these files before committing. For production, use pnpm prisma migrate deploy instead—it applies pending migrations without creating new ones. The generate step updates the TypeScript types, enabling full type safety in your application code.

Conventional Commits for Automated Releases

Voi's release pipeline depends on properly formatted commit messages. Here are production-ready examples:

# Triggers minor version bump (0.1.0 → 0.2.0)
git commit -m "feat: add upvoting functionality to feedback posts"

# Triggers patch version bump (0.1.0 → 0.1.1)
git commit -m "fix: resolve race condition in OTP validation"

# Triggers major version bump (1.0.0 → 2.0.0)
git commit -m "feat!: remove legacy API endpoints

BREAKING CHANGE: All v1 API endpoints removed. Migrate to v2 endpoints."

# No release triggered
git commit -m "docs: update SMTP configuration examples"
git commit -m "chore: upgrade Next.js to version 16.2.0"

Key Insights: The exclamation mark (!) after the type signals breaking changes concisely. The footer format is more explicit and supports detailed migration notes. Husky hooks validate commit messages locally, preventing malformed commits. This automation eliminates manual versioning errors and maintains a clean, predictable changelog.

Shadcn UI Component Management

Voi streamlines UI development with custom helper scripts for Shadcn UI:

# Add a new UI component (e.g., data-table)
pnpm ui:add data-table

# Check for upstream updates to a specific component
pnpm ui:diff alert-dialog

# Sync all components to latest versions
pnpm ui:diff

Key Insights: The ui:add script wraps npx shadcn-ui@latest add, ensuring version consistency. ui:diff compares your local components against the upstream registry, highlighting updates. This pattern prevents component drift and makes updating Shadcn UI painless. Since components are copied into your codebase, you retain full customization control—unlike traditional npm packages.

Advanced Usage & Best Practices

Horizontal Scaling: Deploy Voi behind a load balancer with multiple app containers. Use Redis for session storage to enable sticky sessions. Configure BETTER_AUTH_SECRET identically across all instances. PostgreSQL connection pooling with PgBouncer prevents connection exhaustion under heavy load.

Security Hardening: Enable Row Level Security (RLS) in PostgreSQL to enforce data isolation. Use Cloudflare Access or Tailscale for internal deployments. Implement rate limiting at the reverse proxy level (Nginx/Traefik) to prevent OTP spam. Regularly rotate BETTER_AUTH_SECRET using a secrets manager like HashiCorp Vault.

Monitoring & Observability: Integrate Voi with your existing monitoring stack. The Next.js App Router natively supports OpenTelemetry. Export metrics to Prometheus via custom API routes. Set up alerts for failed OTP deliveries, database connection errors, and high response times. Use structured logging with Pino for actionable log analysis.

Backup Strategy: Automate daily PostgreSQL dumps with pg_dump and store them in S3-compatible storage. Test restores monthly. For point-in-time recovery, enable WAL archiving. Backup uploaded files (if any) separately using rclone or similar tools. Document your disaster recovery runbook.

Customization Without Forking: Leverage Next.js's modular architecture. Create custom themes by extending Tailwind config. Add new feedback categories by modifying the Prisma schema and running migrations. Build custom analytics dashboards using tRPC endpoints. This approach lets you upgrade Voi without merge conflicts.

Voi vs. Alternatives: Why Self-Hosting Wins

Why Voi Dominates: While SaaS options like Canny and Frill offer convenience, they create critical dependencies. Your customer data lives on their servers. Your roadmap is held hostage by their pricing tiers. Voi flips this model—host on a $5 VPS and scale infinitely. The modern Next.js stack attracts top developer talent, making customization enjoyable rather than painful. Unlike Fider's aging Go codebase, Voi's TypeScript ecosystem integrates seamlessly with modern development workflows.

Frequently Asked Questions

What exactly is Voi? Voi is an open-source, self-hosted customer feedback management system. It lets you collect, organize, and prioritize customer feedback on your own infrastructure using a modern Next.js 16 stack.

How much does Voi cost to run? The software is 100% free. Hosting costs start at $5/month for a VPS. SMTP providers like SendGrid offer free tiers for 100 emails/day. For most startups, total monthly cost remains under $10.

Is Voi stable enough for production? Yes! The project uses automated testing and semantic releases. While marked as work-in-progress, many teams run Voi in production. The key is pinning to specific Docker versions and testing upgrades in staging first.

How do I update Voi to the latest version? For Docker deployments, update the image tag in docker-compose.yaml and run docker compose pull && docker compose up -d. For source installations, pull latest changes and run pnpm install && pnpm prisma migrate deploy.

Can I customize Voi's appearance? Absolutely! The Shadcn UI + Tailwind CSS stack makes theming trivial. Modify tailwind.config.ts for colors, fonts, and spacing. All components live in your codebase—no build steps required.

Which SMTP providers work with Voi? Any SMTP-compatible service works: SendGrid, AWS SES, Resend, Mailgun, or even Gmail. The key is using the correct port (587 for STARTTLS, 465 for SSL) and authentication method.

How do I backup my Voi data? Backup the PostgreSQL database using pg_dump and store the output securely. If you modified uploaded assets, backup those directories too. Test restores regularly to ensure disaster recovery readiness.

Conclusion: Take Control of Your Customer Feedback Today

Voi represents a paradigm shift in feedback management. By combining modern developer ergonomics with self-hosted freedom, it delivers enterprise capabilities without enterprise baggage. The automated release pipeline, type-safe codebase, and Docker-first deployment make it a joy to operate.

The minimalist philosophy ensures you get exactly what you need—nothing more, nothing less. Your customers get a fast, beautiful feedback experience. Your team gets complete data ownership and unlimited customization potential. Your finance department gets to cancel yet another SaaS subscription.

Ready to revolutionize how you collect customer insights? Deploy Voi in the next 30 minutes using the Docker Compose example above. The active development community at getsieutoc welcomes contributions and feedback. Star the repository, join the journey, and own your roadmap.

Deploy Voi now: https://github.com/getsieutoc/voi