Deploying Input

Introduction

Input is a privacy-focused, no-code, open-source form builder designed for simplicity and brand consistency. Created as a self-hostable alternative to tools like Typeform, Input allows you to create beautiful, conversational forms and surveys that match your brand identity - all while keeping your data on your own infrastructure.

Built with Laravel and Vue.js, Input provides an intuitive drag-and-drop interface for creating forms, along with powerful features for customizing appearance, collecting responses, and analyzing results. The application is designed to be lightweight and easy to deploy while offering professional-grade functionality.

Key highlights of Input:

• No-Code Builder: Create forms with an intuitive drag-and-drop interface
• Conversational Forms: One question at a time for better user experience
• Brand Customization: Match your brand with custom colors, logos, and themes
• Multiple Question Types: Text, multiple choice, ratings, file uploads, and more
• Logic Jumps: Create dynamic forms that adapt to responses
• Response Collection: Gather and manage form submissions
• Analytics: View response statistics and completion rates
• Webhooks: Send responses to external services
• API Access: Integrate forms programmatically
• Self-Hosted Privacy: Your data stays on your infrastructure
• Mobile Friendly: Responsive design works on all devices
• Open Source: MIT licensed and community-driven

This guide walks through deploying Input on Klutch.sh using Docker, setting up your own professional form builder.

Why Deploy Input on Klutch.sh

Deploying Input on Klutch.sh provides several advantages for form creation:

Simplified Deployment: Klutch.sh automatically detects your Dockerfile and builds Input without complex server configuration. Push to GitHub and your form builder deploys automatically.

Persistent Storage: Attach persistent volumes for your database and uploads. Your forms and responses survive container restarts.

HTTPS by Default: Klutch.sh provides automatic SSL certificates, ensuring secure form submissions and data collection.

GitHub Integration: Connect your configuration repository directly from GitHub. Updates trigger automatic redeployments.

Privacy: Keep all form responses on infrastructure you control, not shared with third-party services.

Custom Domains: Assign a custom domain for professional, branded form URLs.

Cost Effective: Avoid per-response fees common with commercial form services.

Prerequisites

Before deploying Input on Klutch.sh, ensure you have:

• A Klutch.sh account
• A GitHub account with a repository for your Input configuration
• Basic familiarity with Docker and containerization concepts
• A MySQL/MariaDB database (can be deployed separately)
• (Optional) SMTP server for email notifications

Understanding Input Architecture

Input is built on a modern Laravel stack:

Laravel Backend: PHP-based application handling form logic, data storage, and API.

Vue.js Frontend: Reactive user interface for form building and response viewing.

MySQL Database: Stores forms, questions, responses, and user data.

File Storage: Uploaded files can be stored locally or in S3-compatible storage.

Preparing Your Repository

To deploy Input on Klutch.sh, create a GitHub repository containing your Dockerfile.

Repository Structure

input-deploy/
├── Dockerfile
├── .env.example
└── .dockerignore

Creating the Dockerfile

Create a Dockerfile in the root of your repository:

FROM ghcr.io/deck9/input:main

# Set environment variables
ENV APP_ENV=production
ENV APP_DEBUG=false
ENV APP_KEY=${APP_KEY}
ENV APP_URL=${APP_URL}

# Database configuration
ENV DB_CONNECTION=mysql
ENV DB_HOST=${DB_HOST}
ENV DB_PORT=${DB_PORT:-3306}
ENV DB_DATABASE=${DB_DATABASE}
ENV DB_USERNAME=${DB_USERNAME}
ENV DB_PASSWORD=${DB_PASSWORD}

# Mail configuration (optional)
ENV MAIL_MAILER=${MAIL_MAILER:-smtp}
ENV MAIL_HOST=${MAIL_HOST:-}
ENV MAIL_PORT=${MAIL_PORT:-587}
ENV MAIL_USERNAME=${MAIL_USERNAME:-}
ENV MAIL_PASSWORD=${MAIL_PASSWORD:-}
ENV MAIL_FROM_ADDRESS=${MAIL_FROM_ADDRESS:-}

# Session and cache
ENV SESSION_DRIVER=database
ENV CACHE_DRIVER=database

# Create storage directories
RUN mkdir -p /var/www/html/storage/app/public \
    /var/www/html/storage/framework/cache \
    /var/www/html/storage/framework/sessions \
    /var/www/html/storage/framework/views \
    /var/www/html/storage/logs

# Set permissions
RUN chown -R www-data:www-data /var/www/html/storage /var/www/html/bootstrap/cache

# Expose port
EXPOSE 8080

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

# Volumes
VOLUME ["/var/www/html/storage"]

Alternative Build from Source

For building from source:

FROM php:8.2-apache

# Install dependencies
RUN apt-get update && apt-get install -y \
    git \
    curl \
    libpng-dev \
    libonig-dev \
    libxml2-dev \
    libzip-dev \
    zip \
    unzip \
    nodejs \
    npm \
    && rm -rf /var/lib/apt/lists/*

# Install PHP extensions
RUN docker-php-ext-install pdo_mysql mbstring exif pcntl bcmath gd zip

# Install Composer
COPY --from=composer:latest /usr/bin/composer /usr/bin/composer

# Clone Input
WORKDIR /var/www/html
RUN git clone https://github.com/deck9/input.git .

# Install PHP dependencies
RUN composer install --no-dev --optimize-autoloader

# Install and build frontend
RUN npm ci && npm run build

# Configure Apache
RUN a2enmod rewrite
RUN echo '<Directory /var/www/html/public>\n\
    AllowOverride All\n\
    Require all granted\n\
</Directory>' > /etc/apache2/conf-available/input.conf \
    && a2enconf input

# Set document root
ENV APACHE_DOCUMENT_ROOT /var/www/html/public
RUN sed -ri -e 's!/var/www/html!${APACHE_DOCUMENT_ROOT}!g' /etc/apache2/sites-available/*.conf

# Set permissions
RUN chown -R www-data:www-data /var/www/html

EXPOSE 80

HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
  CMD wget --no-verbose --tries=1 --spider http://localhost:80/ || exit 1

Environment Variables Reference

Variable	Required	Default	Description
APP_KEY	Yes	-	Laravel encryption key (base64:…)
APP_URL	Yes	-	Full URL of your Input installation
DB_HOST	Yes	-	MySQL hostname
DB_PORT	No	3306	MySQL port
DB_DATABASE	Yes	-	Database name
DB_USERNAME	Yes	-	Database username
DB_PASSWORD	Yes	-	Database password
MAIL_HOST	No	-	SMTP server for notifications
MAIL_PORT	No	587	SMTP port
MAIL_USERNAME	No	-	SMTP username
MAIL_PASSWORD	No	-	SMTP password
MAIL_FROM_ADDRESS	No	-	From address for emails

Deploying Input on Klutch.sh

Once your repository is prepared, follow these steps to deploy Input:

Generate Your App Key

Generate a Laravel application key:

php artisan key:generate --show

Or generate a base64 key:

echo "base64:$(openssl rand -base64 32)"

Set Up MySQL Database

Input requires MySQL or MariaDB. You can:

• Deploy a MySQL app on Klutch.sh
• Use a managed database service like PlanetScale
• Use an existing MySQL server

Create a database for Input.

Push Your Repository to GitHub

Initialize your repository and push to GitHub:

git init
git add Dockerfile .dockerignore
git commit -m "Initial Input deployment configuration"
git remote add origin https://github.com/yourusername/input-deploy.git
git push -u origin main

Create a New Project on Klutch.sh

Navigate to the Klutch.sh dashboard and create a new project. Give it a descriptive name like “forms” or “input”.

Create a New App

Within your project, create a new app. Connect your GitHub account if you haven’t already, then select the repository containing your Input Dockerfile.

Configure HTTP Traffic

Input serves its web interface over HTTP. In the deployment settings:

• Select HTTP as the traffic type
• Set the internal port to 8080 (or 80 if using the Apache build)

Set Environment Variables

In the environment variables section, add:

Variable	Value
APP_KEY	Your generated Laravel key
APP_URL	https://your-app-name.klutch.sh
DB_HOST	Your MySQL hostname
DB_DATABASE	Database name
DB_USERNAME	Database username
DB_PASSWORD	Database password

Attach Persistent Volumes

Add the following volume for storage:

Mount Path	Recommended Size	Purpose
/var/www/html/storage	10 GB	Uploads, cache, and logs

Deploy Your Application

Click Deploy to start the build process. Klutch.sh will:

• Detect your Dockerfile automatically
• Build the container image
• Attach the persistent volumes
• Start the Input container
• Provision an HTTPS certificate

Run Migrations

After deployment, run database migrations:

php artisan migrate --force

This can be done through Klutch.sh’s console or exec functionality.

Access Input

Once deployment completes and migrations are run, access your Input instance at https://your-app-name.klutch.sh. Create your admin account and start building forms.

Creating Forms

Form Builder Interface

Input provides an intuitive form builder:

1. Click “Create Form”
2. Give your form a name and optional description
3. Use the drag-and-drop interface to add questions

Question Types

Input supports various question types:

Type	Description
Short Text	Single-line text input
Long Text	Multi-line textarea
Multiple Choice	Select one option
Checkboxes	Select multiple options
Rating	Star or number ratings
Date	Date picker
File Upload	Accept file attachments
Number	Numeric input
Email	Email validation
Statement	Non-question text blocks

Logic Jumps

Create dynamic forms that adapt to responses:

1. Select a question
2. Add logic rules
3. Define conditions (if answer equals X, go to Y)
4. Preview to test logic flow

Branding

Customize your forms to match your brand:

1. Go to form settings
2. Set colors for background, buttons, and text
3. Upload your logo
4. Configure success messages

Managing Responses

Viewing Responses

Access collected responses:

1. Open your form
2. Go to the Responses tab
3. View individual submissions
4. Export to CSV

Response Analytics

View statistics:

• Completion rates
• Average completion time
• Question-level analytics
• Drop-off points

Webhooks

Send responses to external services:

1. Go to form settings > Integrations
2. Add webhook URL
3. Responses are POSTed in JSON format

Troubleshooting Common Issues

Database Connection Errors

Symptoms: Application fails to connect to database.

Solutions:

• Verify MySQL host is accessible
• Check username and password
• Ensure database exists

Storage Permission Issues

Symptoms: Cannot upload files or save forms.

Solutions:

• Check storage volume is mounted
• Verify www-data owns storage directory
• Ensure sufficient disk space

Forms Not Loading

Symptoms: Form pages show errors.

Solutions:

• Run php artisan cache:clear
• Check APP_URL matches your actual URL
• Verify APP_KEY is set correctly

Additional Resources

• Input GitHub Repository
• Input Website
• Laravel Documentation
• Klutch.sh Persistent Volumes
• Klutch.sh Deployments

Conclusion

Deploying Input on Klutch.sh gives you a professional, self-hosted form builder with automatic builds, persistent storage, and secure HTTPS access. You maintain full control over your form responses and user data while enjoying the ease of a no-code interface.

Whether you’re collecting customer feedback, running surveys, or building lead generation forms, Input on Klutch.sh provides a privacy-respecting alternative to commercial form services without the per-response pricing.