Deploying an EasyAppointments App

Introduction

EasyAppointments is a powerful open-source appointment scheduling and booking platform built with PHP and CodeIgniter. It provides a comprehensive solution for managing appointments, services, providers, and customer bookings across multiple business types. With features like calendar synchronization, email notifications, customizable booking forms, multi-language support, and provider management, EasyAppointments is perfect for medical clinics, salons, consulting firms, fitness centers, and any business requiring professional appointment management capabilities.

Deploying EasyAppointments on Klutch.sh gives you a scalable, production-ready infrastructure with automatic Dockerfile detection, persistent storage for uploads and databases, secure environment variable management, and built-in SSL certificate provisioning. This comprehensive guide walks through installing EasyAppointments locally, creating an optimized Dockerfile, configuring MySQL database connections, setting up persistent volumes for data retention, and deploying to Klutch.sh with production best practices.

Whether you’re managing a small clinic, running a multi-location salon, or building a booking platform for your consulting business, this guide provides everything you need to deploy and maintain a reliable EasyAppointments installation on Klutch.sh.

Prerequisites

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

A Klutch.sh account with access to the dashboard
A GitHub repository (Klutch.sh uses GitHub as the git source)
Basic knowledge of Docker, PHP, and web applications
A MySQL database instance (can be provisioned on Klutch.sh or externally)
Familiarity with environment variables and database configuration

What is EasyAppointments?

EasyAppointments is a feature-rich, self-hosted appointment booking platform that offers:

Appointment Management: Create, modify, and delete appointments with drag-and-drop calendar interface
Service Management: Define multiple services with durations, prices, and descriptions
Provider Management: Manage multiple service providers with individual schedules and availability
Customer Portal: Allow customers to self-book appointments through a customizable booking interface
Calendar Synchronization: Sync with Google Calendar for provider availability
Email Notifications: Automated email reminders and confirmations for customers and providers
Multi-Language Support: Available in 20+ languages with easy translation capabilities
Customizable Booking Pages: Embed booking widgets on external websites
Working Hours Management: Set custom working hours and breaks for each provider
Business Logic: Define buffer times, concurrent appointments, and booking advance limits
REST API: Comprehensive API for integrations and custom applications
GDPR Compliant: Built-in data privacy and consent management features

Built on the CodeIgniter PHP framework, EasyAppointments provides a stable, maintainable codebase with excellent documentation and an active community.

Getting Started: Local Installation

Before deploying to Klutch.sh, let’s set up EasyAppointments locally to understand its structure and configuration.

Installation Steps

Clone the EasyAppointments repository

git clone https://github.com/alextselegidis/easyappointments.git easyappointments-app
cd easyappointments-app

Install PHP dependencies with Composer
Terminal window
```
composer install --no-dev --optimize-autoloader
```
Set up environment configuration
Terminal window
```
cp config-sample.php config.php
```

Configure your database in config.php

Edit config.php and set your database credentials:

// Database Configuration
Config::$db_host = '127.0.0.1';
Config::$db_name = 'easyappointments';
Config::$db_username = 'your_username';
Config::$db_password = 'your_password';

// Base URL
Config::$base_url = 'http://localhost:8000';

Create the database

mysql -u root -p -e "CREATE DATABASE easyappointments CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;"

Install EasyAppointments via web installer

Start a PHP development server:
Terminal window
```
php -S 0.0.0.0:8000
```
Navigate to http://localhost:8000/installation and complete the installation wizard.
Complete the installation wizard

Follow the web-based installer to:
- Verify server requirements
- Set up the database schema
- Create the admin account
- Configure basic settings
Your EasyAppointments installation should now be accessible at http://localhost:8000

Sample API Usage Code

Once installed, you can interact with EasyAppointments through its REST API. Here’s a sample JavaScript snippet showing how to create an appointment:

// EasyAppointments REST API Example
const API_URL = 'https://example-app.klutch.sh/api/v1';
const API_TOKEN = 'your_api_token_here';

// Create a new appointment
async function createAppointment() {
  const appointment = {
    start_datetime: '2024-06-15 10:00:00',
    end_datetime: '2024-06-15 11:00:00',
    id_users_provider: 1,
    id_users_customer: 2,
    id_services: 1,
    notes: 'Initial consultation appointment'
  };

  const response = await fetch(`${API_URL}/appointments`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${API_TOKEN}`
    },
    body: JSON.stringify(appointment)
  });

  const result = await response.json();
  console.log('Appointment created:', result);
  return result;
}

// Fetch available appointment times
async function getAvailableHours(providerId, serviceId, date) {
  const params = new URLSearchParams({
    provider_id: providerId,
    service_id: serviceId,
    date: date
  });

  const response = await fetch(`${API_URL}/availabilities?${params}`, {
    headers: {
      'Authorization': `Bearer ${API_TOKEN}`
    }
  });

  const hours = await response.json();
  console.log('Available hours:', hours);
  return hours;
}

This demonstrates EasyAppointments’ RESTful API architecture, making it easy to integrate with external applications and build custom booking interfaces.

Project Structure

Understanding EasyAppointments’ file structure helps with Docker configuration and persistent storage planning:

easyappointments-app/
├── application/              # CodeIgniter application
│   ├── config/              # Configuration files
│   │   ├── config.php       # Main configuration
│   │   ├── database.php     # Database configuration
│   │   └── email.php        # Email settings
│   ├── controllers/         # MVC controllers
│   ├── models/              # Data models
│   ├── views/               # View templates
│   └── libraries/           # Custom libraries
├── assets/                  # Frontend assets
│   ├── css/                 # Stylesheets
│   ├── js/                  # JavaScript files
│   └── img/                 # Images
├── storage/                 # Application storage
│   ├── uploads/             # User uploads
│   ├── sessions/            # Session data
│   ├── cache/               # Cache files
│   └── logs/                # Application logs
├── system/                  # CodeIgniter system files
├── vendor/                  # Composer dependencies
├── config-sample.php        # Sample configuration
├── composer.json            # PHP dependencies
└── index.php               # Application entry point

Key directories for persistence:

/var/www/html/storage — Uploads, sessions, cache, logs
/var/www/html/application/config — Configuration files (use env vars instead in production)

Creating a Production Dockerfile

Klutch.sh automatically detects and uses a Dockerfile when present in your repository’s root directory. Here’s a production-ready Dockerfile for EasyAppointments:

Basic Production Dockerfile

FROM php:8.1-apache

# Install system dependencies
RUN apt-get update && apt-get install -y \
    git \
    curl \
    libpng-dev \
    libonig-dev \
    libxml2-dev \
    libzip-dev \
    zip \
    unzip \
    mariadb-client \
    libfreetype6-dev \
    libjpeg62-turbo-dev \
    && rm -rf /var/lib/apt/lists/*

# Install PHP extensions
RUN docker-php-ext-configure gd --with-freetype --with-jpeg \
    && docker-php-ext-install pdo_mysql mbstring exif pcntl bcmath gd zip

# Enable Apache mod_rewrite
RUN a2enmod rewrite

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

# Set working directory
WORKDIR /var/www/html

# Copy application files
COPY . .

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

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

# Configure Apache
RUN sed -i 's!/var/www/html!/var/www/html!g' /etc/apache2/sites-available/000-default.conf \
    && echo '<Directory /var/www/html>\n\
    Options Indexes FollowSymLinks\n\
    AllowOverride All\n\
    Require all granted\n\
</Directory>' >> /etc/apache2/apache2.conf

# Expose port 80
EXPOSE 80

# Start Apache
CMD ["apache2-foreground"]

Advanced Multi-Stage Dockerfile

For smaller images and faster deployments, use a multi-stage build:

# Build stage
FROM composer:2 as builder

WORKDIR /app

COPY composer.json composer.lock ./
RUN composer install --no-dev --no-scripts --no-autoloader --prefer-dist

COPY . .
RUN composer dump-autoload --optimize --no-dev

# Production stage
FROM php:8.1-apache

# Install system dependencies
RUN apt-get update && apt-get install -y \
    libpng-dev \
    libonig-dev \
    libxml2-dev \
    libzip-dev \
    libfreetype6-dev \
    libjpeg62-turbo-dev \
    mariadb-client \
    && docker-php-ext-configure gd --with-freetype --with-jpeg \
    && docker-php-ext-install pdo_mysql mbstring exif pcntl bcmath gd zip \
    && rm -rf /var/lib/apt/lists/*

# Enable Apache modules
RUN a2enmod rewrite

# Set working directory
WORKDIR /var/www/html

# Copy application from builder
COPY --from=builder /app .

# Set permissions
RUN chown -R www-data:www-data storage \
    && chmod -R 775 storage

# Configure Apache
RUN echo '<Directory /var/www/html>\n\
    Options Indexes FollowSymLinks\n\
    AllowOverride All\n\
    Require all granted\n\
</Directory>' >> /etc/apache2/apache2.conf

# Create entrypoint script
COPY docker-entrypoint.sh /usr/local/bin/
RUN chmod +x /usr/local/bin/docker-entrypoint.sh

EXPOSE 80

ENTRYPOINT ["docker-entrypoint.sh"]
CMD ["apache2-foreground"]

Docker Entrypoint Script

Create docker-entrypoint.sh for initialization tasks:

#!/bin/bash
set -e

# Wait for database to be ready
echo "Waiting for database connection..."
until php -r "new PDO('mysql:host=${DB_HOST};port=${DB_PORT}', '${DB_USERNAME}', '${DB_PASSWORD}');" > /dev/null 2>&1; do
  echo "Database not ready, waiting..."
  sleep 3
done

echo "Database connected!"

# Set up configuration from environment variables
if [ ! -f "config.php" ]; then
  echo "Creating configuration from environment variables..."
  cp config-sample.php config.php

  # Update config.php with environment variables
  sed -i "s/DB_HOST = '.*'/DB_HOST = '${DB_HOST}'/" config.php
  sed -i "s/DB_NAME = '.*'/DB_NAME = '${DB_NAME}'/" config.php
  sed -i "s/DB_USERNAME = '.*'/DB_USERNAME = '${DB_USERNAME}'/" config.php
  sed -i "s/DB_PASSWORD = '.*'/DB_PASSWORD = '${DB_PASSWORD}'/" config.php
  sed -i "s|BASE_URL = '.*'|BASE_URL = '${BASE_URL}'|" config.php
fi

echo "EasyAppointments is ready!"

# Execute the main command
exec "$@"

Persistent Storage Configuration

EasyAppointments requires persistent storage for uploaded files, session data, and logs. Klutch.sh provides persistent volumes that survive deployments and restarts.

Setting Up Persistent Volumes

Identify required persistent directories
- /var/www/html/storage — File uploads, session data, cache, logs
- /var/www/html/application/config — Configuration files (optional, prefer env vars)
Create a persistent volume in Klutch.sh

In the Klutch.sh dashboard, navigate to your app settings:
- Click “Add Volume”
- Set Mount Path: /var/www/html/storage
- Set Size: 5GB (adjust based on expected file uploads)
- Save the configuration

Update Dockerfile permissions

Ensure the Docker user has write access:

RUN chown -R www-data:www-data /var/www/html/storage \
    && chmod -R 775 /var/www/html/storage

Verify persistence after deployment

After deploying, upload test files through EasyAppointments and redeploy to confirm files persist.

Database Setup and Configuration

EasyAppointments requires a MySQL database. You can use Klutch.sh’s database offerings or an external managed database.

Option 1: Using Klutch.sh MySQL

Provision a MySQL database

See the MySQL deployment guide for detailed instructions on provisioning a database on Klutch.sh.
Note the connection details

After provisioning, you’ll receive:
- Host address (e.g., mysql-app.klutch.sh)
- Port (typically 8000 for TCP traffic)
- Database name
- Username and password
Configure environment variables

Set these in your Klutch.sh app configuration (see next section).

Option 2: External MySQL Database

You can use any MySQL-compatible database:

Managed MySQL services (AWS RDS, Google Cloud SQL, DigitalOcean Managed Databases)
Self-hosted MySQL instances
PlanetScale, Supabase, or other MySQL providers

Ensure network connectivity between Klutch.sh and your database server, and note the connection credentials for environment variable configuration.

Environment Variables

Configure EasyAppointments by setting environment variables in the Klutch.sh dashboard. These replace configuration files in production.

Required Environment Variables

# Application
BASE_URL=https://example-app.klutch.sh
APP_ENV=production

# Database
DB_HOST=your-database-host
DB_PORT=3306
DB_NAME=easyappointments
DB_USERNAME=your_db_user
DB_PASSWORD=your_secure_password

# Email Configuration (for notifications)
SMTP_HOST=smtp.gmail.com
SMTP_PORT=587
SMTP_USERNAME=your_email@gmail.com
SMTP_PASSWORD=your_email_password
SMTP_PROTOCOL=smtp
SMTP_CRYPTO=tls
SMTP_FROM_EMAIL=noreply@yourdomain.com
SMTP_FROM_NAME=EasyAppointments

# Google Calendar Integration (optional)
GOOGLE_SYNC_FEATURE=true
GOOGLE_CLIENT_ID=your_google_client_id
GOOGLE_CLIENT_SECRET=your_google_client_secret
GOOGLE_API_KEY=your_google_api_key

Optional Environment Variables

# Session Configuration
SESSION_DRIVER=file
SESSION_LIFETIME=120

# Cache Configuration
CACHE_DRIVER=file

# Timezone
TIMEZONE=America/New_York

# Language
LANGUAGE=english

# Company Information
COMPANY_NAME=Your Company Name
COMPANY_EMAIL=info@yourcompany.com
COMPANY_LINK=https://yourcompany.com

Customizing Commands with Nixpacks

If you need to customize the build or start command (though the Dockerfile handles this), you can use Nixpacks environment variables:

NIXPACKS_BUILD_CMD — Custom build command
NIXPACKS_START_CMD — Custom start command (e.g., apache2-foreground)

However, when using a Dockerfile, Klutch.sh automatically uses the Dockerfile’s CMD and ENTRYPOINT directives.

Deploying to Klutch.sh

Now that your Dockerfile and configuration are ready, follow these steps to deploy EasyAppointments to Klutch.sh.

Deployment Steps

Push your repository to GitHub

Ensure your repository contains:
- Dockerfile (in the root directory)
- docker-entrypoint.sh (if using the entrypoint script)
- EasyAppointments application files
- .dockerignore file (to exclude unnecessary files)
Terminal window
```
git add .
git commit -m "Add Dockerfile for Klutch.sh deployment"
git push origin main
```
Log in to Klutch.sh

Navigate to klutch.sh/app
Create a new project
- Click “New Project”
- Enter a project name (e.g., “Appointment Booking”)
- Save the project
Create a new app
- Click “New App” within your project
- Connect your GitHub repository
- Select the repository containing your EasyAppointments code
- Select the branch (e.g., main or production)
Configure app settings
- Traffic Type: Select HTTP (EasyAppointments is a web application)
- Internal Port: Set to 80 (the port Apache listens on in the container)
- Region: Choose the region closest to your users
- Compute Resources: Select appropriate CPU and memory (start with 1 CPU, 1GB RAM)
- Instances: Set to 1 (scale up later based on traffic)
Add environment variables

Click “Add Environment Variable” and enter all required variables from the previous section:
- Database credentials (DB_HOST, DB_NAME, DB_USERNAME, DB_PASSWORD)
- Base URL (BASE_URL — use your Klutch.sh URL or custom domain)
- Email configuration (SMTP_HOST, SMTP_USERNAME, SMTP_PASSWORD)
- Google Calendar credentials (if using synchronization)
Attach persistent volumes
- Click “Add Volume”
- Mount Path: /var/www/html/storage
- Size: 5GB (or more based on needs)
- Save the volume configuration
Deploy the application

Click “Create App” or “Deploy”

Klutch.sh will:
- Clone your repository
- Detect the Dockerfile automatically
- Build the Docker image
- Deploy the container with your configuration
- Expose the app on HTTP with automatic routing
Monitor the deployment

Watch the build logs to ensure successful deployment. The process typically takes 3-5 minutes.
Access your EasyAppointments installation

Once deployed, access your app at the provided URL:
- https://example-app.klutch.sh
Complete the initial EasyAppointments setup in your browser if not already completed.

Custom Domain Configuration

To use your own domain with EasyAppointments on Klutch.sh:

Add a custom domain in Klutch.sh
- Go to your app settings in the Klutch.sh dashboard
- Navigate to “Domains” section
- Click “Add Custom Domain”
- Enter your domain (e.g., appointments.yourdomain.com)
Configure DNS records

Update your DNS provider with the records provided by Klutch.sh:
- Add a CNAME record pointing to your Klutch.sh app
- Or add A/AAAA records as instructed
Update BASE_URL environment variable

In your app settings, update:
Terminal window
```
BASE_URL=https://appointments.yourdomain.com
```
Wait for DNS propagation

DNS changes can take up to 48 hours, but typically propagate within minutes.
Verify SSL certificate

Klutch.sh automatically provisions SSL certificates for custom domains. Once DNS propagates, your site will be accessible via HTTPS.

For more details, see the custom domains documentation.

Post-Deployment Configuration

After deploying EasyAppointments, complete these configuration steps:

Initial Setup

Access your EasyAppointments URL

Visit your deployed app URL (e.g., https://example-app.klutch.sh)
Complete installation wizard (if needed)

If accessing for the first time, EasyAppointments may guide you through:
- Database setup verification
- Creating the admin account
- Basic company information
Log in to the admin panel

Use your admin credentials to access the backend at /backend
Configure general settings
- Navigate to Settings → General
- Set company name, email, and contact information
- Configure booking page settings
- Set appointment advance time limits
- Configure time slot intervals
Set up services
- Navigate to Services
- Add services your business offers (e.g., “Haircut”, “Consultation”)
- Set service duration, price, and description
- Assign service categories
Add service providers
- Navigate to Users → Providers
- Add provider accounts
- Set individual schedules and working hours
- Assign services to each provider

Configuring Email Notifications

EasyAppointments sends automated emails for confirmations and reminders:

Configure SMTP settings

Ensure environment variables are set correctly:

SMTP_HOST=smtp.gmail.com
SMTP_PORT=587
SMTP_USERNAME=your_email@gmail.com
SMTP_PASSWORD=your_app_password

Test email delivery
- Create a test appointment
- Verify confirmation emails are sent
- Check spam folders if emails don’t arrive
Customize email templates
- Navigate to Settings → Email
- Customize email subject lines and content
- Add company branding and logos

Google Calendar Synchronization

To enable Google Calendar sync:

Create Google API credentials
- Visit Google Cloud Console
- Create a new project
- Enable Google Calendar API
- Create OAuth 2.0 credentials
- Set authorized redirect URIs to your EasyAppointments URL

Configure environment variables

GOOGLE_SYNC_FEATURE=true
GOOGLE_CLIENT_ID=your_client_id
GOOGLE_CLIENT_SECRET=your_client_secret
GOOGLE_API_KEY=your_api_key

Connect provider calendars
- Each provider can connect their Google Calendar
- Navigate to Settings → Google Calendar
- Authorize the connection
- Appointments will sync bidirectionally

Scaling and Performance

As your appointment traffic grows, optimize EasyAppointments performance:

Vertical Scaling

Increase compute resources in Klutch.sh:

Navigate to app settings
Adjust CPU and memory allocation
Recommended for busy clinics: 2 CPU, 2GB RAM
For high-traffic scenarios: 4 CPU, 4GB RAM

Horizontal Scaling

Run multiple instances:

Increase instance count in app settings
Klutch.sh automatically load-balances traffic

Ensure session storage uses database instead of files:

// In config.php
$config['sess_driver'] = 'database';
$config['sess_save_path'] = 'ci_sessions';

Run database migrations to create session table

Database Optimization

Use connection pooling
Add indexes to frequently queried tables (appointments, customers)
Regular database maintenance and optimization
Consider read replicas for high-traffic deployments
Monitor slow queries and optimize

Caching Strategy

For high-traffic deployments, implement caching:

Use Redis for session storage
Cache API responses
Enable browser caching for static assets
Use CDN for asset delivery

Monitoring and Maintenance

Application Monitoring

Monitor your EasyAppointments deployment:

Check application logs in Klutch.sh dashboard
Set up uptime monitoring (UptimeRobot, Pingdom)
Monitor database performance and connection pool
Track booking metrics in EasyAppointments admin panel
Set up error notifications via email

Regular Maintenance

Update EasyAppointments regularly
Terminal window
```
git pull upstream master
composer update
git push origin main
```
Klutch.sh will automatically rebuild and redeploy.
Database backups
- Schedule regular database backups
- Test restoration procedures monthly
- Store backups in multiple locations
- Consider automated backup solutions
Security updates
- Keep PHP and system packages updated
- Rebuild Docker images regularly to get security patches
- Update composer dependencies
- Monitor security advisories for CodeIgniter
Performance reviews
- Review slow queries monthly
- Optimize images and assets
- Clean up old log files
- Archive old appointments (older than 2 years)
- Vacuum and optimize database tables

Troubleshooting

Common issues and solutions:

Issue: Application shows 500 error

Check logs in /var/www/html/storage/logs
Verify database connection credentials
Ensure storage/ directory has write permissions
Check Apache error logs: docker logs <container_id>

Issue: Database connection failed

Verify DB_HOST, DB_PORT, DB_USERNAME, DB_PASSWORD
Test connection: mysql -h $DB_HOST -P $DB_PORT -u $DB_USERNAME -p
Check network connectivity between app and database
Verify database server is running

Issue: Emails not sending

Test SMTP credentials manually
Check firewall allows outbound SMTP traffic (port 587 or 465)
Verify SMTP_* environment variables
Check spam folders
Enable SMTP debugging in config

Issue: File uploads failing

Verify persistent volume is mounted at /var/www/html/storage
Check disk space on volume
Verify write permissions: chown -R www-data:www-data storage
Check PHP upload limits in php.ini

Issue: Google Calendar sync not working

Verify Google API credentials
Check authorized redirect URIs match your domain
Ensure Google Calendar API is enabled
Check provider has authorized connection
Review API quota limits

Issue: Booking page not loading

Verify Apache mod_rewrite is enabled
Check .htaccess file exists and is readable
Verify BASE_URL matches your domain
Check for JavaScript errors in browser console

Security Best Practices

Protect your EasyAppointments installation:

Use HTTPS exclusively
- Always set BASE_URL to https://
- Klutch.sh provides automatic SSL certificates
- Never disable SSL validation in production
Secure environment variables
- Never commit secrets to Git
- Use Klutch.sh’s secure environment variable storage
- Rotate database passwords regularly
- Use strong, unique passwords
Database security
- Use strong, unique database passwords
- Limit database user privileges to only required operations
- Enable database firewall rules
- Use private networking when possible
- Regular security audits
Application hardening
- Keep EasyAppointments and dependencies updated
- Disable directory listing
- Implement rate limiting for booking endpoints
- Enable CSRF protection (enabled by default in CodeIgniter)
- Sanitize all user inputs
Access control
- Use strong admin passwords
- Limit admin access by IP if possible
- Regularly audit user accounts
- Remove unused provider accounts
- Implement two-factor authentication if available
Data privacy and GDPR
- Enable GDPR consent features
- Document data retention policies
- Provide customer data export functionality
- Implement data deletion upon request
- Maintain audit logs for data access
Backup and disaster recovery
- Schedule automated daily backups
- Test restoration procedures monthly
- Store backups in different geographic regions
- Document recovery procedures
- Maintain backup retention policy

Cost Optimization

Optimize your Klutch.sh hosting costs:

Right-size compute resources: Start with 1 CPU, 1GB RAM and scale based on actual usage
Use efficient Docker images: Multi-stage builds reduce image size and build time
Implement caching: Reduce database queries with application and browser caching
Optimize storage: Regularly clean up old logs and session files
Monitor usage: Track metrics to identify optimization opportunities
Schedule scaling: Consider time-based scaling for businesses with peak hours

Advanced Configuration

Enabling the REST API

EasyAppointments includes a comprehensive REST API:

Generate API token
- Log in as admin
- Navigate to Settings → API
- Generate new API token
- Save token securely
Configure API permissions
- Set allowed origins for CORS
- Define rate limits
- Enable/disable specific API endpoints

Test API access

curl -X GET "https://example-app.klutch.sh/api/v1/appointments" \
  -H "Authorization: Bearer your_api_token"

Customizing the Booking Interface

Customize the booking page appearance:

/* Add to custom.css */
.booking-header {
  background-color: #007bff;
  color: white;
}

.service-card {
  border-radius: 10px;
  box-shadow: 0 2px 4px rgba(0,0,0,0.1);
}

.book-button {
  background-color: #28a745;
  font-weight: bold;
}

Mount custom CSS via persistent volume or include in Docker image.

Multi-Location Setup

Run multiple instances for different locations:

Deploy separate EasyAppointments instances per location
Use custom domains for each location
Share a central database or use separate databases
Implement custom authentication for multi-tenant scenarios

Resources

Conclusion

Deploying EasyAppointments on Klutch.sh provides a robust, scalable solution for appointment scheduling and booking management. With automatic Dockerfile detection, persistent storage, secure environment variables, and built-in SSL, Klutch.sh simplifies the deployment process while maintaining production-grade reliability.

This guide covered local installation for development, creating optimized Dockerfiles, configuring databases and persistent storage, setting environment variables, deploying to Klutch.sh with detailed steps, adding custom domains, scaling for high traffic, implementing security best practices, and maintaining your deployment long-term.

Whether you’re managing a small clinic, running a multi-location salon, or building a booking platform for your business, EasyAppointments on Klutch.sh gives you professional appointment management capabilities with minimal operational overhead. Start your deployment today and experience the power of self-hosted appointment scheduling.