How To Install Zammad on Debian 13

Zammad is a powerful open-source helpdesk and customer support ticketing system that streamlines communication across multiple channels including email, phone, chat, and social media. Built with Ruby and designed for flexibility, Zammad helps support teams manage customer interactions efficiently while maintaining complete control over their data. This comprehensive guide walks through the complete installation process of Zammad on Debian 13, covering everything from system preparation to production deployment with Elasticsearch integration.

What is Zammad?

Zammad is a web-based open-source helpdesk solution licensed under GNU AGPLv3 that enables organizations to centralize their customer communication workflows. Unlike proprietary ticketing systems, Zammad provides full transparency and customization capabilities without vendor lock-in. The platform excels at converting customer inquiries from various channels into manageable tickets, allowing support teams to track, prioritize, and resolve issues systematically.

Written in Ruby with Java components, Zammad integrates seamlessly with existing infrastructure including LDAP directories, OAuth providers, and external communication platforms. Its architecture supports both small teams and enterprise deployments, scaling to handle thousands of tickets while maintaining responsive performance. Organizations choose Zammad for its robust feature set, active community support, and the freedom to self-host sensitive customer data.

Key Features of Zammad

Zammad delivers comprehensive helpdesk functionality through its rich feature ecosystem. The platform supports full-text search capabilities powered by Elasticsearch, allowing agents to search through ticket content, attachments, and historical communications instantly. Multi-language support spanning over 30 languages makes Zammad suitable for global support operations, with automatic translation features enhancing cross-border communication.

Advanced collaboration features include ticket assignment systems, group management, role-based permissions, and real-time notifications that keep teams synchronized. Time tracking functionality enables accurate reporting of agent workload and ticket resolution times. The integrated knowledge base system empowers customers with self-service options, reducing ticket volume while improving satisfaction.

Security features are paramount, with S/MIME email encryption, two-factor authentication, device logging, and granular permission controls protecting sensitive customer data. OAuth integration with providers like Google, Facebook, and Twitter simplifies authentication management. Workflow automation through triggers and scheduled jobs eliminates repetitive tasks, allowing agents to focus on complex customer needs.

Prerequisites and System Requirements

Before installing Zammad on Debian 13, ensure the system meets minimum hardware specifications. A basic deployment requires at least 2 CPU cores and 6 GB of RAM for the application server. Adding Elasticsearch to the same server demands an additional 4-6 GB of RAM, bringing the total to 10-12 GB for optimal search performance. Production environments supporting up to 40 agents should provision 6 CPU cores with 12 GB total RAM when running all services on a single server.

Storage requirements vary based on ticket volume and attachment retention. Start with at least 100 GB of SSD storage, with expansion capability as the database grows. Network connectivity must be stable, with sufficient bandwidth to handle email synchronization and web interface access.

Software prerequisites include a fresh Debian 13 (Trixie) installation with root or sudo administrative access. The system must support UTF-8 locale encoding, critical for PostgreSQL database compatibility and international character handling. Optional but highly recommended is a registered domain name for production deployments, facilitating SSL certificate installation and professional client communication.

Step 1: Update System and Configure Locales

Begin by updating Debian 13 package repositories to ensure access to the latest security patches and software versions. Execute the following command to refresh package indexes and upgrade existing packages:

sudo apt update && sudo apt upgrade -y

This command combination updates the package cache and applies all available updates automatically. System reboots may be necessary if kernel updates are applied, ensuring all security patches take effect.

Zammad requires UTF-8 locale configuration for proper database encoding and international character support. Verify current locale settings with:

locale

The output should display LANG=en_US.UTF-8. If UTF-8 locale is not configured, generate it using:

sudo apt install locales -y
sudo locale-gen en_US.UTF-8
sudo update-locale LANG=en_US.UTF-8

These commands install locale packages, generate the UTF-8 locale, and set it as the system default. Verify the configuration by running locale again to confirm proper settings. Apply changes immediately with source /etc/default/locale or reboot the system.

Step 2: Install Required Dependencies

Zammad relies on several system packages for repository management, security, and core functionality. Install essential dependencies with a single command:

sudo apt install curl wget apt-transport-https ca-certificates gnupg2 libimlib2 libimlib2-dev -y

This installs curl and wget for file downloads, apt-transport-https for secure repository access, ca-certificates for SSL verification, and gnupg2 for GPG key management. The libimlib2 package provides image processing capabilities required by Zammad for avatar handling and attachment previews.

Additional utility packages streamline configuration management. Consider installing vim or nano text editors if not already present:

sudo apt install vim nano -y

These tools facilitate configuration file editing throughout the installation process. With dependencies installed, the system is prepared for database, search engine, and Zammad package installation.

Step 3: Install and Configure Database Server

Zammad supports multiple database backends, with PostgreSQL being the officially recommended and default option. PostgreSQL provides excellent performance, robust data integrity, and superior handling of concurrent operations. MariaDB and MySQL are also supported for organizations with existing infrastructure preferences.

PostgreSQL Installation

Install PostgreSQL on Debian 13 using the distribution’s package repository:

sudo apt install postgresql postgresql-common postgresql-contrib -y

This installs the PostgreSQL server, common utilities, and additional contributed modules. After installation, PostgreSQL automatically starts and enables on system boot.

Configure PostgreSQL for Zammad by adjusting the maximum connections parameter to handle concurrent requests. Edit the configuration file:

sudo nano /etc/postgresql/15/main/postgresql.conf

Locate the max_connections parameter and set it to 2000:

max_connections = 2000

Save the file and restart PostgreSQL to apply changes:

sudo systemctl restart postgresql

This configuration ensures PostgreSQL can handle the connection pool required by Zammad’s web server, worker processes, and websocket connections.

MariaDB Alternative

For organizations preferring MariaDB, install it with:

sudo apt install mariadb-server mariadb-client -y

Run the security installation script to set root password and remove insecure defaults:

sudo mysql_secure_installation

Follow the prompts to set a strong root password, remove anonymous users, disallow remote root login, and remove test databases. Configure character set encoding for international character support by creating a custom configuration file:

sudo nano /etc/mysql/mariadb.conf.d/99-zammad.cnf

Add the following configuration:

[mysqld]
character-set-server = utf8mb4
collation-server = utf8mb4_unicode_ci

Restart MariaDB to apply encoding settings:

sudo systemctl restart mariadb

The utf8mb4 character set provides full Unicode support including emojis and special characters.

Step 4: Install and Configure Elasticsearch

Elasticsearch powers Zammad’s advanced search capabilities, enabling full-text search across tickets, knowledge base articles, and attachment contents. While optional, Elasticsearch is highly recommended for production deployments handling significant ticket volumes.

Add Elasticsearch Repository

Import the Elasticsearch GPG signing key to verify package authenticity:

wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo gpg --dearmor -o /usr/share/keyrings/elasticsearch-keyring.gpg

Add the Elasticsearch 8.x repository to the system sources:

echo "deb [signed-by=/usr/share/keyrings/elasticsearch-keyring.gpg] https://artifacts.elastic.co/packages/8.x/apt stable main" | sudo tee /etc/apt/sources.list.d/elasticsearch-8.x.list

Update the package cache to include the new repository:

sudo apt update

Install Elasticsearch

Install Elasticsearch with the ingest-attachment plugin required for document indexing:

sudo apt install elasticsearch -y

During installation, Elasticsearch 8.x automatically configures security features including TLS encryption and authentication. The installation process displays critical information including the auto-generated password for the elastic superuser. Save this password immediately as it’s needed for Zammad integration.

Example output shows:

The generated password for the elastic built-in superuser is: ucoAPGk-io-hwnPalUle

Install the ingest-attachment plugin for searching document attachments:

sudo /usr/share/elasticsearch/bin/elasticsearch-plugin install ingest-attachment

This plugin enables Elasticsearch to extract and index text content from PDF, Word, Excel, and other document formats attached to tickets.

Configure Elasticsearch

Optimize Elasticsearch for Zammad by adjusting configuration parameters. Edit the main configuration file:

sudo nano /etc/elasticsearch/elasticsearch.yml

Add the following settings at the end:

http.max_content_length: 400mb
indices.query.bool.max_clause_count: 2000

The first parameter increases the maximum HTTP request body size to accommodate large attachments. The second setting adjusts query complexity limits for Zammad’s search operations.

Configure JVM heap size based on available RAM. Create a custom heap configuration:

sudo nano /etc/elasticsearch/jvm.options.d/jvm-custom-heap.options

For systems with 12 GB RAM, allocate 4 GB to Elasticsearch:

-Xms4g
-Xmx4g

The heap size should be approximately 25-50% of available RAM, never exceeding 32 GB. Adjust these values based on system capacity and workload requirements.

Increase virtual memory map count for optimal Elasticsearch performance:

echo "vm.max_map_count=262144" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

This system tuning parameter prevents memory allocation issues under heavy load.

Start Elasticsearch

Enable and start the Elasticsearch service:

sudo systemctl enable elasticsearch
sudo systemctl start elasticsearch

Verify Elasticsearch is running correctly:

curl -X GET "https://localhost:9200" --cacert /etc/elasticsearch/certs/http_ca.crt -u elastic

Enter the elastic user password when prompted. Successful output displays cluster information including version number and cluster health.

Step 5: Install Web Server

Zammad requires a reverse proxy web server to handle HTTP requests and serve static content. Debian 13 supports both Apache and Nginx, with Zammad providing configuration templates for both.

Apache Installation

Install Apache web server and essential modules:

sudo apt install apache2 apache2-utils -y

Enable required Apache modules for proxying and security:

sudo a2enmod proxy proxy_http proxy_wstunnel headers ssl

These modules enable Apache to proxy requests to Zammad’s Puma application server, handle websocket connections, manipulate HTTP headers, and provide SSL/TLS encryption.

Start and enable Apache to run at system boot:

sudo systemctl enable apache2
sudo systemctl start apache2

Verify Apache is running without errors:

sudo systemctl status apache2

Nginx Alternative

For organizations preferring Nginx, install it with:

sudo apt install nginx -y

Nginx offers excellent performance for high-traffic deployments with lower memory consumption than Apache. Enable and start Nginx:

sudo systemctl enable nginx
sudo systemctl start nginx

Zammad’s package installation automatically provides configuration files for both web servers, simplifying setup.

Step 6: Add Zammad Repository

Zammad maintains official package repositories providing stable, tested releases for Debian systems. Add the repository signing key to verify package authenticity:

curl -fsSL https://dl.packager.io/srv/zammad/zammad/key | sudo gpg --dearmor -o /etc/apt/trusted.gpg.d/pkgr-zammad.gpg

This command downloads Zammad’s GPG key and stores it in the system keyring. Create the Zammad repository configuration for Debian 13:

echo "deb [signed-by=/etc/apt/trusted.gpg.d/pkgr-zammad.gpg] https://dl.packager.io/srv/deb/zammad/zammad/stable/debian 12 main" | sudo tee /etc/apt/sources.list.d/zammad.list

Note: At the time of writing, Debian 13 packages may use the Debian 12 repository path until official Debian 13 packages are released. Update the package cache to include Zammad packages:

sudo apt update

The system now has access to official Zammad packages maintained by the development team.

Step 7: Install Zammad Package

Install Zammad and all required dependencies with a single command:

sudo apt install zammad -y

The installation process automatically configures Redis for session storage and caching, installs required Ruby libraries, creates system users, and initializes the PostgreSQL database. Installation typically takes 5-10 minutes depending on system performance and internet connection speed.

During installation, the package manager configures Apache or Nginx virtual hosts, enables necessary web server modules, and starts Zammad services. The installation output provides important information about service status and next configuration steps.

Zammad installs to /opt/zammad/ by default, with application files, configurations, and uploaded attachments stored in this directory hierarchy. Log files are written to /var/log/zammad/ for troubleshooting and monitoring.

Step 8: Configure Firewall Rules

Production servers typically run firewall software to restrict network access. Configure firewall rules to allow HTTP and HTTPS traffic to Zammad.

UFW Configuration

For systems using UFW (Uncomplicated Firewall), open web server ports:

sudo ufw allow 'WWW Full'

This rule permits incoming connections on ports 80 (HTTP) and 443 (HTTPS). Alternatively, specify ports individually:

sudo ufw allow 80/tcp
sudo ufw allow 443/tcp

Enable UFW if not already active:

sudo ufw enable

Verify firewall rules:

sudo ufw status

nftables Configuration

For systems using nftables, add rules to allow web traffic. Create or edit the nftables configuration:

sudo nano /etc/nftables.conf

Add rules within the input chain:

tcp dport { 80, 443 } accept

Reload nftables configuration:

sudo systemctl reload nftables

Firewall configuration ensures Zammad remains accessible to users while blocking unauthorized access attempts.

Step 9: Connect Zammad to Elasticsearch

Integrate Elasticsearch with Zammad to enable advanced search functionality. Configure the Elasticsearch connection URL:

sudo zammad run rails r "Setting.set('es_url', 'https://localhost:9200')"

Note the HTTPS protocol for Elasticsearch 8.x installations. Set Elasticsearch authentication credentials:

sudo zammad run rails r "Setting.set('es_user', 'elastic')"
sudo zammad run rails r "Setting.set('es_password', 'YOUR_ELASTIC_PASSWORD')"

Replace YOUR_ELASTIC_PASSWORD with the password generated during Elasticsearch installation. For security, disable command history before entering the password:

set +o history
sudo zammad run rails r "Setting.set('es_password', 'YOUR_ELASTIC_PASSWORD')"
set -o history

This prevents the password from being saved in shell history files.

Add Elasticsearch Certificate

Elasticsearch 8.x uses self-signed certificates for TLS encryption. Add the certificate to Zammad’s admin panel for secure communication. Display the certificate content:

sudo cat /etc/elasticsearch/certs/http_ca.crt

Copy the entire certificate output including the BEGIN and END delimiters. Access Zammad’s admin panel through the web interface, navigate to System → SSL Certificates, and paste the certificate content. Save the configuration to establish trusted communication with Elasticsearch.

Build Search Index

Initialize the Elasticsearch index structure and populate it with existing data:

sudo zammad run rake zammad:searchindex:rebuild

The indexing process duration depends on ticket volume and system resources. Small installations complete within minutes, while large deployments with thousands of tickets may require hours. The process can run during normal operations without data loss, though it may temporarily impact system performance.

For systems with multiple CPU cores, specify parallelization:

sudo zammad run rake zammad:searchindex:rebuild[8]

This example uses 8 CPU cores to accelerate indexing.

Optimize Elasticsearch Settings

Reduce resource consumption by excluding certain file types from attachment indexing:

sudo zammad run rails r "Setting.set('es_attachment_ignore', ['.png', '.jpg', '.jpeg', '.mpeg', '.mpg', '.mov', '.bin', '.exe', '.box', '.mbox'])"

Limit attachment indexing size to prevent memory issues:

sudo zammad run rails r "Setting.set('es_attachment_max_size_in_mb', 50)"

These optimizations prevent Elasticsearch from indexing large media files that provide minimal search value.

Step 10: Configure Web Server Virtual Host

Zammad’s installation automatically creates web server configuration files, but they require customization for production deployments.

Apache Configuration

For Apache installations, Zammad provides template configurations in /opt/zammad/contrib/apache2/. Copy the SSL configuration template:

sudo cp /opt/zammad/contrib/apache2/zammad_ssl.conf /etc/apache2/sites-available/

Edit the configuration to specify your domain name:

sudo nano /etc/apache2/sites-available/zammad_ssl.conf

Locate the ServerName directive and replace localhost with your actual domain:

ServerName support.yourdomain.com

Configure SSL certificate paths if using commercial certificates:

SSLCertificateFile /path/to/your/certificate.crt
SSLCertificateKeyFile /path/to/your/private.key
SSLCertificateChainFile /path/to/your/ca-bundle.crt

For Let’s Encrypt certificates, the paths typically point to /etc/letsencrypt/live/yourdomain.com/. Disable the default Apache site to prevent conflicts:

sudo a2dissite 000-default.conf

Enable the Zammad site configuration:

sudo a2ensite zammad_ssl.conf

Test Apache configuration syntax:

sudo apachectl configtest

If the syntax test returns “Syntax OK,” restart Apache to apply changes:

sudo systemctl restart apache2

Nginx Configuration

For Nginx installations, edit the default Zammad configuration:

sudo nano /etc/nginx/sites-available/zammad.conf

Update the server_name directive with your domain:

server_name support.yourdomain.com;

Test Nginx configuration syntax:

sudo nginx -t

Reload Nginx to apply changes:

sudo systemctl reload nginx

The web server now properly routes requests to Zammad’s application server.

Step 11: Start and Enable Zammad Services

Zammad operates through multiple systemd services managing different components. The main service coordinates three specialized services: zammad-web for the Puma application server, zammad-worker for background job processing, and zammad-websocket for real-time updates.

Start all Zammad services:

sudo systemctl start zammad

Enable automatic startup on system boot:

sudo systemctl enable zammad

Verify all services are running correctly:

sudo systemctl status zammad
sudo systemctl status zammad-web
sudo systemctl status zammad-worker
sudo systemctl status zammad-websocket

Each service should display “active (running)” status. Individual service management is possible when troubleshooting specific components:

sudo systemctl restart zammad-web
sudo systemctl restart zammad-worker
sudo systemctl restart zammad-websocket

Service logs are accessible through journalctl for diagnosing startup issues:

sudo journalctl -u zammad -f

The -f flag follows log output in real-time.

Step 12: Complete Initial Setup via Web Interface

Access Zammad through your web browser by navigating to https://yourdomain.com or http://serverip for initial configuration. The setup wizard appears on first access, guiding through essential configuration steps.

Click “Set up a new system” to begin the initialization process. Create the administrator account with a strong username and password, avoiding common credentials for security. This account has full system access including user management, system settings, and security configurations.

Configure organization details including company name, logo, and system URL. The system URL should match your production domain name for proper email notifications and webhook callbacks. Upload a company logo to personalize the interface and customer communications.

Email notification configuration enables Zammad to send ticket updates and system alerts. Choose between SMTP server connection or local mail transfer agent. For SMTP configuration, provide server address, port (typically 587 for TLS or 465 for SSL), authentication credentials, and sender email address. Gmail users require app-specific passwords when two-factor authentication is enabled.

Test email configuration by sending a verification message to your inbox. Successful delivery confirms proper SMTP settings. Communication channel setup allows connecting email accounts, social media platforms, and chat services. Skip optional channels during initial setup and configure them later as needed.

The final setup screen offers colleague invitation functionality for adding team members. Complete the wizard to access the Zammad dashboard where ticket management, agent configuration, and system customization begin.

Post-Installation Configuration

Optimize Zammad for production use through additional configuration. Navigate to the admin panel by clicking the gear icon and selecting “Admin”. Configure additional email accounts under Channels → Email to enable ticket creation from multiple mailboxes.

Set up ticket triggers for automating workflows such as auto-assignment based on keywords, priority escalation after time thresholds, or automatic tagging. Create macros for common responses, reducing agent response time and maintaining message consistency.

Configure user roles and permissions under Manage → Roles to control agent capabilities. Restrict sensitive operations like user deletion or system settings to administrators only. Enable two-factor authentication in Settings → Security to protect administrative accounts from unauthorized access.

Implement backup procedures for the Zammad database and attachment storage. PostgreSQL backups using pg_dump preserve ticket data and configuration:

sudo -u postgres pg_dump zammad_production > /backup/zammad-$(date +%Y%m%d).sql

Back up attachment files from /opt/zammad/storage/ directory using rsync or similar tools. Schedule automated backups via cron for consistent data protection.

Integrating Additional Features

Extend Zammad capabilities through integrations with external services. LDAP integration synchronizes user accounts with Active Directory or OpenLDAP servers, centralizing authentication management. Configure LDAP connection under Settings → Security → Third-Party Authentication.

Knowledge base functionality empowers customers with self-service support articles reducing ticket volume. Enable the knowledge base in Settings → Channels → Knowledge Base, then create article categories and content through the interface.

Slack integration notifies teams of new tickets or urgent issues in real-time. Install the Slack app from Settings → Integrations and configure webhook URLs. Similarly, Telegram and Mattermost integrations provide alternative team communication channels.

Telephony integration with providers like Sipgate or Placetel enables call logging and screen pop functionality. Configure phone integration under Channels → Phone to display caller information and create tickets from incoming calls.

OAuth authentication with Google, Microsoft, Facebook, or Twitter simplifies user login for customer portals. Configure OAuth providers in Settings → Security → Third-Party Authentication, following provider-specific setup instructions.

Performance Optimization Tips

Optimize Zammad performance as ticket volume and user base grow. Redis caching improves response times by storing session data and frequently accessed objects in memory. Monitor Redis memory usage and adjust maxmemory settings in /etc/redis/redis.conf if needed.

Database query optimization becomes critical as the ticket database expands. Regular PostgreSQL maintenance including VACUUM and ANALYZE operations reclaims storage and updates query planner statistics:

sudo -u postgres vacuumdb --analyze zammad_production

Schedule this maintenance during low-traffic periods. Monitor Zammad performance through the admin panel’s dashboard displaying response times, ticket statistics, and system load.

Elasticsearch performance tuning involves adjusting heap size based on workload. Systems experiencing slow searches benefit from increased heap allocation or additional Elasticsearch nodes for distributed indexing. Monitor Elasticsearch cluster health through its API:

curl -X GET "https://localhost:9200/_cluster/health" --cacert /etc/elasticsearch/certs/http_ca.crt -u elastic

Worker process scaling improves background job processing for high-volume installations. Add worker processes by modifying systemd service files or running additional worker instances.

Troubleshooting Common Issues

Address common installation problems with systematic troubleshooting. Locale errors during installation indicate missing UTF-8 configuration. Regenerate locales using locale-gen en_US.UTF-8 and update the system default.

Database connection failures suggest incorrect credentials or service status issues. Verify PostgreSQL is running with systemctl status postgresql and check connection settings in /opt/zammad/config/database.yml.

Elasticsearch connectivity errors appear when Zammad cannot reach the search engine. Verify Elasticsearch is running, credentials are correct, and firewall rules permit local connections. Certificate validation errors require adding the Elasticsearch CA certificate to Zammad’s admin panel.

Apache module errors prevent web server startup. Enable required modules using a2enmod commands and verify no configuration syntax errors with apachectl configtest. Permission problems affecting file uploads or attachment access require adjusting ownership to the zammad user:

sudo chown -R zammad:zammad /opt/zammad/

Service startup failures are diagnosed through systemd logs:

sudo journalctl -u zammad-web -n 100

This displays the last 100 log entries for the web service, revealing specific error messages. Production log files at /var/log/zammad/production.log contain detailed application errors and stack traces.

Security Hardening

Secure production Zammad installations through comprehensive hardening measures. SSL/TLS encryption is mandatory for production deployments protecting authentication credentials and customer data in transit. Obtain Let’s Encrypt certificates using Certbot:

sudo apt install certbot python3-certbot-apache -y
sudo certbot --apache -d support.yourdomain.com

Certbot automatically configures Apache for HTTPS and sets up automatic certificate renewal. For Nginx installations, use python3-certbot-nginx instead.

Configure HTTPS redirection ensuring all traffic uses encrypted connections. The Zammad Apache SSL configuration template includes redirect directives forcing HTTPS. Implement Diffie-Hellman parameters for forward secrecy:

sudo openssl dhparam -dsaparam -out /etc/ssl/dhparam.pem 4096

Reference this file in Apache or Nginx SSL configuration for enhanced encryption.

Fail2ban protects against brute-force authentication attempts by temporarily blocking IP addresses with excessive failed logins. Install and configure Fail2ban:

sudo apt install fail2ban -y

Create a Zammad jail configuration monitoring authentication logs. Restrict database access to localhost only unless external database servers are used. PostgreSQL configuration file /etc/postgresql/15/main/pg_hba.conf controls connection permissions.

Regular security updates are critical for patching vulnerabilities. Subscribe to Zammad security announcements through the community forum or GitHub repository. Apply updates promptly following release notes and backup procedures.

Implement strong password policies through Zammad’s security settings requiring minimum length, complexity, and regular password changes. Enable two-factor authentication for all administrative accounts. Configure session timeout values balancing security and usability.

Updating and Maintaining Zammad

Maintain Zammad through regular updates ensuring access to new features, bug fixes, and security patches. Package-based installations simplify updates through apt package manager. Check for available updates:

sudo apt update
sudo apt list --upgradable | grep zammad

Before updating, always create complete system backups including database and files. Stop Zammad services during the update process:

sudo systemctl stop zammad

Apply the update:

sudo apt install --only-upgrade zammad

The update process automatically handles database migrations and configuration changes. Restart Zammad services after the update completes:

sudo systemctl start zammad

Verify the update succeeded by checking the version in the admin panel under System → About. Monitor the production log for any errors during startup:

sudo tail -f /var/log/zammad/production.log

Zammad follows a regular release schedule with long-term support (LTS) versions receiving extended maintenance. Subscribe to release announcements through the Zammad community forum or GitHub repository for update notifications.

Major version updates may require additional steps including Elasticsearch reindexing or configuration adjustments. Review release notes carefully before upgrading production systems, testing updates in staging environments when possible.

Congratulations! You have successfully installed Zammad. Thanks for using this tutorial for installing the Zammad ticketing system on Debian 13 “Trixie” system. For additional help or useful information, we recommend you check the official Zammad website.