Voi: The Sleek Self-Hosted Feedback System Every Developer Needs

Tired of paying hefty subscriptions for customer feedback tools that hoard your data? Voi changes everything. This minimalist, self-hosted powerhouse gives you complete control over your customer feedback management without sacrificing modern developer experience. Built with cutting-edge technologies like Next.js 16 and TypeScript, Voi represents a new generation of tools that put developers and privacy first. In this deep dive, you'll discover why Voi is revolutionizing how teams collect, manage, and act on customer feedback—on their own terms.

Introduction: The Feedback Management Problem Nobody Talks About

SaaS feedback tools promise simplicity but deliver headaches. Monthly fees climb as your team grows. Your valuable customer data sits on someone else's servers. Customization? Forget about it—you're locked into their roadmap. Voi shatters these limitations with a radical approach: a minimalist, self-hosted customer feedback management system that you control completely.

Created by the innovative team at ⚡Sieutoc, Voi isn't just another open-source project—it's a statement. A statement that developers deserve beautiful, modern tools without the vendor lock-in. A statement that customer feedback management should be as sleek as the products you're building. This article unpacks everything you need to master Voi, from zero to production deployment. You'll get real code examples, pro tips for scaling, and a clear roadmap to liberating your feedback workflow.

What is Voi? The Minimalist Revolution in Feedback Management

Voi is a self-hosted customer feedback management system designed for developers who value simplicity, control, and modern tooling. At its core, Voi provides a clean, intuitive interface where your users can submit feedback, report bugs, and suggest features—while you maintain 100% ownership of the data and infrastructure.

The project emerged from a simple frustration: existing solutions were either too expensive, too bloated, or too restrictive. The team at Sieutoc built Voi to prove that minimalist design and powerful functionality aren't mutually exclusive. By leveraging Next.js 16's latest features, TypeScript's type safety, and a carefully curated tech stack, Voi delivers a premium experience without the premium price tag.

What makes Voi particularly compelling right now is the growing developer backlash against SaaS sprawl. Teams are reclaiming their infrastructure, prioritizing data privacy, and seeking tools that align with their workflows—not the other way around. Voi rides this wave perfectly, offering Docker-ready deployments, automated releases, and a development experience that feels like it was built in 2025, not 2015.

The system's architecture reflects modern best practices: App Router for optimal performance, Prisma for type-safe database interactions, and Better-Auth for secure email-based authentication. Every layer is intentional, every dependency justified. This isn't a kitchen-sink project—it's a precision instrument for feedback management.

Key Features: Why Voi Stands Out in a Crowded Field

Voi's feature set reads like a wishlist for developer-centric tools. Let's break down what makes this system exceptional:

Next.js 16 & TypeScript Foundation Voi builds on the latest Next.js 16 framework, delivering blazing-fast performance, server-side rendering, and API routes out of the box. TypeScript ensures type safety across the entire codebase, catching errors before they reach production. The combination provides an unmatched developer experience with hot reloading, intelligent code completion, and seamless refactoring.

PostgreSQL with Prisma ORM Data integrity matters. Voi uses PostgreSQL as its primary database—a battle-tested, production-ready solution that scales with your needs. Prisma ORM adds a layer of type-safe database access, eliminating raw SQL queries and preventing runtime errors. The schema is clean, migrations are automatic, and the developer experience is buttery smooth.

Better-Auth Email OTP Authentication Security doesn't have to be complicated. Voi integrates Better-Auth for passwordless email authentication via one-time passwords (OTPs). Users receive a magic link or code in their inbox—no passwords to remember, no credential stuffing attacks to worry about. It's modern, secure, and frictionless.

Shadcn UI with Tailwind CSS The interface is built with Shadcn UI components and styled using Tailwind CSS, creating a beautiful, accessible, and highly customizable design system. Every component is copy-paste friendly, meaning you can easily extend or modify the UI without fighting a rigid component library. The result is a clean, minimalist aesthetic that puts content first.

Automated Semantic Releases Version management is fully automated through semantic-release. Every commit to the master branch triggers an intelligent release process that analyzes Conventional Commits, generates changelogs, creates GitHub releases, and updates versions automatically. No more manual version bumping or forgotten release notes.

Docker-First Deployment Voi ships with production-ready Docker configurations. The multi-stage builds optimize for size and performance, while the provided docker-compose.yaml includes PostgreSQL and SMTP setup. Deploy to any cloud provider, your own servers, or platforms like Railway and Dokploy with minimal configuration.

Developer Experience Obsession From the pnpm ui:add helper scripts to the comprehensive environment variable setup, every detail prioritizes developer productivity. The project uses ESLint and Prettier for code quality, Husky for git hooks, and commitlint to enforce Conventional Commits. It's a joy to work with.

Real-World Use Cases: Where Voi Shines Brightest

1. The Privacy-Focused Startup Imagine you're building a healthcare or fintech product where data sovereignty is non-negotiable. Commercial feedback tools can't guarantee where your data resides or who accesses it. With Voi, you deploy on your own infrastructure—whether that's AWS, GCP, or an on-premise server. Customer feedback containing sensitive information never leaves your controlled environment, ensuring compliance with HIPAA, GDPR, or SOC 2 requirements.

2. The Bootstrapped SaaS Company You're watching every dollar while scaling to your first 1,000 users. Paying $500/month for feedback management feels like robbery. Voi eliminates this cost entirely. Host it on a $5/month VPS or even a free tier on Railway. The money saved goes directly into product development or marketing. Plus, as your team grows, you don't face per-seat pricing penalties.

3. The Digital Agency Managing Multiple Clients Agencies juggle feedback across dozens of client projects. Using separate SaaS accounts creates chaos and billing nightmares. With Voi, you deploy a dedicated instance per client, each with custom branding and isolated data. Your clients get a professional feedback portal that feels like a premium service, while you maintain centralized control and consistent workflows across all projects.

4. The Open Source Project Maintainers Community-driven projects need to collect feature requests and bug reports without forcing contributors onto proprietary platforms. Voi, being open source itself, aligns perfectly with these values. Deploy it on GitHub Pages, integrate with your existing GitHub workflow, and let your community vote on features transparently. The automated release system even mirrors your development practices.

Step-by-Step Installation & Setup Guide

Getting Voi running takes less than 15 minutes. Follow these precise steps for a flawless deployment.

Prerequisites

Before starting, ensure you have:

• Node.js 18+ and pnpm package manager
• Docker and Docker Compose for containerized deployment
• A PostgreSQL 16+ instance (or use the Docker setup)
• SMTP credentials for email authentication

Development Setup

1. Clone and Install Dependencies

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

2. Configure Environment Variables

Copy the example environment file and customize it:

cp .env.example .env

Edit .env with your settings:

# Core authentication secrets
BETTER_AUTH_SECRET=your-super-secret-jwt-key-min-32-chars
BETTER_AUTH_URL=http://localhost:3000
NEXT_PUBLIC_BASE_URL=http://localhost:3000

# PostgreSQL connection
DATABASE_URL=postgresql://user:password@localhost:5432/voi_db

# SMTP for email OTP
SMTP_USER=your-smtp-username
SMTP_PASSWORD=your-smtp-password
SMTP_HOST=smtp.yourdomain.com
SMTP_PORT=587
EMAIL_FROM=feedback@yourdomain.com

# Optional: Project branding
PROJECT_NAME=YourProduct Feedback

3. Start PostgreSQL with Docker

docker run -d \
  --name voi-postgres \
  -e POSTGRES_DB=voi_db \
  -e POSTGRES_USER=voi_user \
  -e POSTGRES_PASSWORD=your_secure_password \
  -p 5432:5432 \
  -v voi-data:/var/lib/postgresql/data \
  postgres:16-alpine

4. Run Prisma Migrations

With your database running, initialize the schema:

pnpm prisma migrate dev

5. Launch the Development Server

pnpm dev

Open http://localhost:3000 and you'll see Voi's clean interface ready for customization.

Production Deployment with Docker

For production, use the official Docker image:

# Create project directory
mkdir voi-production && cd voi-production

# Create docker-compose.yaml (see code examples section)
# Then deploy:
docker compose pull
docker compose up -d

Your Voi instance is now live at http://localhost (or your domain). Check logs with docker compose logs app to confirm startup.

REAL Code Examples from the Repository

Let's examine actual code snippets from Voi's documentation to understand its power and flexibility.

1. Production-Ready Docker Compose Configuration

This is the exact configuration used for deploying Voi in production environments:

# docker-compose.yaml
version: "3.8"
name: voi

services:
  postgres:
    container_name: voi-postgres
    image: postgres:16-alpine  # Lightweight, production-ready PostgreSQL
    restart: always  # Ensures database restarts on failure or reboot
    ports:
      - "5432:5432"  # Exposes PostgreSQL port (remove in production for security)
    volumes:
      - data:/var/lib/postgresql/data  # Persistent storage for data
    environment:
      POSTGRES_DB: postgresdb
      POSTGRES_USER: postgresuser
      POSTGRES_PASSWORD: yourpostgrespassword  # CHANGE THIS!

  app:
    container_name: voi-app
    image: ghcr.io/getsieutoc/voi:latest  # Official Voi image from GitHub Container Registry
    restart: always
    ports:
      - "80:3000"  # Maps container port 3000 to host port 80
    environment:
      # Authentication configuration
      BETTER_AUTH_SECRET: topsecret  # Generate with: openssl rand -base64 32
      BETTER_AUTH_URL: http://localhost  # Your domain in production
      
      # Database connection using Docker service name
      DATABASE_URL: postgres://postgresuser:yourpostgrespassword@postgres:5432/postgresdb
      
      # Email configuration for OTP authentication
      EMAIL_FROM: hi@yourdomain.com
      SMTP_USER: username
      SMTP_PASSWORD: password
      SMTP_HOST: smtp.yourdomain.com
      SMTP_PORT: 587  # Use 465 for SSL/TLS
      
      # Optional project customization
      PROJECT_NAME: Voi

volumes:
  data:  # Named volume for PostgreSQL persistence

Key Insights:

• The postgres service uses Alpine Linux for minimal attack surface
• The app service connects to PostgreSQL using the service name (postgres) as hostname
• Port mapping 80:3000 makes Voi accessible on standard HTTP port
• Environment variables separate configuration from code perfectly

2. Environment Variables Template

Voi's environment configuration demonstrates enterprise-grade security practices:

# .env.example - Copy to .env and customize

# Better Auth Configuration
# Generate a strong secret: openssl rand -base64 32
BETTER_AUTH_SECRET=topsecret

# Public URL where your app is accessible
# Must match your domain for cookie security
BETTER_AUTH_URL=https://yourdomain.com
NEXT_PUBLIC_BASE_URL=https://yourdomain.com

# PostgreSQL Connection String Format:
# postgres://USER:PASSWORD@HOST:PORT/DATABASE
DATABASE_URL=postgres://username:password@localhost:5432/voi_production

# SMTP Settings for Email OTP
# Any SMTP provider works: SendGrid, AWS SES, Mailgun, etc.
SMTP_USER=yoursmtpuser
SMTP_PASSWORD=yoursmtppass
SMTP_HOST=yoursmtpserver
SMTP_PORT=587  # or 465 for SSL

# Optional: Customize the from address
EMAIL_FROM=feedback@yourdomain.com

Security Best Practices:

• Never commit .env to version control (it's in .gitignore)
• Use strong, unique passwords for each environment
• Rotate BETTER_AUTH_SECRET regularly in production
• For SMTP, use environment-specific credentials

3. Conventional Commits for Automated Releases

Voi's release automation depends on properly formatted commit messages. Here's the exact specification:

# Commit Type Examples - These trigger automatic version bumps

# Feature addition (minor version: 0.1.0 → 0.2.0)
git commit -m "feat: add upvoting system for feedback posts"
git commit -m "feat(auth): implement social login with GitHub"

# Bug fix (patch version: 0.1.0 → 0.1.1)
git commit -m "fix: resolve dashboard loading spinner freeze"
git commit -m "fix(api): handle empty feedback descriptions gracefully"

# Performance improvement (patch version)
git commit -m "perf: lazy load feedback images to reduce initial bundle size"

# Breaking change (major version: 1.0.0 → 2.0.0)
git commit -m "feat!: redesign API endpoints with new authentication scheme"

# Alternative breaking change format
git commit -m "feat: remove legacy webhook endpoints

BREAKING CHANGE: All webhook integrations must migrate to new /api/v2/webhooks endpoint."

# Non-releasing changes (no version bump)
git commit -m "docs: update SMTP configuration guide"
git commit -m "chore: upgrade Prisma to v5.11.0"
git commit -m "style: format codebase with Prettier 3.0"
git commit -m "test: add unit tests for auth middleware"

Release Automation Magic: When you push to master, semantic-release analyzes these commits, determines the version bump, generates a changelog, creates a GitHub release, and publishes the Docker image automatically. No manual intervention needed.

4. Shadcn UI Component Management

Voi includes custom scripts to manage UI components efficiently:

# Add a new UI component from shadcn-ui
pnpm ui:add dialog  # Adds Dialog component with all dependencies

# Check for updates to existing components
pnpm ui:diff button  # Shows changes between your version and latest shadcn-ui

# Example workflow for customizing components
pnpm ui:add alert    # Adds Alert component to @/components/ui/alert.tsx
# Edit the component to match your design system
pnpm ui:diff alert   # Check if upstream has important updates

Why This Matters: Unlike traditional component libraries, shadcn-ui components become part of your codebase. You own them completely, can customize every detail, and aren't dependent on package updates. Voi's helper scripts make this workflow seamless.

5. Prisma Database Migration Command

Database schema management is critical. Voi uses Prisma's migration system:

# During development, after modifying schema.prisma
pnpm prisma migrate dev --name add_user_profile_fields

# This command:
# 1. Generates a new migration file in prisma/migrations/
# 2. Applies the migration to your development database
# 3. Updates Prisma Client types automatically
# 4. Seeds data if prisma/seed.ts exists

# For production deployments
pnpm prisma migrate deploy  # Applies pending migrations without generating new ones

# View database state
pnpm prisma studio  # Opens a web-based database browser on http://localhost:5555

Pro Tip: Always review generated migration files before committing. They should be in version control alongside your code.

Advanced Usage & Best Practices

Production Security Hardening

• Remove PostgreSQL port exposure in docker-compose.yaml (ports: - "5432:5432")
• Set BETTER_AUTH_SECRET to a 64-character random string
• Use a dedicated SMTP service like AWS SES or SendGrid for reliable email delivery
• Enable HTTPS with Let's Encrypt or your provider's SSL certificate
• Configure firewall rules to only expose ports 80 and 443

Scaling Strategies

• Deploy PostgreSQL on a managed service (RDS, Cloud SQL) for automatic backups
• Use Redis for session storage in multi-instance deployments
• Enable Next.js output: 'standalone' in next.config.js for smaller Docker images
• Set up CDN for static assets using Vercel or CloudFront
• Monitor with Prometheus and Grafana using custom metrics

Customization Patterns

• Extend the Prisma schema in schema.prisma to add custom fields
• Modify Tailwind config in tailwind.config.ts for brand colors
• Override shadcn-ui components in @/components/ui/ for unique styling
• Add new API routes in app/api/ directory following existing patterns
• Integrate with Slack/Discord webhooks for real-time feedback notifications

Backup and Recovery

• Schedule daily PostgreSQL dumps: pg_dump voi_production > backup.sql
• Store backups in S3 or equivalent with 30-day retention
• Test recovery procedures monthly on a staging environment
• Version-control your docker-compose.yaml and environment files securely

Comparison: Voi vs. The Competition

Why Voi Wins: For teams prioritizing data ownership, cost efficiency, and developer experience, Voi is unmatched. While GitHub Issues is free, it's not designed for customer feedback collection. Voi gives you the polished UX of Canny or Frill with the freedom of self-hosting and the modern stack developers love.

Frequently Asked Questions

Q: Is Voi stable enough for production use? A: The project is marked "Work in progress" but follows semantic versioning and automated testing. Many teams run it in production successfully. Start with a staging deployment, review the changelog for breaking changes, and keep backups. The automated release process ensures updates are predictable.

Q: Can I migrate existing feedback from Canny/UserVoice? A: Yes! Write a Prisma script to import data. The schema is straightforward: Users, Posts, Comments, and Votes. Export your data as JSON from your current tool, then map fields to Voi's schema. Community members have shared migration scripts for popular platforms.

Q: How do I handle authentication for my team vs. customers? A: Better-Auth supports multiple strategies. Configure email OTP for customers, then add GitHub OAuth or Google login for team members. You can implement role-based access control by extending the User model with a role field and protecting routes accordingly.

Q: What's the resource footprint for hosting? A: Voi is surprisingly lean. The Docker image is ~200MB. On a 1GB RAM VPS, you can comfortably handle thousands of monthly active users. PostgreSQL is the main resource consumer—monitor its memory usage and consider connection pooling with PgBouncer for high traffic.

Q: Can I customize the UI for my brand? A: Absolutely! Voi uses Tailwind CSS and shadcn-ui components. Modify tailwind.config.ts for colors, fonts, and spacing. Replace the logo in app/layout.tsx. Edit components in @/components/ui/ to match your design system. The codebase is your canvas.

Q: How do upgrades work with Docker? A: Upgrades are seamless: docker compose pull && docker compose up -d. The new image runs migrations automatically on startup. Always backup your database first. Check release notes for breaking changes that require manual intervention.

Q: Is there a managed hosting option if I don't want to self-host? A: The official demo runs on Railway.app, which offers one-click deployment. While Sieutoc doesn't provide managed hosting, community members offer deployment services. The Docker-first approach makes it trivial to deploy to any platform supporting containers.

Conclusion: Take Control of Your Feedback Loop Today

Voi represents more than just another open-source tool—it's a paradigm shift in how we think about customer feedback management. In a world where SaaS tools nickel-and-dime you for basic features and hold your data hostage, Voi hands you the keys to the kingdom. The minimalist design philosophy ensures you're not drowning in complexity, while the modern tech stack guarantees you can extend and customize without limits.

The real magic of Voi lies in its developer experience. From the moment you run pnpm install to your first production deployment, every interaction feels intentional. The automated release pipeline, type-safe database access, and component-driven architecture remove friction from your workflow, letting you focus on what matters: building products your customers love.

If you're ready to reclaim your feedback data, eliminate subscription fatigue, and deploy a solution that grows with your team, Voi is your answer. The setup takes minutes, the benefits last forever. Visit the official repository now, give it a star, and join the community of developers who've discovered that the best tools are the ones you control.

Your feedback management deserves better than a SaaS black box. It deserves Voi.

Ready to deploy? Head to https://github.com/getsieutoc/voi and start your self-hosted journey today.