Skip to content
Klutch.sh Docs

Deploying Digibunch

Digibunch is a comprehensive team collaboration and project management platform that brings together everything your team needs to stay organized and productive. Built on Laravel and designed with modern teams in mind, it combines project tracking, task management, file sharing, team communication, and time tracking into one unified workspace. Instead of juggling multiple tools and subscriptions—one for chat, another for files, a third for tasks—Digibunch consolidates these essential functions into a single, self-hosted application that you control completely.

What sets Digibunch apart from heavyweight enterprise solutions is its focus on simplicity without sacrificing power. The interface feels intuitive from day one, with a clean design that puts your work front and center. Create projects and immediately start adding tasks, uploading files, and inviting team members. The built-in Kanban boards give you visual task management, while the calendar view helps you track deadlines and milestones. Real-time notifications keep everyone in the loop, and the activity feed provides transparency into what’s happening across all your projects. File version control ensures you never lose important work, and the time tracking features help teams understand how they’re spending their hours. Whether you’re a small startup coordinating remote workers or an established company looking to break free from expensive SaaS subscriptions, Digibunch provides the tools you need without the complexity you don’t.

Why Deploy Digibunch on Klutch.sh?

Deploying Digibunch on Klutch.sh offers several compelling advantages for team collaboration:

  • Complete Data Ownership: Your team’s projects, files, and communications stay on infrastructure you control
  • Always-On Access: Keep your workspace available 24/7 without maintaining local servers
  • Automatic HTTPS: Secure team communications with built-in SSL certificates
  • Persistent Storage: All projects, files, and data persist safely across deployments
  • Scalable Infrastructure: Grow from small teams to large organizations on the same platform
  • Cost Effective: Eliminate per-user SaaS fees with self-hosted collaboration
  • Quick Deployment: Go from code to productive workspace in minutes

Prerequisites

Before deploying Digibunch to Klutch.sh, ensure you have:

  • A Klutch.sh account (sign up here)
  • A GitHub account with a repository for your Digibunch deployment
  • Basic understanding of Docker and containerization
  • Familiarity with PHP and Laravel applications
  • Understanding of team collaboration workflows
  • Git installed on your local development machine
  • MySQL or PostgreSQL database knowledge (optional but helpful)

Understanding Digibunch Architecture

Digibunch follows a traditional LAMP/LEMP stack architecture optimized for team collaboration:

Core Components

Laravel Backend

Digibunch is built on the Laravel PHP framework, which provides a robust foundation for the application. Laravel’s elegant syntax and comprehensive feature set handle everything from database operations to authentication, task scheduling, and real-time events. The backend manages all business logic including user permissions, project hierarchies, task dependencies, file storage, and notification delivery. Laravel’s Eloquent ORM makes database interactions efficient and secure, while the built-in queue system handles resource-intensive operations like email sending and file processing asynchronously.

Key backend responsibilities:

  • User authentication and authorization with role-based access control
  • Project and task CRUD operations with relationship management
  • File upload, storage, and version control
  • Real-time notification system via Laravel Echo
  • Task scheduling for recurring events and reminders
  • API endpoints for mobile and third-party integrations
  • Background job processing for heavy operations
  • Database migrations and seeding

Frontend Interface

The frontend uses a combination of Blade templates and Vue.js components for a responsive, interactive experience. Blade provides server-side rendering for initial page loads and SEO, while Vue.js handles dynamic interactions like drag-and-drop task management, real-time updates, and inline editing. The interface adapts seamlessly across devices—desktop, tablet, and mobile—ensuring team members can stay productive regardless of how they access Digibunch.

Interface features:

  • Dashboard showing recent activity across all projects
  • Project list with filtering and search capabilities
  • Kanban-style task boards with drag-and-drop
  • Calendar view for deadline tracking
  • File browser with folder organization
  • Team directory with availability status
  • Activity timeline showing recent changes
  • Real-time notifications without page refresh

Database Layer

Digibunch supports both MySQL and PostgreSQL, with MySQL being the default choice. The database schema is carefully designed to handle complex relationships:

Core Tables:

  • users: Team member accounts with profiles and settings
  • projects: Project metadata, descriptions, and settings
  • tasks: Task details including title, description, assignee, due date, status
  • files: File metadata with references to storage locations
  • comments: Discussions on tasks and projects
  • teams: Team/workspace groupings
  • activity_logs: Comprehensive audit trail of all actions

Relationship Tables:

  • project_user: Team member assignments to projects
  • task_dependencies: Dependencies between tasks
  • file_versions: Version history for uploaded files
  • notifications: User notification queue

The schema uses proper indexing for performance and foreign key constraints for data integrity.

Storage System

Digibunch handles file storage flexibly:

Local Storage: Files stored on the server filesystem in the storage/app directory. Organized by project and file type for easy management. Suitable for small to medium teams with moderate file storage needs.

Cloud Storage: Supports AWS S3, DigitalOcean Spaces, and other S3-compatible storage. Recommended for larger deployments or when horizontal scaling is needed. Configured via environment variables with automatic failover to local storage if cloud storage is unavailable.

File Features:

  • Automatic file type detection and icon assignment
  • Version control with diff viewing for text files
  • Direct file serving or download options
  • Thumbnail generation for images
  • Preview generation for documents
  • Access control based on project permissions

Queue System

Laravel’s queue system handles asynchronous tasks:

Queue Workers: Process background jobs including:

  • Email notifications to team members
  • File processing (thumbnail generation, format conversion)
  • Large data exports (project reports, time sheets)
  • Webhook deliveries to external services
  • Database cleanup and optimization tasks

Queue Drivers: Supports multiple backends:

  • Database queue (default, simple setup)
  • Redis queue (recommended for production, better performance)
  • Beanstalkd queue (alternative high-performance option)

Workers run continuously, picking up jobs as they’re queued and processing them asynchronously.

Real-Time Features

Digibunch uses Laravel Echo with WebSocket connections for real-time updates:

Broadcasting Events:

  • New task assignments appear immediately
  • Comment notifications show in real-time
  • File upload completions broadcast to project members
  • User presence indicators (online/offline status)
  • Typing indicators in comment threads

Technical Stack:

  • Laravel Broadcasting for event firing
  • Pusher or Laravel WebSockets for WebSocket server
  • Socket.io client library for frontend connections
  • Redis for pub/sub message distribution

Request Flow

Understanding how requests move through Digibunch helps with deployment and troubleshooting:

  1. User Action: Team member creates task, uploads file, or posts comment
  2. Web Server: Nginx receives request and passes to PHP-FPM
  3. Laravel Router: Routes request to appropriate controller
  4. Controller Logic: Validates input, performs business logic
  5. Database Operation: Eloquent saves changes to database
  6. Event Broadcasting: Laravel fires event for real-time updates
  7. Queue Jobs: Asynchronous tasks queued (emails, notifications)
  8. Response: JSON or HTML response returned to user
  9. Frontend Update: Vue.js components update interface
  10. WebSocket Push: Other team members receive real-time updates

Permission System

Digibunch implements a flexible permission model:

Roles:

  • Owner: Full control over workspace, billing, and all projects
  • Admin: Can manage projects, users, and settings
  • Member: Can create projects and participate in assigned projects
  • Guest: Limited access to specific projects only

Project Permissions:

  • Project Manager: Full control within project
  • Member: Can create and manage own tasks
  • Viewer: Read-only access to project

Permissions cascade from workspace level to project level, with more restrictive permissions taking precedence.

Storage Requirements

Digibunch’s storage needs depend on team size and usage:

  • Application: 200-300MB for Laravel, dependencies, and assets
  • Database: 100MB-1GB depending on team size and activity
  • Files: Highly variable based on team file usage (plan 5-50GB typically)
  • Logs: 50-200MB with rotation enabled
  • Cache: 50-100MB for application and session cache

Typical deployment scenarios:

  • Small Team (5-10 users): 10GB total
  • Medium Team (10-50 users): 30GB total
  • Large Team (50+ users): 100GB+ total

Installation and Setup

Let’s walk through setting up Digibunch for deployment on Klutch.sh.

Step 1: Create the Project Structure

First, create a new directory for your Digibunch deployment:

Terminal window
mkdir digibunch-deployment
cd digibunch-deployment
git init

Step 2: Create the Dockerfile

Create a Dockerfile in the root directory:

FROM php:8.2-fpm-alpine


# Install system dependencies
RUN apk add --no-cache \
    nginx \
    supervisor \
    mysql-client \
    postgresql-client \
    nodejs \
    npm \
    git \
    curl \
    zip \
    unzip \
    libpng-dev \
    libjpeg-turbo-dev \
    freetype-dev \
    libzip-dev \
    oniguruma-dev \
    icu-dev


# Install PHP extensions
RUN docker-php-ext-configure gd --with-freetype --with-jpeg && \
    docker-php-ext-install -j$(nproc) \
    pdo \
    pdo_mysql \
    pdo_pgsql \
    mbstring \
    zip \
    exif \
    pcntl \
    bcmath \
    gd \
    intl


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


# Set working directory
WORKDIR /var/www/html


# Copy application files
COPY . .


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


# Install Node dependencies and build assets
RUN npm ci && npm run build


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


# Copy configuration files
COPY docker/nginx.conf /etc/nginx/nginx.conf
COPY docker/php-fpm.conf /usr/local/etc/php-fpm.d/www.conf
COPY docker/supervisord.conf /etc/supervisord.conf


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


# Expose port
EXPOSE 8080


# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
  CMD curl -f http://localhost:8080/health || exit 1


# Start supervisord
CMD ["/usr/bin/supervisord", "-c", "/etc/supervisord.conf"]

Step 3: Create Nginx Configuration

Create docker/nginx.conf:

user www-data;
worker_processes auto;
pid /run/nginx.pid;


events {
    worker_connections 1024;
    use epoll;
}


http {
    include /etc/nginx/mime.types;
    default_type application/octet-stream;


    access_log /var/log/nginx/access.log;
    error_log /var/log/nginx/error.log;


    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    keepalive_timeout 65;
    types_hash_max_size 2048;
    client_max_body_size 100M;


    gzip on;
    gzip_vary on;
    gzip_proxied any;
    gzip_comp_level 6;
    gzip_types text/plain text/css text/xml text/javascript application/json application/javascript application/xml+rss application/rss+xml font/truetype font/opentype application/vnd.ms-fontobject image/svg+xml;


    server {
        listen 8080;
        server_name _;
        root /var/www/html/public;
        index index.php index.html;


        location / {
            try_files $uri $uri/ /index.php?$query_string;
        }


        location ~ \.php$ {
            fastcgi_pass 127.0.0.1:9000;
            fastcgi_index index.php;
            fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
            include fastcgi_params;
            fastcgi_buffers 16 16k;
            fastcgi_buffer_size 32k;
        }


        location ~ /\.ht {
            deny all;
        }


        location ~* \.(jpg|jpeg|png|gif|ico|css|js|svg|woff|woff2|ttf|eot)$ {
            expires 1y;
            add_header Cache-Control "public, immutable";
        }
    }
}

Step 4: Create PHP-FPM Configuration

Create docker/php-fpm.conf:

[www]
user = www-data
group = www-data
listen = 127.0.0.1:9000
listen.owner = www-data
listen.group = www-data
pm = dynamic
pm.max_children = 50
pm.start_servers = 5
pm.min_spare_servers = 5
pm.max_spare_servers = 35
pm.max_requests = 500


; PHP settings
php_admin_value[error_log] = /var/log/php-fpm/error.log
php_admin_flag[log_errors] = on
php_admin_value[memory_limit] = 256M
php_value[upload_max_filesize] = 100M
php_value[post_max_size] = 100M
php_value[max_execution_time] = 300

Step 5: Create Supervisor Configuration

Create docker/supervisord.conf:

[supervisord]
nodaemon=true
user=root
logfile=/var/log/supervisord.log
pidfile=/var/run/supervisord.pid


[program:nginx]
command=/usr/sbin/nginx -g "daemon off;"
autostart=true
autorestart=true
stdout_logfile=/dev/stdout
stdout_logfile_maxbytes=0
stderr_logfile=/dev/stderr
stderr_logfile_maxbytes=0


[program:php-fpm]
command=/usr/local/sbin/php-fpm -F
autostart=true
autorestart=true
stdout_logfile=/dev/stdout
stdout_logfile_maxbytes=0
stderr_logfile=/dev/stderr
stderr_logfile_maxbytes=0


[program:queue-worker]
process_name=%(program_name)s_%(process_num)02d
command=php /var/www/html/artisan queue:work --sleep=3 --tries=3 --max-time=3600
autostart=true
autorestart=true
numprocs=2
redirect_stderr=true
stdout_logfile=/var/www/html/storage/logs/worker.log


[program:scheduler]
command=/bin/sh -c "while [ true ]; do php /var/www/html/artisan schedule:run --verbose --no-interaction; sleep 60; done"
autostart=true
autorestart=true
stdout_logfile=/var/www/html/storage/logs/scheduler.log

Step 6: Create Laravel Environment Configuration

Create .env.example:

Terminal window
# Application
APP_NAME=Digibunch
APP_ENV=production
APP_KEY=
APP_DEBUG=false
APP_URL=https://example-app.klutch.sh


# Database
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=digibunch
DB_USERNAME=digibunch
DB_PASSWORD=


# Cache & Session
CACHE_DRIVER=file
SESSION_DRIVER=file
QUEUE_CONNECTION=database


# Redis (optional, for better performance)
REDIS_HOST=127.0.0.1
REDIS_PASSWORD=null
REDIS_PORT=6379


# Mail
MAIL_MAILER=smtp
MAIL_HOST=smtp.mailtrap.io
MAIL_PORT=2525
MAIL_USERNAME=
MAIL_PASSWORD=
MAIL_ENCRYPTION=tls
MAIL_FROM_ADDRESS=no-reply@digibunch.com
MAIL_FROM_NAME="${APP_NAME}"


# Filesystem
FILESYSTEM_DISK=local


# AWS S3 (optional)
AWS_ACCESS_KEY_ID=
AWS_SECRET_ACCESS_KEY=
AWS_DEFAULT_REGION=us-east-1
AWS_BUCKET=
AWS_USE_PATH_STYLE_ENDPOINT=false


# Broadcasting (for real-time features)
BROADCAST_DRIVER=log
PUSHER_APP_ID=
PUSHER_APP_KEY=
PUSHER_APP_SECRET=
PUSHER_APP_CLUSTER=mt1


# Storage
STORAGE_PATH=/var/www/html/storage


# Logging
LOG_CHANNEL=stack
LOG_LEVEL=error


# Security
SESSION_LIFETIME=120
SESSION_SECURE_COOKIE=true

Step 7: Create Application Bootstrap Script

Create docker/bootstrap.sh:

#!/bin/sh
set -e


echo "Bootstrapping Digibunch..."


# Wait for database to be ready
echo "Waiting for database..."
until php artisan migrate:status 2>/dev/null; do
    echo "Database not ready, waiting..."
    sleep 2
done


# Run migrations
echo "Running database migrations..."
php artisan migrate --force


# Clear and cache config
echo "Optimizing application..."
php artisan config:cache
php artisan route:cache
php artisan view:cache


# Create storage link
php artisan storage:link


# Set permissions
chown -R www-data:www-data /var/www/html/storage
chmod -R 775 /var/www/html/storage


echo "Bootstrap complete!"

Step 8: Create Composer Configuration

Create composer.json (if not exists in Digibunch):

{
    "name": "digibunch/digibunch",
    "type": "project",
    "description": "Team collaboration and project management platform",
    "keywords": ["framework", "laravel", "project management", "collaboration"],
    "license": "MIT",
    "require": {
        "php": "^8.1",
        "laravel/framework": "^10.0",
        "laravel/sanctum": "^3.2",
        "laravel/tinker": "^2.8",
        "intervention/image": "^2.7",
        "spatie/laravel-permission": "^5.10",
        "spatie/laravel-activitylog": "^4.7",
        "laravel/horizon": "^5.15",
        "pusher/pusher-php-server": "^7.2"
    },
    "require-dev": {
        "fakerphp/faker": "^1.9.1",
        "laravel/pint": "^1.0",
        "laravel/sail": "^1.18",
        "mockery/mockery": "^1.4.4",
        "nunomaduro/collision": "^7.0",
        "phpunit/phpunit": "^10.0",
        "spatie/laravel-ignition": "^2.0"
    },
    "autoload": {
        "psr-4": {
            "App\\": "app/",
            "Database\\Factories\\": "database/factories/",
            "Database\\Seeders\\": "database/seeders/"
        }
    },
    "autoload-dev": {
        "psr-4": {
            "Tests\\": "tests/"
        }
    },
    "scripts": {
        "post-autoload-dump": [
            "Illuminate\\Foundation\\ComposerScripts::postAutoloadDump",
            "@php artisan package:discover --ansi"
        ],
        "post-update-cmd": [
            "@php artisan vendor:publish --tag=laravel-assets --ansi --force"
        ],
        "post-root-package-install": [
            "@php -r \"file_exists('.env') || copy('.env.example', '.env');\""
        ],
        "post-create-project-cmd": [
            "@php artisan key:generate --ansi"
        ]
    },
    "extra": {
        "laravel": {
            "dont-discover": []
        }
    },
    "config": {
        "optimize-autoloader": true,
        "preferred-install": "dist",
        "sort-packages": true,
        "allow-plugins": {
            "pestphp/pest-plugin": true,
            "php-http/discovery": true
        }
    },
    "minimum-stability": "stable",
    "prefer-stable": true
}

Step 9: Create Package.json for Frontend

Create package.json:

{
    "private": true,
    "scripts": {
        "dev": "vite",
        "build": "vite build",
        "watch": "vite build --watch"
    },
    "devDependencies": {
        "@vitejs/plugin-vue": "^4.0.0",
        "axios": "^1.1.2",
        "laravel-vite-plugin": "^0.7.2",
        "vite": "^4.0.0",
        "vue": "^3.2.31"
    },
    "dependencies": {
        "@fortawesome/fontawesome-free": "^6.4.0",
        "bootstrap": "^5.2.3",
        "chart.js": "^4.2.1",
        "vue-router": "^4.1.6",
        "vuex": "^4.1.0",
        "vue-draggable": "^4.1.0",
        "dayjs": "^1.11.7",
        "lodash": "^4.17.21"
    }
}

Step 10: Create Health Check Endpoint

Create routes/web.php addition:

// Health check endpoint
Route::get('/health', function () {
    try {
        // Check database connection
        DB::connection()->getPdo();


        // Check storage is writable
        $testFile = storage_path('framework/cache/health-check.txt');
        file_put_contents($testFile, time());
        unlink($testFile);


        return response()->json([
            'status' => 'healthy',
            'timestamp' => now()->toIso8601String(),
            'database' => 'connected',
            'storage' => 'writable'
        ]);
    } catch (\Exception $e) {
        return response()->json([
            'status' => 'unhealthy',
            'error' => $e->getMessage()
        ], 503);
    }
});

Step 11: Create Docker Ignore File

Create .dockerignore:

.git
.gitignore
.env
.env.backup
.phpunit.result.cache
node_modules/
vendor/
storage/logs/*.log
storage/framework/cache/*
storage/framework/sessions/*
storage/framework/views/*
!storage/framework/.gitignore
bootstrap/cache/*
!bootstrap/cache/.gitignore
public/hot
public/storage
npm-debug.log
yarn-error.log
*.md
README.md
.vscode
.idea
.DS_Store
Thumbs.db
tests/

Step 12: Create Documentation

Create README.md:

# Digibunch Deployment


This repository contains a Digibunch deployment configured for Klutch.sh.


## Features


- **Project Management**: Create and manage multiple projects
- **Task Tracking**: Kanban boards, lists, and calendar views
- **File Sharing**: Upload and organize files with version control
- **Team Collaboration**: Comments, mentions, and activity feeds
- **Time Tracking**: Track time spent on tasks and projects
- **Role-Based Access**: Flexible permissions for teams
- **Real-Time Updates**: Live notifications and activity updates
- **Mobile Responsive**: Access from any device


## Default Credentials


After first deployment, create an admin account via Artisan:


```bash
php artisan make:admin --email=admin@example.com --password=changeme

IMPORTANT: Change the default password immediately!

Quick Start

  1. Deploy to Klutch.sh
  2. Set environment variables (database, mail, etc.)
  3. Access application at your deployment URL
  4. Create admin account via console
  5. Login and start creating projects

Configuration

Database Setup

Digibunch requires MySQL or PostgreSQL:

DB_CONNECTION=mysql
DB_HOST=your-database-host
DB_PORT=3306
DB_DATABASE=digibunch
DB_USERNAME=digibunch_user
DB_PASSWORD=secure_password

Mail Configuration

Configure email for notifications:

MAIL_MAILER=smtp
MAIL_HOST=smtp.example.com
MAIL_PORT=587
MAIL_USERNAME=your-username
MAIL_PASSWORD=your-password
MAIL_ENCRYPTION=tls
MAIL_FROM_ADDRESS=no-reply@yourdomain.com

Storage Configuration

For production, use S3-compatible storage:

FILESYSTEM_DISK=s3
AWS_ACCESS_KEY_ID=your-access-key
AWS_SECRET_ACCESS_KEY=your-secret-key
AWS_DEFAULT_REGION=us-east-1
AWS_BUCKET=your-bucket-name

Artisan Commands

Create Admin User

Terminal window
php artisan make:admin --email=admin@example.com --password=secure_password

Run Database Migrations

Terminal window
php artisan migrate

Clear Cache

Terminal window
php artisan cache:clear
php artisan config:clear
php artisan view:clear

Optimize Application

Terminal window
php artisan config:cache
php artisan route:cache
php artisan view:cache

API Endpoints

  • GET /api/projects - List all projects
  • POST /api/projects - Create new project
  • GET /api/projects/{id} - Get project details
  • GET /api/projects/{id}/tasks - Get project tasks
  • POST /api/tasks - Create new task
  • PUT /api/tasks/{id} - Update task
  • POST /api/files - Upload file

Deployment

This application is configured to deploy on Klutch.sh with automatic Docker detection.

### Step 13: Initialize Git Repository


```bash
git add .
git commit -m "Initial Digibunch setup for Klutch.sh deployment"
git branch -M master
git remote add origin https://github.com/yourusername/digibunch-deployment.git
git push -u origin master

Deploying to Klutch.sh

Now that your Digibunch application is configured, let’s deploy it to Klutch.sh.

  1. Log in to Klutch.sh

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

  2. Create a New Project

    Click “New Project” and select “Import from GitHub”. Choose the repository containing your Digibunch deployment.

  3. Configure Build Settings

    Klutch.sh will automatically detect the Dockerfile in your repository. The platform will use this for building your container.

  4. Configure Traffic Settings

    Select “HTTP” as the traffic type. Digibunch’s web interface runs on port 8080, and Klutch.sh will route HTTPS traffic to this port.

  5. Set Environment Variables

    In the project settings, add the following environment variables:

    • APP_NAME: Digibunch
    • APP_ENV: production
    • APP_KEY: Generate with php artisan key:generate --show
    • APP_DEBUG: false
    • APP_URL: Your Klutch.sh deployment URL

    Database configuration:

    • DB_CONNECTION: mysql or pgsql
    • DB_HOST: Your database host
    • DB_PORT: 3306 (MySQL) or 5432 (PostgreSQL)
    • DB_DATABASE: digibunch
    • DB_USERNAME: Your database username
    • DB_PASSWORD: Your database password

    Mail configuration:

    • MAIL_MAILER: smtp
    • MAIL_HOST: Your SMTP host
    • MAIL_PORT: 587
    • MAIL_USERNAME: Your SMTP username
    • MAIL_PASSWORD: Your SMTP password
    • MAIL_FROM_ADDRESS: no-reply@yourdomain.com

    Optional Redis configuration (recommended):

    • REDIS_HOST: Your Redis host
    • REDIS_PORT: 6379
    • REDIS_PASSWORD: Your Redis password (if applicable)
    • CACHE_DRIVER: redis
    • SESSION_DRIVER: redis
    • QUEUE_CONNECTION: redis
  6. Configure Persistent Storage

    Digibunch requires persistent storage for user uploads and application data:

    • Storage Volume:
      • Mount path: /var/www/html/storage
      • Size: 20GB (adjust based on expected file storage)
    • Public Files Volume:
      • Mount path: /var/www/html/public/storage
      • Size: 10GB
    • Logs Volume (optional):
      • Mount path: /var/www/html/storage/logs
      • Size: 2GB

    These volumes ensure your uploaded files, user data, and application state persist across deployments.

  7. Deploy the Application

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

    • Clone your repository
    • Build the Docker image using your Dockerfile
    • Install PHP dependencies via Composer
    • Install Node.js dependencies and build frontend assets
    • Configure Nginx and PHP-FPM
    • Start queue workers and scheduler
    • Deploy the container
    • Provision an HTTPS endpoint

    The build process typically takes 5-8 minutes.

  8. Run Database Migrations

    After deployment, access the container terminal and run:

    Terminal window
    php artisan migrate --force

    This creates all necessary database tables.

  9. Create Admin Account

    Create your first admin user:

    Terminal window
    php artisan make:admin --email=admin@example.com --password=SecurePassword123

    Replace the email and password with your desired credentials.

  10. Access Digibunch

    Navigate to your deployment URL (e.g., example-app.klutch.sh) and login with your admin credentials.

Getting Started with Digibunch

Once your Digibunch instance is deployed, here’s how to set up your team workspace:

Initial Configuration

First Login

Access your deployment URL and login with the admin credentials you created.

Update Profile

  1. Click your avatar in top-right corner
  2. Select “Profile Settings”
  3. Upload profile photo
  4. Update display name
  5. Set timezone
  6. Configure notification preferences

Workspace Settings

Configure workspace-wide settings:

  1. Navigate to Settings → Workspace
  2. Set workspace name and logo
  3. Configure default project permissions
  4. Set up email domains for auto-join
  5. Configure file upload limits
  6. Set default timezone

Creating Projects

Create Your First Project

// Via API
POST /api/projects
{
    "name": "Website Redesign",
    "description": "Redesign company website with modern UI",
    "color": "#3498db",
    "is_private": false,
    "start_date": "2025-01-01",
    "end_date": "2025-03-31"
}

Or use the web interface:

  1. Click “New Project” button
  2. Enter project details:
    • Name: Descriptive project name
    • Description: Project goals and scope
    • Color: Visual identifier
    • Privacy: Public (all team members) or Private (invited only)
    • Dates: Start and end dates
  3. Click “Create Project”

Project Structure

Each project includes:

  • Overview: Project dashboard with recent activity
  • Tasks: Task management with multiple views
  • Files: File storage and organization
  • Team: Project member management
  • Activity: Complete activity log
  • Settings: Project-specific configuration

Managing Tasks

Create Tasks

Add tasks to your project:

// Via API
POST /api/tasks
{
    "project_id": 1,
    "title": "Design homepage mockup",
    "description": "Create high-fidelity mockup of new homepage design",
    "assignee_id": 5,
    "due_date": "2025-01-15",
    "priority": "high",
    "status": "todo",
    "tags": ["design", "homepage"],
    "estimated_hours": 8
}

Web interface:

  1. Navigate to project
  2. Click “New Task”
  3. Fill in task details:
    • Title and description
    • Assignee
    • Due date
    • Priority level
    • Status column
    • Tags and labels
    • Time estimate
  4. Click “Create Task”

Kanban Board View

Manage tasks visually:

  1. Switch to “Board” view
  2. Drag tasks between columns:
    • To Do: Pending tasks
    • In Progress: Active work
    • In Review: Awaiting review
    • Done: Completed tasks
  3. Customize columns for your workflow
  4. Filter by assignee, priority, or tags

List View

For detailed task management:

  1. Switch to “List” view
  2. Sort by due date, priority, or assignee
  3. Bulk select tasks for batch operations
  4. Apply filters for focused views
  5. Export tasks to CSV

Calendar View

Track deadlines:

  1. Switch to “Calendar” view
  2. See tasks by due date
  3. Drag tasks to reschedule
  4. View monthly, weekly, or daily
  5. Color-coded by project or priority

File Management

Upload Files

// Via JavaScript
const uploadFile = async (file, projectId) => {
  const formData = new FormData();
  formData.append('file', file);
  formData.append('project_id', projectId);
  formData.append('folder', 'Design Assets');


  const response = await fetch('/api/files', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${token}`
    },
    body: formData
  });


  return response.json();
};

Web interface:

  1. Navigate to project Files tab
  2. Click “Upload” button
  3. Select files or drag-and-drop
  4. Choose destination folder
  5. Add description (optional)
  6. Click “Upload”

Organize Files

Create folder structure:

  1. Click “New Folder”
  2. Name the folder (e.g., “Design Assets”, “Documents”, “Marketing”)
  3. Drag files into folders
  4. Create sub-folders for hierarchy

File Versions

Track file changes:

  1. Click on any file
  2. Select “Upload New Version”
  3. Choose replacement file
  4. Add version notes
  5. Previous versions remain accessible

File Sharing

Share files with external users:

  1. Right-click file
  2. Select “Generate Share Link”
  3. Set expiration date (optional)
  4. Set password protection (optional)
  5. Copy link and share

Team Collaboration

Invite Team Members

Add people to your workspace:

// Via API
POST /api/invitations
{
    "email": "colleague@example.com",
    "role": "member",
    "message": "Welcome to our team workspace!"
}

Web interface:

  1. Navigate to Settings → Team
  2. Click “Invite Member”
  3. Enter email address
  4. Select role (Admin, Member, or Guest)
  5. Add personal message
  6. Click “Send Invitation”

Assign to Projects

Add members to specific projects:

  1. Open project
  2. Go to “Team” tab
  3. Click “Add Member”
  4. Select team member
  5. Choose project role
  6. Set permissions
  7. Click “Add”

Task Comments

Discuss tasks with team:

// Add comment via API
POST /api/tasks/123/comments
{
    "content": "I've updated the mockup based on the feedback. Please review!",
    "mentions": ["@john", "@sarah"]
}

Web interface:

  1. Open task
  2. Scroll to comments section
  3. Type comment
  4. Use @ to mention team members
  5. Attach files if needed
  6. Click “Post Comment”

Real-Time Notifications

Stay updated on activity:

  • New task assignments
  • Comments and mentions
  • File uploads
  • Due date reminders
  • Project updates
  • Status changes

Notifications appear in:

  • In-app notification center
  • Email (configurable)
  • Browser push notifications (optional)

Time Tracking

Track Time on Tasks

Start timer for active work:

// Start time tracking
POST /api/tasks/123/time-entries
{
    "started_at": "2025-01-10T09:00:00Z",
    "description": "Working on homepage mockup"
}


// Stop time tracking
PUT /api/time-entries/456
{
    "ended_at": "2025-01-10T11:30:00Z"
}

Web interface:

  1. Open task
  2. Click “Start Timer”
  3. Work on task
  4. Click “Stop Timer” when done
  5. Edit time entry if needed

Manual Time Entry

Add time retroactively:

  1. Navigate to task
  2. Click “Add Time”
  3. Enter date and duration
  4. Add description
  5. Click “Save”

Time Reports

Generate time reports:

  1. Navigate to Reports
  2. Select “Time Report”
  3. Choose date range
  4. Filter by project, user, or task
  5. Export to CSV or PDF

Advanced Configuration

Database Optimization

Configure Connection Pooling

For better performance with MySQL:

DB_CONNECTION=mysql
DB_HOST=your-mysql-host
DB_PORT=3306
DB_DATABASE=digibunch
DB_USERNAME=digibunch_user
DB_PASSWORD=secure_password


# Connection pool settings
DB_POOL_MIN=2
DB_POOL_MAX=10

Add Database Indexes

Optimize common queries:

-- Index frequently queried columns
CREATE INDEX idx_tasks_project_status ON tasks(project_id, status);
CREATE INDEX idx_tasks_assignee_duedate ON tasks(assignee_id, due_date);
CREATE INDEX idx_files_project ON files(project_id);
CREATE INDEX idx_comments_task ON comments(task_id);
CREATE INDEX idx_activity_project ON activity_logs(project_id, created_at DESC);

Redis Configuration

Enable Redis Caching

Improve performance with Redis:

CACHE_DRIVER=redis
SESSION_DRIVER=redis
QUEUE_CONNECTION=redis


REDIS_HOST=your-redis-host
REDIS_PASSWORD=your-redis-password
REDIS_PORT=6379
REDIS_DB=0


# Redis configuration
REDIS_CLIENT=phpredis
REDIS_CLUSTER=false

Configure Redis Queues

For better queue performance:

config/queue.php
'redis' => [
    'driver' => 'redis',
    'connection' => 'default',
    'queue' => env('REDIS_QUEUE', 'default'),
    'retry_after' => 90,
    'block_for' => null,
    'after_commit' => false,
],

Email Configuration

Configure SMTP

Set up email notifications:

MAIL_MAILER=smtp
MAIL_HOST=smtp.sendgrid.net
MAIL_PORT=587
MAIL_USERNAME=apikey
MAIL_PASSWORD=your-sendgrid-api-key
MAIL_ENCRYPTION=tls
MAIL_FROM_ADDRESS=notifications@yourdomain.com
MAIL_FROM_NAME="Digibunch Notifications"

Queue Email Sending

Improve performance by queuing emails:

// In your notification class
public function via($notifiable)
{
    return ['mail', 'database'];
}


// Queue the email
public function viaQueues()
{
    return [
        'mail' => 'emails',
    ];
}

File Storage Configuration

AWS S3 Storage

Use S3 for scalable file storage:

FILESYSTEM_DISK=s3


AWS_ACCESS_KEY_ID=your-access-key-id
AWS_SECRET_ACCESS_KEY=your-secret-access-key
AWS_DEFAULT_REGION=us-east-1
AWS_BUCKET=digibunch-files
AWS_USE_PATH_STYLE_ENDPOINT=false
AWS_URL=https://your-bucket.s3.amazonaws.com


# Optional: CloudFront CDN
AWS_CLOUDFRONT_DOMAIN=your-distribution.cloudfront.net

DigitalOcean Spaces

Alternative S3-compatible storage:

FILESYSTEM_DISK=s3


AWS_ACCESS_KEY_ID=your-spaces-key
AWS_SECRET_ACCESS_KEY=your-spaces-secret
AWS_DEFAULT_REGION=nyc3
AWS_BUCKET=digibunch-files
AWS_ENDPOINT=https://nyc3.digitaloceanspaces.com
AWS_USE_PATH_STYLE_ENDPOINT=false

Real-Time Features

Configure Laravel WebSockets

Self-hosted WebSocket server:

BROADCAST_DRIVER=pusher


PUSHER_APP_ID=local
PUSHER_APP_KEY=local
PUSHER_APP_SECRET=local
PUSHER_HOST=127.0.0.1
PUSHER_PORT=6001
PUSHER_SCHEME=http
PUSHER_APP_CLUSTER=mt1

Start WebSocket server:

Terminal window
php artisan websockets:serve

Configure Pusher

Use hosted Pusher service:

BROADCAST_DRIVER=pusher


PUSHER_APP_ID=your-app-id
PUSHER_APP_KEY=your-app-key
PUSHER_APP_SECRET=your-app-secret
PUSHER_APP_CLUSTER=us2

Security Hardening

Enable CSRF Protection

Ensure CSRF tokens are validated:

// Middleware already included in Laravel
// Verify it's in app/Http/Kernel.php
protected $middlewareGroups = [
    'web' => [
        \App\Http\Middleware\VerifyCsrfToken::class,
        // other middleware...
    ],
];

Configure CORS

Allow specific domains:

config/cors.php
return [
    'paths' => ['api/*', 'broadcasting/auth'],
    'allowed_methods' => ['*'],
    'allowed_origins' => [
        'https://yourdomain.com',
        'https://app.yourdomain.com',
    ],
    'allowed_origins_patterns' => [],
    'allowed_headers' => ['*'],
    'exposed_headers' => [],
    'max_age' => 0,
    'supports_credentials' => true,
];

Rate Limiting

Protect against abuse:

routes/api.php
Route::middleware(['throttle:60,1'])->group(function () {
    // API routes limited to 60 requests per minute
});


// config/sanctum.php
'limiter' => 'api', // Use the 'api' limiter for Sanctum

Performance Optimization

Enable OPcache

Cache PHP bytecode:

; php.ini or docker/php-fpm.conf
opcache.enable=1
opcache.memory_consumption=256
opcache.interned_strings_buffer=16
opcache.max_accelerated_files=10000
opcache.validate_timestamps=0
opcache.revalidate_freq=0
opcache.fast_shutdown=1

Configure Query Caching

Cache database queries:

// In your models or controllers
$projects = Cache::remember('user.'.$userId.'.projects', 3600, function () use ($userId) {
    return Project::where('user_id', $userId)->with('tasks')->get();
});

Lazy Load Relationships

Optimize database queries:

// Eager load relationships to avoid N+1 queries
$projects = Project::with(['tasks', 'files', 'members'])->get();


// Lazy eager loading when needed
$projects = Project::all();
if ($needTasks) {
    $projects->load('tasks');
}

Asset Optimization

Minimize frontend assets:

vite.config.js
import { defineConfig } from 'vite';
import laravel from 'laravel-vite-plugin';


export default defineConfig({
    plugins: [
        laravel({
            input: ['resources/css/app.css', 'resources/js/app.js'],
            refresh: true,
        }),
    ],
    build: {
        minify: 'terser',
        terserOptions: {
            compress: {
                drop_console: true,
            },
        },
        rollupOptions: {
            output: {
                manualChunks: {
                    vendor: ['vue', 'axios', 'lodash'],
                },
            },
        },
    },
});

Production Best Practices

Follow these recommendations for running Digibunch in production:

Security

Secure Environment Variables

Never commit sensitive data:

Terminal window
# Generate secure APP_KEY
php artisan key:generate --show


# Use strong database passwords
DB_PASSWORD=$(openssl rand -base64 32)


# Secure session configuration
SESSION_SECURE_COOKIE=true
SESSION_SAME_SITE=strict

Regular Backups

Automate database backups:

backup.sh
#!/bin/bash
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_DIR="/backups"
DB_NAME="digibunch"


# Backup database
mysqldump -h $DB_HOST -u $DB_USER -p$DB_PASS $DB_NAME | gzip > "$BACKUP_DIR/db_$DATE.sql.gz"


# Backup storage
tar -czf "$BACKUP_DIR/storage_$DATE.tar.gz" /var/www/html/storage/app


# Keep only last 7 days
find $BACKUP_DIR -name "db_*.sql.gz" -mtime +7 -delete
find $BACKUP_DIR -name "storage_*.tar.gz" -mtime +7 -delete


echo "Backup completed: $DATE"

Schedule with cron:

0 2 * * * /usr/local/bin/backup.sh

Update Dependencies

Keep packages current:

Terminal window
# Update Composer dependencies
composer update


# Update npm packages
npm update


# Check for security vulnerabilities
composer audit
npm audit

Performance Monitoring

Enable Laravel Telescope

Monitor application performance:

Terminal window
composer require laravel/telescope --dev
php artisan telescope:install
php artisan migrate

Access at: https://example-app.klutch.sh/telescope

Configure Logging

Set up structured logging:

config/logging.php
'channels' => [
    'stack' => [
        'driver' => 'stack',
        'channels' => ['single', 'slack'],
        'ignore_exceptions' => false,
    ],


    'single' => [
        'driver' => 'single',
        'path' => storage_path('logs/laravel.log'),
        'level' => env('LOG_LEVEL', 'debug'),
    ],


    'slack' => [
        'driver' => 'slack',
        'url' => env('LOG_SLACK_WEBHOOK_URL'),
        'username' => 'Digibunch Logger',
        'emoji' => ':boom:',
        'level' => 'error',
    ],
],

Application Monitoring

Track key metrics:

// Track custom metrics
use Illuminate\Support\Facades\Log;


class TaskController extends Controller
{
    public function store(Request $request)
    {
        $startTime = microtime(true);


        $task = Task::create($request->all());


        $duration = microtime(true) - $startTime;


        Log::info('Task created', [
            'task_id' => $task->id,
            'duration_ms' => round($duration * 1000, 2),
            'user_id' => auth()->id(),
        ]);


        return response()->json($task);
    }
}

Reliability

Health Checks

Implement comprehensive health monitoring:

Route::get('/health', function () {
    $health = [
        'status' => 'healthy',
        'timestamp' => now()->toIso8601String(),
        'checks' => []
    ];


    // Database check
    try {
        DB::connection()->getPdo();
        $health['checks']['database'] = 'ok';
    } catch (\Exception $e) {
        $health['checks']['database'] = 'error';
        $health['status'] = 'unhealthy';
    }


    // Redis check
    try {
        Cache::store('redis')->get('health');
        $health['checks']['redis'] = 'ok';
    } catch (\Exception $e) {
        $health['checks']['redis'] = 'error';
    }


    // Storage check
    try {
        Storage::disk('local')->put('health-check.txt', 'ok');
        Storage::disk('local')->delete('health-check.txt');
        $health['checks']['storage'] = 'ok';
    } catch (\Exception $e) {
        $health['checks']['storage'] = 'error';
        $health['status'] = 'unhealthy';
    }


    // Queue check
    $failedJobsCount = DB::table('failed_jobs')->count();
    $health['checks']['queue'] = [
        'status' => $failedJobsCount < 10 ? 'ok' : 'warning',
        'failed_jobs' => $failedJobsCount
    ];


    $statusCode = $health['status'] === 'healthy' ? 200 : 503;
    return response()->json($health, $statusCode);
});

Graceful Degradation

Handle service outages:

// Fallback to local storage if S3 fails
try {
    Storage::disk('s3')->put($filename, $content);
} catch (\Exception $e) {
    Log::warning('S3 upload failed, falling back to local', ['error' => $e->getMessage()]);
    Storage::disk('local')->put($filename, $content);
}


// Queue emails with fallback to sync
try {
    Mail::to($user)->queue(new TaskAssigned($task));
} catch (\Exception $e) {
    Log::error('Queue failed, sending email synchronously', ['error' => $e->getMessage()]);
    Mail::to($user)->send(new TaskAssigned($task));
}

Troubleshooting

Common Issues

Problem: 500 Internal Server Error on deployment

Solutions:

  • Check APP_KEY is set: php artisan key:generate
  • Verify storage permissions: chmod -R 775 storage bootstrap/cache
  • Check logs: tail -f storage/logs/laravel.log
  • Clear cache: php artisan config:clear && php artisan cache:clear
  • Verify database connection in .env

Problem: Database connection errors

Solutions:

  • Verify database credentials in .env
  • Check database server is accessible: telnet DB_HOST DB_PORT
  • Ensure database exists: mysql -h DB_HOST -u DB_USER -p -e "SHOW DATABASES;"
  • Check firewall rules allow database connections
  • Verify SSL requirements if using secure connection

Problem: File uploads failing

Solutions:

  • Check storage directory is writable: ls -la storage/
  • Verify upload_max_filesize and post_max_size in PHP config
  • Check disk space: df -h
  • Verify volume mounted correctly
  • Check Nginx client_max_body_size setting
  • Review storage/logs/laravel.log for errors

Performance Issues

Problem: Slow page loads

Solutions:

  • Enable OPcache in PHP configuration
  • Clear and rebuild cache: php artisan optimize
  • Check database query performance: Use Laravel Telescope
  • Add database indexes for slow queries
  • Enable Redis for cache and sessions
  • Optimize assets: npm run build

Problem: Queue jobs not processing

Solutions:

  • Check queue workers are running: ps aux | grep queue:work
  • Verify queue connection in .env
  • Check failed jobs table: php artisan queue:failed
  • Restart queue workers: php artisan queue:restart
  • Review worker logs in supervisor

Problem: High memory usage

Solutions:

  • Check for memory leaks in custom code
  • Optimize database queries (avoid N+1 problems)
  • Increase PHP memory_limit if needed
  • Use chunk() for large dataset processing
  • Monitor with: php artisan queue:work --memory=512

Configuration Issues

Problem: Real-time notifications not working

Solutions:

  • Verify BROADCAST_DRIVER is set correctly
  • Check WebSocket server is running
  • Test WebSocket connection in browser console
  • Verify Pusher credentials if using Pusher
  • Check firewall allows WebSocket connections
  • Review broadcasting configuration in config/broadcasting.php

Problem: Emails not sending

Solutions:

  • Verify MAIL_ environment variables
  • Test SMTP connection manually
  • Check mail queue: php artisan queue:work --queue=emails
  • Review failed jobs: php artisan queue:failed
  • Check spam folders
  • Verify sender domain SPF/DKIM records

Additional Resources

Conclusion

Digibunch provides everything modern teams need to collaborate effectively without the complexity and cost of enterprise project management suites. By combining project tracking, task management, file sharing, and team communication in one unified platform, it eliminates the need to juggle multiple tools and subscriptions. Teams can focus on their work instead of wrestling with software, while retaining complete control over their data.

Deploying Digibunch on Klutch.sh gives you a production-ready team workspace without the operational overhead of managing servers. Your team collaboration platform runs 24/7 with automatic HTTPS, persistent file storage, and the scalability to grow from a small team to a large organization. Whether you’re coordinating a remote team, managing multiple projects, or looking to consolidate your team’s tools, Digibunch on Klutch.sh provides a solid foundation that you control completely.

Start building your team’s collaborative workspace with Digibunch today and experience the freedom of self-hosted project management done right.