Deploying a Claper App

Claper is the #1 open-source interactive presentation platform that transforms how you engage with your audience. With Claper, you can create dynamic, real-time interactions including live Q&A, instant polls, interactive quizzes, forms, and feedback mechanisms. Whether you’re hosting corporate meetings, educational lectures, conferences, or training workshops, Claper empowers every voice and creates vibrant, engaging conversations. Supported by PDF and PowerPoint imports, multi-language interface (English, French, German, Spanish, Dutch, Italian), LMS integration with Moodle, and comprehensive analytics, Claper makes it effortless to transform passive presentations into interactive experiences with real-time audience engagement.

This comprehensive guide walks through deploying Claper to Klutch.sh using a Dockerfile for reliable, containerized deployment. You’ll learn how to set up Claper with persistent storage for presentations and event data, create a production-ready Dockerfile, configure the web interface, set up real-time collaboration features, manage presentations and interactive elements, implement security best practices, configure custom domains, set up monitoring, and troubleshoot common issues. By the end of this guide, you’ll have a production-ready Claper instance running on Klutch.sh’s global infrastructure with automatic HTTPS, optimized performance, and reliable hosting for interactive events.

Prerequisites

Docker installed locally for testing (optional but recommended)
Git installed locally and a GitHub account (Klutch.sh uses GitHub as the only git source)
Klutch.sh account with access to the dashboard at klutch.sh/app
Text editor or IDE for code editing (VS Code recommended)
Node.js knowledge (helpful but not required)
Basic networking knowledge: Understanding of HTTP/HTTPS and DNS

Understanding Claper Architecture

Technology Stack

Backend:

Node.js/Express.js server
WebSocket support for real-time updates
PostgreSQL database for persistent storage
Redis (optional) for caching and real-time features

Frontend:

Modern web application (React/Vue-based)
Real-time WebSocket connections
Responsive design for desktop, tablet, mobile

Key Features

Interactive Elements:

Q&A: Real-time audience questions with moderation
Polls: Live polling with instant results visualization
Quizzes: Interactive knowledge assessments
Forms: Custom data collection
Web Content: Embed external content

Presentation Management:

PDF upload and support
PowerPoint presentation support
Slide navigation and organization
Presentation statistics and analytics

Collaboration:

Multi-user event management
Real-time participant updates
Moderation tools and controls
Export and reporting capabilities

Multi-language Support:

English, French, German, Spanish, Dutch, Italian
Extensible for additional languages

Project Setup

1. Create Project Directory

Create a project directory for Claper deployment:

mkdir claper-deployment
cd claper-deployment
git init

2. Create Directory Structure

Create necessary directories:

mkdir -p {uploads,data,backup,scripts,config}

Resulting project structure:

claper-deployment/
├── Dockerfile
├── docker-compose.yaml (for local testing)
├── entrypoint.sh
├── config/
│   └── default.env
├── scripts/
│   └── init-db.sh
├── data/
│   └── (persistent database)
├── uploads/
│   └── (presentation uploads)
├── .dockerignore
├── .gitignore
└── README.md

3. Create .gitignore File

Create .gitignore to exclude unnecessary files:

.env.local
.env.*.local
*.log
*.swp
.DS_Store
.vscode
.idea
node_modules/
data/
uploads/
backup/
tmp/

4. Create .dockerignore File

Create .dockerignore to exclude files from Docker build:

.git
.gitignore
*.log
.env.local
node_modules
data/
uploads/
backup/
tmp/
.DS_Store
.vscode
.idea
docker-compose.yaml

Creating a Production Dockerfile

Create a Dockerfile for production deployment:

# === Build Stage ===
FROM node:20-alpine AS builder

WORKDIR /app

# Install dependencies
RUN apk add --no-cache python3 make g++ cairo-dev jpeg-dev pango-dev giflib-dev

# Clone and build Claper from source
RUN git clone https://github.com/ClaperCo/Claper.git . && \
    npm ci && \
    npm run build && \
    npm prune --production

# === Production Stage ===
FROM node:20-alpine

WORKDIR /app

# Install runtime dependencies
RUN apk add --no-cache tini curl

# Copy built application from builder
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/package*.json ./

# Create app user
RUN addgroup -g 1001 -S nodejs && \
    adduser -S nodejs -u 1001

# Create data directories
RUN mkdir -p /app/uploads /app/data && \
    chown -R nodejs:nodejs /app

# Copy entrypoint script
COPY entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh

# Use tini to handle signals properly
ENTRYPOINT ["/sbin/tini", "--"]

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

# Expose port
EXPOSE 3000

# Set user
USER nodejs

# Start application
CMD ["node", "dist/server.js"]

Dockerfile Explanation

Build stage: Compiles Claper from source with all dependencies
Production stage: Lightweight runtime with only production dependencies
Data persistence: /app/uploads for presentations and /app/data for database
Non-root user: Runs as nodejs user for security
Health checks: Automatic container health monitoring
Signal handling: Uses tini for proper signal handling
Multi-stage build: Reduces final image size significantly

Create Entrypoint Script

Create entrypoint.sh for initialization:

#!/bin/sh

set -e

echo "Starting Claper initialization..."

# Wait for database if needed
if [ -n "$DATABASE_URL" ]; then
    echo "Waiting for database to be ready..."
    timeout 30 sh -c 'until nc -z $(echo $DATABASE_URL | sed "s/.*@//g" | cut -d: -f1) $(echo $DATABASE_URL | sed "s/.*://g" | cut -d/ -f1); do sleep 1; done' || true
fi

# Run migrations if needed
if [ "$RUN_MIGRATIONS" = "true" ]; then
    echo "Running database migrations..."
    npm run migrate || true
fi

echo "Claper startup complete. Starting server..."

# Start the application
exec node dist/server.js

Building the Dockerfile Locally (Optional)

Test the Dockerfile locally:

# Build the Docker image
docker build -t claper:latest .

# Run the container locally (for testing only)
docker run -d \
  --name claper-test \
  -p 3000:3000 \
  -e NODE_ENV=production \
  -v claper-uploads:/app/uploads \
  -v claper-data:/app/data \
  claper:latest

# Wait for container to start
sleep 10

# Access the application
# http://localhost:3000

Deploying with Docker on Klutch.sh

Klutch.sh automatically detects a Dockerfile in your repository root and uses it for deployment.

Prerequisites for Docker Deployment

Your Claper project pushed to GitHub with Dockerfile
Database credentials prepared (PostgreSQL recommended for production)
Planned storage for presentations and data

Steps to Deploy with Docker

Prepare Your Repository

Commit and push all necessary files:

git add Dockerfile entrypoint.sh .dockerignore
git commit -m "Add Docker deployment configuration for Claper"
git push origin main

Log In to Klutch.sh Dashboard
Go to klutch.sh/app and sign in with your GitHub account.
Create a Project
Navigate to the Projects section and create a new project for your Claper instance.
Create an App
Click “Create App” and select your GitHub repository containing the Claper Docker configuration.
Select the Branch
Choose the branch you want to deploy (typically main).
Configure Traffic Type
Select HTTP as the traffic type for Claper (a web application).
Set the Internal Port
Set the internal port to 3000 – this is the port where Claper server listens.

Add Environment Variables**
Configure environment variables for your Claper instance:

NODE_ENV=production LOG_LEVEL=info # Database Configuration DATABASE_URL=postgresql://user:password@db.example.com:5432/claper REDIS_URL=redis://redis.example.com:6379 # Application Configuration CLAPER_HOST=example-app.klutch.sh CLAPER_PORT=3000 CLAPER_SECURE=true # File Upload Configuration MAX_UPLOAD_SIZE=104857600 UPLOAD_PATH=/app/uploads # Email Configuration (for notifications) SMTP_HOST=smtp.example.com SMTP_PORT=587 SMTP_USER=your-email@example.com SMTP_PASS=your-password SMTP_FROM=no-reply@example.com # Authentication JWT_SECRET=your-super-secret-jwt-key-change-this SESSION_SECRET=your-super-secret-session-key # Feature Flags ENABLE_REGISTRATION=true ENABLE_MOODLE_INTEGRATION=false RUN_MIGRATIONS=true TZ=UTC

Replace with your actual values.

Configure Persistent Storage**
Claper needs persistent volumes for uploads and data:

After creating the app, go to Volumes

Add volume for presentations and data:

Mount path: /app/uploads

Size: 10-50 GiB (adjust based on expected presentations)

Add volume for database (if using embedded SQLite):

Mount path: /app/data

Size: 5-20 GiB

Configure Compute Resources**
Select appropriate resources:

Minimum: 1-2 CPU, 1-2 GB RAM (small events, <50 participants)

Recommended: 2-4 CPU, 2-4 GB RAM (medium events, 50-500 participants)

Large: 4-8 CPU, 4-8 GB RAM (large events, 500+ participants)

Select region closest to your primary audience.

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

Build the Docker image

Start the Claper container

Assign a public URL (e.g., example-app.klutch.sh)

Configure HTTPS automatically

Complete Initial Setup**
After deployment, access your Claper instance:

Navigate to https://example-app.klutch.sh

Create your administrator account

Configure application settings:

Organization name

Email notifications

Custom branding

Storage and upload limits

Invite team members

Test Interactive Features**
Verify all features are working:

Create a test event

Upload a test presentation (PDF or PPT)

Test Q&A functionality

Test polls and quizzes

Verify real-time updates

Test participant join flow

Review analytics and reporting

Claper Features and Configuration

1. Event Management

Create and manage interactive events:

Event Types:

Conferences and seminars

Educational lectures

Corporate training

Webinars and online events

Workshops and breakout sessions

Event Configuration:

Title, description, date/time

Participant capacity limits

Access controls (public, invite-only, password-protected)

Event scheduling

Participant registration

Configure in admin dashboard:

Go to Events

Click Create Event

Set event details and settings

Upload presentations or content

Enable interactive features

2. Q&A Management

Real-time question handling:

Q&A Features:

Audience submits questions in real-time

Questions displayed on moderator dashboard

Moderation tools (approve, reject, pin)

Question sorting by popularity (votes)

Answer/resolve individual questions

Chat-like interface for participants

Enable Q&A:

In event settings, enable Q&A module

Configure moderation requirements

Allow anonymous questions (optional)

Set question display order (recent/popular)

3. Polling

Create dynamic live polls:

Poll Types:

Multiple choice

Single answer

Rating scales

Free text responses

Image selection

Poll Features:

Real-time results visualization

Pie charts and bar graphs

Export poll results

Duplicate poll option

Anonymous voting

Launch polls from moderator dashboard:

Click Create Poll

Define poll question and options

Set time limit for voting

Launch to participants

View real-time results

4. Quizzes

Interactive knowledge assessments:

Quiz Features:

Multiple question types

Scoring and feedback

Time-limited questions

Automatic grading

Export quiz results

Participant performance tracking

Create quiz:

In presentation editing, add quiz slide

Define questions with multiple choice answers

Set correct answers

Configure point values

Add feedback for answers

5. Presentations

Manage and present content:

Supported Formats:

PDF presentations

PowerPoint files

Image slides

Web content (iframe)

Mixed content presentations

Presentation Features:

Slide thumbnails and navigation

Speaker notes

Slide timing

Custom branding

Fullscreen mode

Mobile-optimized viewing

Upload presentation:

In event settings, click Upload Presentation

Select PDF, PPT, or images

Preview and organize slides

Add interactive elements to specific slides

Configure presentation settings

6. Participant Management

Manage event attendees:

Participant Features:

Registration tracking

Attendance monitoring

Participant list

Engagement scoring

Export participant data

Email communications

View participants:

In event dashboard, go to Participants

View registration status

Track engagement metrics

Export participant list

Send communications

7. Analytics and Reporting

Comprehensive engagement insights:

Analytics Available:

Attendance rate

Engagement score

Q&A participation

Poll response rates

Quiz performance

Interaction timeline

Participant feedback

Access analytics:

In event dashboard, go to Analytics

View engagement metrics

Review question popularity

Analyze poll results

Export comprehensive reports

8. Integration with Moodle

Connect to learning management systems:

Moodle Integration:

Import quizzes from Moodle courses

Sync participant data

Export results back to Moodle

Gradebook integration

Course enrollment sync

Enable Moodle integration:

In admin settings, enable Moodle integration

Configure Moodle connection details

Authenticate with Moodle instance

Link events to courses

Configure data synchronization

Persistent Storage

Claper requires persistent storage for presentations and event data:

Critical Data Directories

/app/uploads/ ├── presentations/ (uploaded PDF/PPT files) ├── exports/ (exported reports and data) └── media/ (images and media files) /app/data/ └── (database files if using SQLite)

Adding Persistent Volumes

In Klutch.sh dashboard, go to your Claper app

Navigate to Volumes section

Add volume for /app/uploads:

Mount path: /app/uploads

Size: 10-50 GiB

Optionally add volume for /app/data:

Mount path: /app/data

Size: 5-20 GiB

Backup Strategy

Implement regular backup routine:

#!/bin/bash # Daily backup script BACKUP_DIR="/backups/claper" DATE=$(date +%Y%m%d_%H%M%S) RETENTION_DAYS=30 # Create backup directory mkdir -p $BACKUP_DIR # Backup uploads tar -czf $BACKUP_DIR/uploads_$DATE.tar.gz /app/uploads/ # Backup database (if using PostgreSQL via CLI) # pg_dump -h $DB_HOST -U $DB_USER $DB_NAME | gzip > $BACKUP_DIR/db_$DATE.sql.gz # Delete old backups find $BACKUP_DIR -name "*_*.tar.gz" -mtime +$RETENTION_DAYS -delete find $BACKUP_DIR -name "db_*.sql.gz" -mtime +$RETENTION_DAYS -delete # Upload to remote storage # aws s3 sync $BACKUP_DIR s3://my-backup-bucket/claper/

Security Best Practices

1. HTTPS/SSL Enforcement

Klutch.sh automatically provides HTTPS for your web interface. All traffic is encrypted by default.

2. Authentication and Authorization

Implement strong access control:

User Roles:

Administrator: Full system access

Moderator: Event management and moderation

Speaker: Present and moderate events

Participant: Join and participate in events

Configure in admin panel:

Go to User Management

Create user accounts with appropriate roles

Set password requirements

Enable two-factor authentication (if available)

Regular access audits

3. Data Privacy

Protect participant data:

Configuration: - Anonymize participant data (optional) - Restrict data exports to authorized users - Set data retention policies - Enable GDPR compliance mode - Configure privacy notices

4. Presentation Security

Protect uploaded presentations:

Access control per event (public/private)

Participants can only view event they joined

Download restrictions (disable download if needed)

Watermarking support (branding)

Activity logging for all accesses

5. Event Security

Secure event access:

Access Control Options:

Public events (anyone can join)

Invite-only events

Password-protected events

Registration required

Participant list visibility (show/hide)

6. Database Security

Secure database connections:

Use strong database passwords

Enforce SSL/TLS for database connections

Restrict database access to application

Regular database backups

Encryption at rest (if available)

7. API Security

If enabling API access:

- Require API authentication - Generate secure API keys - Set API rate limits - Log all API access - Restrict API permissions - Rotate keys regularly

Performance Optimization

1. WebSocket Optimization

Configure WebSocket for real-time features:

Environment variables: WEBSOCKET_HEARTBEAT=30000 WEBSOCKET_TIMEOUT=120000 MAX_WEBSOCKET_CONNECTIONS=10000

2. Database Optimization

Optimize database performance:

Configuration: - Add appropriate indexes - Enable query caching - Optimize table structure - Regular VACUUM/ANALYZE

3. Caching Strategy

Implement multi-layer caching:

Application Caching:

Event data caching

Presentation metadata caching

User session caching

Redis for distributed caching

Browser Caching:

Configure in reverse proxy (if available): - Cache static assets (CSS, JS, images) - Set 1-year expiration for immutable assets - Implement cache busting for updates

4. Resource Monitoring

Monitor system resources:

Terminal window
# Monitor memory usage free -h # Monitor disk usage df -h /app/uploads /app/data # Monitor CPU usage top # Check Node.js process ps aux | grep node # View application logs docker logs <container_id>

5. Connection Pooling

Configure database connection pooling:

MAX_DB_CONNECTIONS=20 DB_IDLE_TIMEOUT=900000 DB_ACQUISITION_TIMEOUT=30000

Monitoring and Logging

1. Access Application Logs

View Claper logs through Klutch.sh:

Go to your app in Klutch.sh

Click Logs

Filter by time range and log level

2. Configure Structured Logging

Configure logging levels:

LOG_LEVEL=info Available levels: - error: Errors only - warn: Warnings and errors - info: Info, warnings, errors (default) - debug: Debug messages and above - trace: All messages

3. Monitor Real-Time Metrics

Track real-time performance:

Metrics to monitor: - Active WebSocket connections - Participant counts per event - API response times - Database query performance - Memory and CPU usage

4. Health Checks

Configure health monitoring:

#!/bin/bash # Health check script # Check HTTP endpoint curl -f http://localhost:3000/health || exit 1 # Check database connectivity curl -f http://localhost:3000/health/db || exit 1 # Check critical services curl -f http://localhost:3000/health/services || exit 1 exit 0

5. Monitoring Integration

Integrate with monitoring services:

Prometheus: Metrics collection

Grafana: Visualization dashboards

DataDog: Infrastructure monitoring

New Relic: Performance monitoring

Sentry: Error tracking

Custom Domains

To use a custom domain with your Claper instance:

1. Add Domain in Klutch.sh

In the Klutch.sh dashboard, go to your app settings and add your custom domain (e.g., events.example.com).

2. Update DNS Configuration

Update your DNS provider:

CNAME: events.example.com → example-app.klutch.sh

3. Update Environment Variables

Update Claper configuration:

CLAPER_HOST=events.example.com CLAPER_SECURE=true

Redeploy the application to apply changes.

4. Verify DNS Propagation

Check DNS resolution:

Terminal window
nslookup events.example.com # or dig events.example.com CNAME

Once propagated, your Claper instance will be accessible at your custom domain with automatic HTTPS.

Troubleshooting

Issue 1: Container Won’t Start

Error: Container exits immediately or doesn’t respond

Solutions:

Check Docker logs: docker logs container_id

Verify Dockerfile builds locally: docker build -t claper:test .

Ensure environment variables are set correctly

Check for missing dependencies in build

Verify entrypoint script has execute permissions

Issue 2: Cannot Access Web Interface

Error: 503 Service Unavailable or connection timeout

Solutions:

Verify Claper is running: Check container status

Verify port 3000 is exposed and traffic is HTTP

Check firewall rules: Ensure port 3000 is accessible

Verify DNS resolution: dig example-app.klutch.sh

Check application logs for startup errors

Wait for full initialization: Container may need time on first start

Issue 3: Presentations Not Uploading

Error: Upload fails or file not saved

Solutions:

Verify persistent volume is mounted: Check /app/uploads exists

Check disk space: df -h /app/uploads

Check file permissions: Ensure container user can write

Verify file size under limit: Check MAX_UPLOAD_SIZE

Review application logs for upload errors

Check browser console for client-side errors

Issue 4: Real-Time Features Not Working

Error: WebSocket connections fail, real-time updates don’t appear

Solutions:

Verify WebSocket support: Check firewall doesn’t block WSS

Check browser WebSocket support: Use modern browser

Verify environment variables: WEBSOCKET_* settings

Review application logs for WebSocket errors

Check network connectivity: High latency may cause issues

Disable browser extensions that might interfere

Issue 5: Participant Join Issues

Error: Participants cannot join events or get connection errors

Solutions:

Verify event exists and is published

Check event access controls: Ensure participants have access

Verify maximum participant limit not exceeded

Check network bandwidth: High participant load requires bandwidth

Review participant connection logs

Test with different browsers/devices

Check firewall rules for WebSocket ports

Issue 6: Database Connection Issues

Error: “Cannot connect to database” errors

Solutions:

Verify database is running and accessible

Check DATABASE_URL environment variable format

Test database connection manually

Verify database credentials are correct

Check firewall allows database access

Verify database user has proper permissions

Check database logs for connection issues

Issue 7: Performance Issues

Error: Slow response times or high latency

Solutions:

Monitor resource usage: CPU, memory, disk

Check database query performance

Enable caching if available

Increase container resources in Klutch.sh

Review WebSocket connection counts

Archive old events to reduce database size

Check network bandwidth usage

Monitor third-party API calls

Issue 8: Data Loss or Corruption

Error: Missing presentations or event data after restart

Solutions:

Verify persistent volumes are mounted correctly

Check volume mount paths in Klutch.sh

Verify data persisted after container stop

Check disk space hasn’t run out

Review backup strategy and recent backups

Restore from backups if necessary

Check for database corruption: Run integrity checks

Best Practices

1. Event Preparation

Thoroughly prepare before events:

Test all interactive features

Preview presentations and slides

Test with expected participant count

Verify audio/video if applicable

Brief team on moderation tools

Have backup plans for technical issues

Schedule dry-run session

Document event procedures

2. Real-Time Engagement

Maximize audience engagement:

Start with icebreaker poll

Encourage questions frequently

Respond to popular questions first

Use polls to gauge understanding

Keep pace manageable for participants

Mix different interaction types

Show participant enthusiasm (votes, reactions)

Provide real-time feedback

3. Moderation Best Practices

Manage participant interactions effectively:

Monitor Q&A actively during event

Filter inappropriate questions

Pin important questions

Group similar questions

Allocate specific time for Q&A

Thank participants for questions

Follow up on unanswered questions

Save interactions for post-event review

4. Data Management

Properly manage event data:

Regular backups of all events

Archive completed events

Export important data promptly

Document event outcomes

Review analytics after each event

Clean up old temporary data

Secure sensitive participant information

Maintain audit trail of changes

5. User Administration

Manage user accounts effectively:

Create appropriate role hierarchy

Regular access reviews

Disable unused accounts

Rotate API keys periodically

Strong password policy

Enable MFA where available

Document user responsibilities

Onboard new users thoroughly

6. Performance Tuning

Continuously optimize performance:

Monitor metrics regularly

Optimize database indexes

Enable caching strategically

Clean up logs and old data

Tune timeout settings appropriately

Test under expected load

Identify and fix bottlenecks

Document performance baselines

7. Security Maintenance

Keep your instance secure:

Regular security updates

Monitor for vulnerabilities

Review access logs regularly

Audit permission settings

Update dependent packages

Test security measures

Document security policies

Incident response plan

8. Documentation

Maintain comprehensive documentation:

Event setup procedures

User guides for participants

Moderation guidelines

Troubleshooting guides

System configuration details

Admin procedures and workflows

Emergency contact information

Post-event review templates

9. Community Engagement

Contribute to Claper community:

Report bugs on GitHub

Share your use cases

Participate in discussions

Contribute improvements

Help other users

Provide feedback on features

Join community channels

10. Scalability Planning

Plan for future growth:

Monitor usage trends

Plan capacity increases

Document scaling procedures

Test scalability regularly

Prepare migration procedures

Plan for archive strategy

Document growth expectations

Establish SLAs for service

Verifying Your Deployment

After deployment completes:

Check the App URL: Visit https://example-app.klutch.sh

Create Admin Account: Complete initial setup

Configure Settings: Set organization details

Test Event Creation: Create a test event

Upload Test Presentation: Upload PDF or PowerPoint

Test Q&A Feature: Verify Q&A module works

Test Polls: Create and launch a test poll

Verify Storage: Confirm files persist

Check Performance: Test with expected participant count

Review Security: Verify HTTPS and access controls

If your Claper instance doesn’t work as expected, review the troubleshooting section and check the Klutch.sh dashboard logs for detailed error messages.

External Resources

Official Claper Website

Claper Documentation

Claper GitHub Repository

Claper Releases

Claper Discord Community

Claper Status Page

Klutch.sh Official Website

Deploying Claper to Klutch.sh using Docker provides a powerful, open-source interactive presentation platform with complete control over your event infrastructure. By following this guide, you’ve learned how to create a production-ready Dockerfile, configure persistent storage for presentations and data, set up real-time collaboration features, manage interactive elements (Q&A, polls, quizzes), implement security best practices, optimize performance, configure custom domains, monitor system health, and troubleshoot common issues. Your Claper instance is now running on Klutch.sh’s global infrastructure with professional-grade hosting, automatic HTTPS, and scalable infrastructure for engaging interactive events. For additional help or questions, consult the official Claper documentation or contact Klutch.sh support.