Deploying pretalx

Introduction

pretalx is a comprehensive, self-hosted conference planning tool that handles the complete lifecycle of event speaker management. From issuing calls for papers (CfP) to scheduling talks and coordinating with speakers, pretalx provides organizers with a powerful platform for managing conferences, meetups, and community events.

Built with Python and Django, pretalx offers a polished user experience for both organizers and speakers. The platform supports multiple events, flexible submission types, review workflows, and automatic schedule generation. Its plugin architecture allows extending functionality to meet specific event requirements.

Key highlights of pretalx:

• Call for Papers Management: Create customizable submission forms with multiple question types, track submissions, and manage deadlines
• Review System: Built-in review workflow with multiple reviewers, scoring, and collaborative decision-making
• Schedule Builder: Drag-and-drop schedule editor with conflict detection and automatic optimization
• Speaker Portal: Self-service portal for speakers to manage profiles, submissions, and session details
• Multi-Event Support: Run multiple conferences from a single installation with separate configurations
• Plugin System: Extend functionality with community plugins for integration with other tools
• Email Automation: Automated notifications and customizable email templates for speaker communication
• Export Options: Export schedules to various formats including JSON, iCal, and XML for apps and websites
• Accessibility Focus: WCAG-compliant interface with attention to accessibility best practices
• Open Source: Licensed under Apache 2.0, freely available with an active community

This guide walks through deploying pretalx on Klutch.sh using Docker, configuring persistent storage for event data, and setting up the application for production use.

Why Deploy pretalx on Klutch.sh

Deploying pretalx on Klutch.sh provides several advantages for conference and event management:

Simplified Deployment: Klutch.sh automatically detects your Dockerfile and builds pretalx without complex orchestration. Push to GitHub, and your event platform deploys automatically.

Persistent Storage: Attach persistent volumes for your database, media uploads, and static files. Your event data and speaker submissions survive container restarts without data loss.

HTTPS by Default: Klutch.sh provides automatic SSL certificates, ensuring secure access to your CfP portal and speaker management interface without manual certificate configuration.

GitHub Integration: Connect your configuration repository directly from GitHub. Updates to your Dockerfile trigger automatic redeployments, keeping your deployment synchronized.

Scalable Resources: Allocate CPU and memory based on your event size and expected traffic. Scale up during CfP periods and submission deadlines when traffic peaks.

Environment Variable Management: Securely store sensitive configuration like database credentials and secret keys through Klutch.sh’s environment variable system.

Custom Domains: Assign a custom domain to your pretalx instance for a professional, branded experience for speakers and attendees.

Always-On Availability: Your CfP portal remains accessible 24/7, allowing speakers from any timezone to submit proposals without downtime concerns.

Prerequisites

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

• A Klutch.sh account
• A GitHub account with a repository for your pretalx configuration
• Basic familiarity with Docker and containerization concepts
• A PostgreSQL database (can be provisioned through Klutch.sh)
• A Redis instance for caching and background tasks
• SMTP credentials for sending speaker notifications
• (Optional) A custom domain for your pretalx instance

Understanding pretalx Architecture

pretalx is built on a robust Python/Django stack designed for reliability:

Django Backend: The core application runs on Django, providing a battle-tested foundation for web applications with excellent security practices and ORM capabilities.

PostgreSQL Database: pretalx requires PostgreSQL for data persistence, storing events, submissions, reviews, schedules, and user accounts.

Redis Cache: Redis handles caching, session storage, and serves as a message broker for background task processing.

Celery Workers: Background tasks like email sending and schedule calculations are processed asynchronously using Celery workers.

Static and Media Files: Static assets and uploaded files (speaker photos, slide decks) are stored separately and can be served via object storage or persistent volumes.

Preparing Your Repository

To deploy pretalx on Klutch.sh, create a GitHub repository containing your Dockerfile and configuration files.

Repository Structure

pretalx-deploy/
├── Dockerfile
├── pretalx.cfg
├── .dockerignore
└── README.md

Creating the Dockerfile

Create a Dockerfile in the root of your repository:

FROM pretalx/standalone:stable

# Set environment variables
ENV PRETALX_DATA_DIR=/data
ENV PRETALX_CONFIG_FILE=/etc/pretalx/pretalx.cfg

# Create necessary directories
RUN mkdir -p /data /etc/pretalx

# Copy configuration file
COPY pretalx.cfg /etc/pretalx/pretalx.cfg

# Expose the web interface port
EXPOSE 80

# The base image includes the default entrypoint

Creating the Configuration File

Create a pretalx.cfg file with your settings:

[filesystem]
data = /data
logs = /data/logs
media = /data/media
static = /data/static

[site]
debug = false
url = https://your-pretalx-domain.klutch.sh

[database]
backend = postgresql
name = pretalx
user = pretalx
password =
host = your-postgres-host
port = 5432

[mail]
from = noreply@yourdomain.com
host = smtp.yourdomain.com
port = 587
user = smtp-user
password =
tls = true

[redis]
location = redis://your-redis-host:6379/0

[celery]
backend = redis://your-redis-host:6379/1
broker = redis://your-redis-host:6379/2

Creating the .dockerignore File

Create a .dockerignore file to exclude unnecessary files:

.git
.github
*.md
LICENSE
.gitignore
*.log
.DS_Store
.env
.env.local
__pycache__/
*.pyc

Environment Variables Reference

Variable	Required	Description
PRETALX_DB_PASS	Yes	PostgreSQL database password
PRETALX_MAIL_PASS	Yes	SMTP password for email sending
SECRET_KEY	Yes	Django secret key for cryptographic signing
PRETALX_REDIS_HOST	Yes	Redis server hostname
PRETALX_DB_HOST	Yes	PostgreSQL server hostname

Deploying pretalx on Klutch.sh

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

Generate Your Secret Key

Before deployment, generate a secure Django secret key:

python -c "from django.core.management.utils import get_random_secret_key; print(get_random_secret_key())"

Save this key securely for the environment variables configuration.

Push Your Repository to GitHub

Initialize your repository and push to GitHub:

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

Create a New Project on Klutch.sh

Navigate to the Klutch.sh dashboard and create a new project. Give it a descriptive name like “pretalx” or “conference-cfp”.

Provision Required Services

Before deploying pretalx, ensure you have:

• A PostgreSQL database instance
• A Redis instance for caching and Celery

These can be provisioned through Klutch.sh or external providers.

Create a New App

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

Configure HTTP Traffic

In the deployment settings:

• Select HTTP as the traffic type
• Set the internal port to 80

Set Environment Variables

In the environment variables section, add:

Variable	Value
PRETALX_DB_PASS	Your PostgreSQL password
PRETALX_MAIL_PASS	Your SMTP password
SECRET_KEY	Your generated Django secret key

Attach Persistent Volumes

Add the following volumes for data persistence:

Mount Path	Recommended Size	Purpose
/data	20 GB	Application data, logs, media uploads, and static files

Deploy Your Application

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

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

Run Initial Setup

After the first deployment, run database migrations by accessing the container or running:

pretalx migrate
pretalx rebuild

Create Admin Account

Create your initial administrator account:

pretalx createsuperuser

Access pretalx

Once deployment completes, access your pretalx instance at https://your-app-name.klutch.sh/orga/ for the organizer interface.

Initial Setup and Configuration

Creating Your First Event

After logging in as an administrator:

1. Navigate to the organizer dashboard at /orga/
2. Click Create a new event
3. Configure basic event details: name, slug, dates, timezone
4. Set up submission types (talks, workshops, lightning talks)
5. Configure the Call for Papers period and questions
6. Customize email templates for speaker communication

Configuring Submission Types

pretalx supports multiple submission types with different configurations:

Type	Duration	Description
Talk	30-45 min	Standard conference presentation
Workshop	2-3 hours	Hands-on interactive session
Lightning Talk	5 min	Quick, focused presentation
Panel	45-60 min	Multi-speaker discussion

Setting Up Review Workflow

Configure how submissions are reviewed:

1. Navigate to Settings → Review
2. Add reviewers and assign permissions
3. Configure scoring criteria and scales
4. Set review deadlines and visibility rules
5. Enable or disable anonymous reviews

Production Best Practices

Security Recommendations

• Secret Key Protection: Never commit your Django secret key to version control
• Database Security: Use strong passwords and restrict database access
• HTTPS Enforcement: Configure pretalx to redirect HTTP to HTTPS
• Regular Updates: Keep pretalx updated for security patches
• Access Control: Use strong passwords and consider SSO integration

Performance Optimization

• Redis Caching: Ensure Redis is properly configured for session and cache storage
• Database Indexing: PostgreSQL handles large events well with proper configuration
• Static Files: Consider CDN delivery for static assets during high-traffic periods
• Celery Workers: Scale background workers based on email volume and task load

Backup Strategy

1. Database Backups: Regular PostgreSQL dumps of the pretalx database
2. Media Files: Back up the /data/media directory containing uploads
3. Configuration: Version control your pretalx.cfg (excluding secrets)
4. Export Events: Use pretalx’s export features for portable backups

Troubleshooting Common Issues

Database Connection Errors

Symptoms: Application fails to start or shows database errors.

Solutions:

• Verify PostgreSQL connection settings in pretalx.cfg
• Ensure database user has proper permissions
• Check network connectivity between pretalx and PostgreSQL

Email Delivery Issues

Symptoms: Speakers don’t receive notification emails.

Solutions:

• Verify SMTP credentials and server settings
• Check mail logs for delivery errors
• Test with a simple email service first
• Ensure SPF/DKIM records are configured for your domain

Static Files Not Loading

Symptoms: CSS and JavaScript files return 404 errors.

Solutions:

• Run pretalx rebuild to collect static files
• Verify the static files directory is properly mounted
• Check file permissions on the data volume

Additional Resources

• Official pretalx Website
• pretalx Documentation
• pretalx GitHub Repository
• pretalx Installation Guide
• Klutch.sh Persistent Volumes
• Klutch.sh Deployments

Conclusion

Deploying pretalx on Klutch.sh gives you a powerful, self-hosted conference management platform with automatic builds, persistent storage, and secure HTTPS access. The combination of pretalx’s comprehensive feature set and Klutch.sh’s deployment simplicity means you can focus on organizing great events rather than managing infrastructure.

With support for multiple events, flexible submission workflows, and collaborative review processes, pretalx scales from small meetups to large international conferences. The speaker self-service portal and automated communication features reduce organizer workload while maintaining professional speaker relationships.

Whether you’re organizing your first community meetup or managing a multi-track conference with hundreds of speakers, pretalx on Klutch.sh provides the foundation for successful event speaker management.