Skip to content
Klutch.sh Docs

Deploying a Fider App

Introduction

Fider is a powerful open-source customer feedback platform that helps teams collect, organize, and prioritize product feedback from users. Built for product teams and SaaS companies, Fider provides an intuitive interface for users to submit ideas, vote on features, and engage with your product roadmap. With built-in moderation tools, custom branding options, and seamless integrations, Fider makes it easy to build products that customers love.

Fider stands out for its:

  • User-Friendly Interface: Clean, modern design that encourages user participation
  • Voting System: Democratic feature prioritization through user votes
  • Custom Branding: Full customization to match your brand identity
  • Multi-Tenant Support: Manage multiple feedback boards from a single instance
  • Privacy-Focused: Self-hosted solution with complete data ownership
  • Rich Moderation Tools: Comprehensive admin controls for managing feedback
  • API Access: RESTful API for custom integrations and automation
  • SSO Support: Integration with popular authentication providers
  • Responsive Design: Works seamlessly across desktop and mobile devices

This comprehensive guide walks you through deploying Fider on Klutch.sh using Docker, including detailed installation steps, sample configurations, persistent storage setup, and production-ready best practices for running a scalable feedback platform.

Prerequisites

Before you begin, ensure you have the following:

  • A Klutch.sh account
  • A GitHub account with a repository for your Fider project
  • Docker installed locally for testing (optional but recommended)
  • Basic understanding of Docker and customer feedback platforms
  • A PostgreSQL database (can be deployed separately or use an external provider)

Installation and Setup

Step 1: Create Your Project Directory

First, create a new directory for your Fider deployment project:

Terminal window
mkdir fider-klutch
cd fider-klutch
git init

Step 2: Create the Dockerfile

Create a Dockerfile in your project root directory. This will define your Fider container configuration:

FROM getfider/fider:stable


# Expose the default Fider port
EXPOSE 3000


# Set working directory
WORKDIR /app


# Fider will be configured via environment variables

Note: This Dockerfile uses the official Fider stable image. Fider requires a PostgreSQL database connection which will be configured via environment variables.

Step 3: Advanced Dockerfile with Custom Configuration

For a production-ready setup with additional customizations:

FROM getfider/fider:stable


# Set working directory
WORKDIR /app


# Create directories for persistent storage
RUN mkdir -p /app/storage /app/uploads


# Expose Fider port
EXPOSE 3000


# Set default environment variables (override these in Klutch.sh dashboard)
ENV GO_ENV=production
ENV PORT=3000


# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
  CMD wget --quiet --tries=1 --spider http://localhost:3000/ || exit 1


# The official image already has the entrypoint configured

Step 4: Create Environment Configuration

Create a .env.example file to document the required environment variables:

Terminal window
# Database Configuration (Required)
DATABASE_URL=postgres://username:password@hostname:5432/fider?sslmode=disable


# Base URL (Required)
BASE_URL=https://example-app.klutch.sh


# JWT Secret (Required - Generate a secure random string)
JWT_SECRET=your-secure-jwt-secret-here-min-64-chars


# Email Configuration (Required for notifications)
EMAIL_SMTP_HOST=smtp.example.com
EMAIL_SMTP_PORT=587
EMAIL_SMTP_USERNAME=your-smtp-username
EMAIL_SMTP_PASSWORD=your-smtp-password
EMAIL_NOREPLY=noreply@example.com


# Optional: Email Whitelist (comma-separated email addresses)
# EMAIL_WHITELIST=user1@example.com,user2@example.com


# Optional: Custom Storage
# BLOB_STORAGE=s3
# AWS_REGION=us-east-1
# AWS_ACCESS_KEY_ID=your-access-key
# AWS_SECRET_ACCESS_KEY=your-secret-key
# AWS_S3_BUCKET_NAME=your-bucket-name


# Optional: OAuth Providers
# OAUTH_GOOGLE_CLIENTID=your-google-client-id
# OAUTH_GOOGLE_SECRET=your-google-secret
# OAUTH_GITHUB_CLIENTID=your-github-client-id
# OAUTH_GITHUB_SECRET=your-github-secret


# Optional: SSL (not needed on Klutch.sh, handled by platform)
# SSL_CERT=/path/to/cert.pem
# SSL_KEY=/path/to/key.pem


# Optional: Custom Port (default is 3000)
PORT=3000


# Environment
GO_ENV=production

Security Note: Never commit actual passwords, secrets, or API keys to your repository. Use environment variables in Klutch.sh dashboard for all sensitive data.

Step 5: Create a docker-compose.yml for Local Development

For local testing with PostgreSQL, create a docker-compose.yml:

version: '3.8'


services:
  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_USER: fider
      POSTGRES_PASSWORD: fider_password
      POSTGRES_DB: fider
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"


  fider:
    build: .
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: postgres://fider:fider_password@postgres:5432/fider?sslmode=disable
      BASE_URL: http://localhost:3000
      JWT_SECRET: this-is-a-test-secret-change-in-production-min-64-characters-long
      EMAIL_SMTP_HOST: smtp.mailtrap.io
      EMAIL_SMTP_PORT: 587
      EMAIL_SMTP_USERNAME: your-test-username
      EMAIL_SMTP_PASSWORD: your-test-password
      EMAIL_NOREPLY: noreply@localhost
      GO_ENV: development
    depends_on:
      - postgres


volumes:
  postgres_data:

Note: This docker-compose.yml is for local development only. Klutch.sh does not support Docker Compose for deployment.

Step 6: Test Locally (Optional)

Before deploying to Klutch.sh, you can test your Fider setup locally:

Terminal window
# Build the Docker image
docker build -t my-fider .


# Run with docker-compose (includes PostgreSQL)
docker-compose up -d


# View logs
docker-compose logs -f fider


# Access Fider at http://localhost:3000


# Stop and remove the test containers when done
docker-compose down

Alternatively, test with just the Fider container (if you have an external database):

Terminal window
# Build the Docker image
docker build -t my-fider .


# Run the container
docker run -d \
  --name fider-test \
  -p 3000:3000 \
  -e DATABASE_URL="postgres://user:pass@hostname:5432/fider?sslmode=disable" \
  -e BASE_URL="http://localhost:3000" \
  -e JWT_SECRET="your-secure-jwt-secret-min-64-chars" \
  -e GO_ENV="production" \
  my-fider


# View logs
docker logs -f fider-test


# Stop and remove when done
docker stop fider-test
docker rm fider-test

Step 7: Create Documentation

Create a README.md file with setup instructions:

# Fider Feedback Platform Deployment


This repository contains the Docker configuration for deploying Fider on Klutch.sh.


## Quick Start


1. Deploy a PostgreSQL database (separately on Klutch.sh or use a managed service)
2. Set all required environment variables in Klutch.sh dashboard
3. Push this repository to GitHub
4. Deploy on Klutch.sh


## Required Environment Variables


- `DATABASE_URL`: PostgreSQL connection string
- `BASE_URL`: Your Fider deployment URL (e.g., https://feedback.example.com)
- `JWT_SECRET`: Secure random string (minimum 64 characters)
- `EMAIL_SMTP_HOST`, `EMAIL_SMTP_PORT`, `EMAIL_SMTP_USERNAME`, `EMAIL_SMTP_PASSWORD`: SMTP configuration
- `EMAIL_NOREPLY`: No-reply email address


## First-Time Setup


On first launch, Fider will:
1. Initialize the database schema
2. Show a setup wizard
3. Ask you to create the first admin account
4. Allow you to configure your feedback board


## Documentation


- Fider Documentation: https://fider.io/docs
- Klutch.sh Documentation: https://docs.klutch.sh

Step 8: Push to GitHub

Commit your Dockerfile and configuration files to your GitHub repository:

Terminal window
git add Dockerfile .env.example docker-compose.yml README.md
git commit -m "Add Fider Dockerfile and configuration"
git remote add origin https://github.com/yourusername/fider-klutch.git
git push -u origin main

Setting Up PostgreSQL Database

Fider requires a PostgreSQL database. You have several options:

Option 1: Deploy PostgreSQL on Klutch.sh

  1. Follow the PostgreSQL deployment guide to create a separate PostgreSQL instance
  2. Note the connection details (host, port, username, password, database name)
  3. When using TCP traffic on Klutch.sh, external connections are made to port 8000, which routes to the internal port you specify in your PostgreSQL deployment
  4. Configure your DATABASE_URL environment variable accordingly

Example connection string for Klutch.sh PostgreSQL (external connection to port 8000):

DATABASE_URL=postgres://username:password@postgres-app.klutch.sh:8000/fider?sslmode=disable

Option 2: Use a Managed PostgreSQL Service

Use a managed database provider like:

Get the connection string from your provider and use it in the DATABASE_URL environment variable.

Deploying to Klutch.sh

Now that your Fider project is ready and pushed to GitHub, follow these steps to deploy it on Klutch.sh with persistent storage.

Deployment Steps

    1. Log in to Klutch.sh

      Navigate to klutch.sh/app and sign in to your account.

    2. Create a New Project

      Go to Create Project and give your project a meaningful name (e.g., “Fider Feedback Platform”).

    3. Create a New App

      Navigate to Create App and configure the following settings:

    4. Select Your Repository

      • Choose GitHub as your Git source
      • Select the repository containing your Dockerfile
      • Choose the branch you want to deploy (usually main or master)

      Note: Klutch.sh will automatically detect the Dockerfile in your repository root and use it for deployment.

    5. Configure Traffic Type

      • Traffic Type: Select HTTP (Fider serves a web interface via HTTP)
      • Internal Port: Set to 3000 (the default port that Fider listens on inside the container)

    6. Set Environment Variables

      Add the following required environment variables for your Fider configuration:

      Required:

      • DATABASE_URL: PostgreSQL connection string (e.g., postgres://user:password@hostname:5432/fider?sslmode=disable)
      • BASE_URL: Your Fider deployment URL (e.g., https://example-app.klutch.sh)
      • JWT_SECRET: A secure random string of at least 64 characters (generate using: openssl rand -base64 64)
      • GO_ENV: Set to production

      Email Configuration (Required for notifications):

      • EMAIL_SMTP_HOST: Your SMTP server hostname
      • EMAIL_SMTP_PORT: SMTP port (typically 587 for TLS)
      • EMAIL_SMTP_USERNAME: SMTP username
      • EMAIL_SMTP_PASSWORD: SMTP password
      • EMAIL_NOREPLY: No-reply email address (e.g., noreply@yourdomain.com)

      Optional:

      • EMAIL_WHITELIST: Comma-separated list of allowed email addresses for signup
      • OAUTH_GOOGLE_CLIENTID and OAUTH_GOOGLE_SECRET: For Google OAuth
      • OAUTH_GITHUB_CLIENTID and OAUTH_GITHUB_SECRET: For GitHub OAuth

      Security Note: Always use strong, unique passwords and secrets for production deployments. Use a password manager or secure secret generator.

    7. Attach a Persistent Volume (Optional)

      If you want to store uploaded files locally (instead of using S3), attach a persistent volume:

      • In the Volumes section, click “Add Volume”
      • Mount Path: Enter /app/storage (this is where Fider stores uploaded files)
      • Size: Choose an appropriate size based on expected uploads (e.g., 5GB for small sites, 20GB+ for high-traffic sites)

      Note: For production deployments, it’s recommended to use S3-compatible storage for uploads instead of local volumes.

    8. Configure Additional Settings

      • Region: Select the region closest to your users for optimal latency
      • Compute Resources: Choose CPU and memory based on your traffic (minimum 512MB RAM recommended)
      • Instances: Start with 1 instance (you can scale up later as traffic grows)

    9. Deploy Your Application

      Click “Create” to start the deployment. Klutch.sh will:

      • Automatically detect your Dockerfile in the repository root
      • Build the Docker image using Nixpacks
      • Attach any configured persistent volumes
      • Start your Fider container
      • Assign a URL for external access

    10. Complete Initial Setup

      Once deployment is complete, you’ll receive a URL like example-app.klutch.sh. Navigate to this URL in your browser to complete the Fider setup:

      https://example-app.klutch.sh

      On first launch, Fider will:

      1. Initialize the database schema automatically
      2. Show a setup wizard
      3. Ask you to create the first admin account
      4. Allow you to configure your feedback board name and settings

Post-Deployment Configuration

After your Fider instance is deployed and the initial setup is complete, configure these important settings:

Branding and Customization

  1. Log in to your Fider dashboard at https://example-app.klutch.sh
  2. Navigate to Administration → Settings → General
  3. Configure:
    • Site Title: Your feedback board name
    • Welcome Message: Custom message for visitors
    • Logo: Upload your company logo
    • Favicon: Upload a custom favicon
    • Custom CSS: Add custom styles to match your brand

User Authentication

Configure authentication methods in Administration → Settings → Authentication:

  1. Email/Password: Enabled by default
  2. Single Sign-On (SSO): Configure OAuth providers
    • Google OAuth (if configured)
    • GitHub OAuth (if configured)
    • Custom OAuth providers
  3. Email Whitelist: Restrict signups to specific email addresses

Privacy and Visibility

In Administration → Settings → Privacy:

  1. Public Access: Choose whether non-authenticated users can view feedback
  2. Allow Signups: Enable or disable new user registrations
  3. Invite Only Mode: Require invitations for new users
  4. Private Mode: Make the entire board private

Email Templates

Customize email templates in Administration → Settings → Email Templates:

  • New post notifications
  • Status change notifications
  • Comment notifications
  • Invitation emails

Environment Variables Reference

Complete list of Fider environment variables you can configure in Klutch.sh:

VariableDescriptionRequiredDefault
DATABASE_URLPostgreSQL connection stringYesNone
BASE_URLPublic URL of your Fider instanceYesNone
JWT_SECRETSecret key for JWT tokens (min 64 chars)YesNone
GO_ENVApplication environmentYesproduction
PORTPort for Fider serverNo3000
EMAIL_SMTP_HOSTSMTP server hostnameYesNone
EMAIL_SMTP_PORTSMTP server portYesNone
EMAIL_SMTP_USERNAMESMTP usernameYesNone
EMAIL_SMTP_PASSWORDSMTP passwordYesNone
EMAIL_NOREPLYNo-reply email addressYesNone
EMAIL_WHITELISTAllowed email addresses (comma-separated)NoNone
BLOB_STORAGEStorage backend (s3 or fs)Nofs
AWS_REGIONAWS region for S3 storageNoNone
AWS_ACCESS_KEY_IDAWS access keyNoNone
AWS_SECRET_ACCESS_KEYAWS secret keyNoNone
AWS_S3_BUCKET_NAMES3 bucket nameNoNone
OAUTH_GOOGLE_CLIENTIDGoogle OAuth client IDNoNone
OAUTH_GOOGLE_SECRETGoogle OAuth secretNoNone
OAUTH_GITHUB_CLIENTIDGitHub OAuth client IDNoNone
OAUTH_GITHUB_SECRETGitHub OAuth secretNoNone

Using S3 Storage for Uploads

For production deployments, it’s recommended to use S3-compatible storage for file uploads:

Step 1: Create an S3 Bucket

Create a bucket with your preferred S3-compatible provider:

Step 2: Configure Environment Variables

Add these environment variables in Klutch.sh:

Terminal window
BLOB_STORAGE=s3
AWS_REGION=us-east-1
AWS_ACCESS_KEY_ID=your-access-key-id
AWS_SECRET_ACCESS_KEY=your-secret-access-key
AWS_S3_BUCKET_NAME=your-bucket-name

Step 3: Configure Bucket Permissions

Ensure your S3 bucket has appropriate CORS and public access policies for Fider to function correctly.

Configuring OAuth Authentication

Enhance user experience by enabling OAuth authentication:

Google OAuth

  1. Go to Google Cloud Console
  2. Create a new OAuth 2.0 Client ID
  3. Add authorized redirect URIs:
    • https://example-app.klutch.sh/oauth/google/callback
  4. Add environment variables in Klutch.sh: 
    OAUTH_GOOGLE_CLIENTID=your-client-id
    OAUTH_GOOGLE_SECRET=your-client-secret

GitHub OAuth

  1. Go to GitHub Developer Settings
  2. Create a new OAuth App
  3. Set authorization callback URL:
    • https://example-app.klutch.sh/oauth/github/callback
  4. Add environment variables in Klutch.sh: 
    OAUTH_GITHUB_CLIENTID=your-client-id
    OAUTH_GITHUB_SECRET=your-client-secret

Production Best Practices

Security Recommendations

  • Strong Secrets: Use a password manager to generate strong, random secrets for JWT_SECRET
  • Environment Variables: Store all sensitive credentials as environment variables in Klutch.sh, never in your Dockerfile or code
  • HTTPS Only: Klutch.sh provides HTTPS by default; ensure you access Fider only via HTTPS
  • Regular Backups: Implement a backup strategy for your PostgreSQL database using snapshots or automated backups
  • Update Regularly: Keep Fider updated to the latest stable version for security patches and new features
  • Database Security: Use strong database passwords and restrict access to your PostgreSQL instance
  • Email Whitelist: In production, consider using EMAIL_WHITELIST to restrict signups to trusted email addresses
  • Private Mode: Consider enabling private mode if your feedback board is for internal use only

Performance Optimization

  • Database Indexing: Ensure proper PostgreSQL indexes are in place (Fider creates these automatically)
  • Connection Pooling: PostgreSQL connection pooling is handled by Fider automatically
  • CDN Integration: Consider using a CDN for static assets to improve loading times globally
  • Caching: Fider includes built-in caching mechanisms
  • Resource Allocation: Monitor your application and increase compute resources if response times slow down
  • Database Performance: Monitor PostgreSQL performance and scale the database instance if needed

Monitoring and Maintenance

Monitor your Fider deployment for:

  • Response Times: Ensure the dashboard loads quickly
  • Database Performance: Watch for slow queries or connection issues
  • Database Size: Monitor database growth and implement archival strategies
  • Memory Usage: Fider should use minimal memory, but monitor for memory leaks
  • Uptime: Use external monitoring services to alert you if Fider goes down
  • Error Rates: Review application logs for errors or exceptions
  • Email Deliverability: Ensure notification emails are being delivered successfully

Data Management

  • Regular Backups: Create regular backups of your PostgreSQL database
  • Database Maintenance: Perform routine PostgreSQL maintenance (VACUUM, ANALYZE)
  • Storage Monitoring: If using local storage, monitor volume usage
  • Archival Strategy: Consider archiving old, completed feedback items
  • Export Capabilities: Fider supports data export; regularly export important feedback data

Customization for Nixpacks

If you need to customize Fider’s build or runtime behavior on Klutch.sh, use Nixpacks environment variables:

To change the start command:

Terminal window
NIXPACKS_START_CMD=/app/fider

To add build-time packages:

Terminal window
NIXPACKS_PKGS=postgresql-client ca-certificates

To set build-time environment variables:

Terminal window
NIXPACKS_BUILD_ENV=GO_ENV=production

Troubleshooting

Cannot Access Fider Dashboard

  • Verify your app is running in the Klutch.sh dashboard
  • Check that the internal port is set to 3000
  • Ensure HTTP traffic type is selected
  • Review application logs for startup errors
  • Verify the BASE_URL environment variable matches your actual URL

Database Connection Errors

  • Verify the DATABASE_URL format is correct
  • Check that the PostgreSQL database is accessible
  • Ensure the database user has appropriate permissions
  • Test the database connection independently
  • Check for SSL mode issues (use ?sslmode=disable if needed)
  • Verify the database exists and is initialized

Email Notifications Not Working

  • Verify all SMTP environment variables are set correctly
  • Test your SMTP credentials with a third-party tool
  • Check SMTP port (587 for TLS, 465 for SSL)
  • Ensure your SMTP provider allows connections from Klutch.sh
  • Check application logs for email-related errors
  • Verify the EMAIL_NOREPLY address is valid

OAuth Authentication Fails

  • Verify OAuth client ID and secret are correct
  • Check that redirect URIs match exactly (including protocol)
  • Ensure OAuth apps are properly configured in provider settings
  • Check that BASE_URL is set correctly
  • Review application logs for OAuth error messages

File Upload Issues

  • If using local storage, verify the persistent volume is attached
  • Check volume has sufficient space and proper permissions
  • If using S3, verify AWS credentials are correct
  • Ensure S3 bucket exists and has proper CORS configuration
  • Check bucket permissions allow read/write access

Performance Issues

  • Monitor CPU and memory usage in Klutch.sh dashboard
  • Check PostgreSQL query performance
  • Consider increasing compute resources
  • Review database indexes and query patterns
  • Monitor network latency to database
  • Consider implementing S3 storage for uploads

Setup Wizard Not Appearing

  • Clear browser cache and cookies
  • Verify database is properly initialized
  • Check application logs for initialization errors
  • Ensure DATABASE_URL is correctly configured
  • Try accessing directly: https://example-app.klutch.sh/signup

Upgrading Fider

To upgrade Fider to a new version:

Method 1: Update Dockerfile

  1. Update the version tag in your Dockerfile:

    FROM getfider/fider:v0.23.0

  2. Commit and push the changes to GitHub:

    Terminal window
    git add Dockerfile
    git commit -m "Upgrade Fider to version 0.23.0"
    git push

  3. Klutch.sh will automatically rebuild and redeploy your application

  4. Your data will be preserved in the PostgreSQL database

Method 2: Use Latest Stable

To always use the latest stable version, keep the stable tag:

FROM getfider/fider:stable

This will automatically pull the latest stable release on each rebuild.

Pre-Upgrade Checklist

  • ✅ Backup your PostgreSQL database
  • ✅ Review Fider changelog for breaking changes
  • ✅ Test the upgrade in a development environment first
  • ✅ Notify users of scheduled maintenance window
  • ✅ Monitor application logs after upgrade

Advanced Configuration

Custom Domain

To use a custom domain with your Fider deployment:

  1. Follow the Klutch.sh custom domains guide
  2. Update the BASE_URL environment variable to your custom domain
  3. Update OAuth redirect URIs if using OAuth authentication

Webhooks and Integrations

Fider supports webhooks for external integrations:

  1. Navigate to Administration → Settings → Webhooks
  2. Add webhook URLs for events:
    • New post created
    • Post status changed
    • New comment added
  3. Use webhooks to integrate with:
    • Slack or Discord notifications
    • Project management tools
    • Custom automation workflows

API Access

Fider provides a REST API for programmatic access:

  1. Generate an API key in Administration → Settings → API Keys

  2. Use the API key in your requests:

    Terminal window
    curl -H "Authorization: Bearer YOUR_API_KEY" \
      https://example-app.klutch.sh/api/v1/posts

  3. Available endpoints:

    • /api/v1/posts - List all posts
    • /api/v1/posts/:number - Get specific post
    • /api/v1/posts/:number/comments - Get comments
    • /api/v1/posts/:number/votes - Manage votes

Multi-Tenancy

To run multiple Fider instances for different teams or products:

  1. Deploy separate Fider applications on Klutch.sh
  2. Use separate PostgreSQL databases for each instance
  3. Configure unique BASE_URL for each instance
  4. Share resources or keep them isolated based on needs

Additional Resources

Conclusion

Deploying Fider to Klutch.sh with Docker provides a powerful, self-hosted feedback platform with complete data ownership and easy scalability. By following this guide, you’ve set up a production-ready Fider instance with proper database connectivity, security configurations, email notifications, and optional S3 storage. Your feedback platform is now ready to help you collect valuable user insights, prioritize feature development, and build products that truly resonate with your customers.

With Fider running on Klutch.sh, you have the flexibility to customize the platform to your exact needs, integrate with your existing tools via webhooks and API, and maintain full control over your user feedback data. As your user base grows, you can easily scale your deployment by adjusting compute resources and optimizing your database configuration.