FreeScout vs Zammad: Which Helpdesk to Self-Host?

By Alex Thornton helpdesk Updated:

Which One Do You Need?

Small team, simple email-based support. You handle 50-200 tickets a month, your support is mostly email, and you want something that feels like Help Scout. You do not need chat, phone integration, or enterprise SSO. Pick FreeScout. It runs on a single container with MariaDB, uses under 256 MB of RAM, and gets you a clean shared inbox in minutes.

Growing team, multi-channel support. You have 5+ agents, customers reach you through email, chat, phone, and social media, and you need full-text search across thousands of tickets. You want LDAP/Active Directory integration and detailed reporting out of the box. Pick Zammad. It is a proper enterprise-grade ticketing system — heavier, but far more capable.

Budget-constrained with specific feature needs. FreeScout’s core is free but many features (knowledge base, satisfaction ratings, time tracking) require paid modules at $2-20 each. Zammad ships every feature for free under the AGPL. If you need those extras and do not want per-module costs, Zammad wins on total cost despite higher infrastructure requirements.

Feature Comparison

FeatureFreeScoutZammad
Ticket managementShared inbox, assignments, tags, notesFull ticket lifecycle, SLAs, escalations, macros
Email integrationIMAP/SMTP, multiple mailboxesIMAP/SMTP, multiple mailboxes, email templates
Knowledge basePaid moduleBuilt-in
Live chatPaid moduleBuilt-in
Phone/CTI integrationNot availableBuilt-in (generic CTI, Sipgate, Placetel)
Reporting & analyticsBasic (paid module for advanced)Built-in dashboards with detailed metrics
REST APIYesYes (comprehensive, well-documented)
Mobile supportResponsive web UIResponsive web UI, mobile-optimized
LDAP/SSOPaid moduleBuilt-in (LDAP, SAML, OAuth)
Two-factor authPaid moduleBuilt-in (TOTP)
Resource usage~128-256 MB RAM~2-4 GB RAM (with Elasticsearch)
LicenseAGPL-3.0 (paid modules proprietary)AGPL-3.0 (fully open source)
LanguagePHP 7.1-8.x / LaravelRuby on Rails / TypeScript (Vue.js frontend)
CommunityModerate (GitHub: ~2.8k stars)Large (GitHub: ~4.5k stars, 398 contributors)
Full-text searchDatabase queriesElasticsearch (fast, typo-tolerant)

Overview

FreeScout

FreeScout is a lightweight, open-source helpdesk built with PHP and Laravel. It positions itself as a self-hosted Help Scout alternative, and the comparison is apt — the UI is clean, email-centric, and focused on shared inbox workflows. The core application is free under AGPL-3.0, but many features that Zendesk and Help Scout include by default (knowledge base, satisfaction surveys, time tracking, LDAP) are sold as paid modules ranging from $2 to $20 each.

FreeScout’s strength is simplicity. It runs on shared hosting if needed, requires only PHP and MySQL/MariaDB, and stays out of your way. For a small team doing email-only support, it is genuinely excellent.

Zammad

Zammad is a full-featured, open-source ticketing system built with Ruby on Rails and a modern Vue.js frontend. It handles email, chat, phone, Twitter, and Facebook channels from a single interface. Every feature — knowledge base, reporting, LDAP, SLAs, macros, text modules — ships in the open-source version with no paid add-ons.

The trade-off is weight. Zammad requires PostgreSQL, Redis, Memcached, and Elasticsearch in production. Plan for at least 4 GB of RAM. It is an enterprise-grade system, and its infrastructure requirements reflect that.

Installation Complexity

FreeScout is dramatically simpler to deploy. One application container plus a MariaDB database, and you are running. Zammad requires orchestrating six services.

FreeScout Docker Compose

FreeScout does not publish an official Docker image. The most widely used community image is tiredofit/freescout, which bundles Nginx, PHP-FPM, and the FreeScout application on Alpine Linux with automatic setup on first boot.

Create a docker-compose.yml:

services:
  freescout:
    image: tiredofit/freescout:1.17.148
    container_name: freescout-app
    restart: unless-stopped
    depends_on:
      - freescout-db
    ports:
      - "8080:80"
    environment:
      # Database connection
      - DB_TYPE=mysql
      - DB_HOST=freescout-db
      - DB_PORT=3306
      - DB_NAME=freescout
      - DB_USER=freescout
      - DB_PASS=change_this_strong_password

      # Admin account (created on first boot)
      - [email protected]
      - ADMIN_PASS=change_this_admin_password

      # Site configuration
      - SITE_URL=https://support.example.com
      - SETUP_TYPE=AUTO

      # Application settings
      - ENABLE_AUTO_UPDATE=FALSE
      - DISPLAY_ERRORS=FALSE

      # Timezone
      - TIMEZONE=UTC
    volumes:
      - freescout-data:/data
      - freescout-logs:/www/logs
    networks:
      - freescout

  freescout-db:
    image: mariadb:11.7.2
    container_name: freescout-db
    restart: unless-stopped
    environment:
      - MYSQL_ROOT_PASSWORD=change_this_root_password
      - MYSQL_DATABASE=freescout
      - MYSQL_USER=freescout
      - MYSQL_PASSWORD=change_this_strong_password
    volumes:
      - freescout-db:/var/lib/mysql
    networks:
      - freescout

volumes:
  freescout-data:
  freescout-logs:
  freescout-db:

networks:
  freescout:

Start it:

docker compose up -d

First boot takes 2-5 minutes while FreeScout initializes the database schema. Access the web UI at http://your-server:8080 and log in with the ADMIN_EMAIL and ADMIN_PASS you configured.

Zammad Docker Compose

Zammad provides an official Docker Compose setup through the zammad-docker-compose repository. It runs multiple containers: the Rails application server, a background scheduler, a WebSocket server, Nginx, PostgreSQL, Elasticsearch, Redis, and Memcached.

Create a docker-compose.yml:

services:
  zammad-elasticsearch:
    image: elasticsearch:8.19.9
    container_name: zammad-elasticsearch
    restart: unless-stopped
    environment:
      - discovery.type=single-node
      - xpack.security.enabled=false
      - ES_JAVA_OPTS=-Xms1g -Xmx1g
    volumes:
      - elasticsearch-data:/usr/share/elasticsearch/data
    networks:
      - zammad

  zammad-memcached:
    image: memcached:1.6.40-alpine
    container_name: zammad-memcached
    restart: unless-stopped
    command: memcached -m 256
    networks:
      - zammad

  zammad-postgresql:
    image: postgres:17.7-alpine
    container_name: zammad-postgresql
    restart: unless-stopped
    environment:
      - POSTGRES_DB=zammad_production
      - POSTGRES_USER=zammad
      - POSTGRES_PASSWORD=change_this_strong_password
    volumes:
      - postgresql-data:/var/lib/postgresql/data
    networks:
      - zammad

  zammad-redis:
    image: redis:7.4.7-alpine
    container_name: zammad-redis
    restart: unless-stopped
    volumes:
      - redis-data:/data
    networks:
      - zammad

  zammad-init:
    image: ghcr.io/zammad/zammad:7.0.0
    container_name: zammad-init
    restart: on-failure
    depends_on:
      - zammad-elasticsearch
      - zammad-postgresql
      - zammad-redis
      - zammad-memcached
    command: ["zammad-init"]
    environment:
      - POSTGRESQL_HOST=zammad-postgresql
      - POSTGRESQL_PORT=5432
      - POSTGRESQL_DB=zammad_production
      - POSTGRESQL_USER=zammad
      - POSTGRESQL_PASS=change_this_strong_password
      - POSTGRESQL_OPTIONS=?pool=50
      - MEMCACHE_SERVERS=zammad-memcached:11211
      - REDIS_URL=redis://zammad-redis:6379
      - ELASTICSEARCH_HOST=zammad-elasticsearch
      - ELASTICSEARCH_PORT=9200
      - ELASTICSEARCH_SCHEMA=http
      - ELASTICSEARCH_NAMESPACE=zammad
      - ELASTICSEARCH_REINDEX=true
      - ELASTICSEARCH_ENABLED=true
    volumes:
      - zammad-storage:/opt/zammad/storage
    networks:
      - zammad

  zammad-railsserver:
    image: ghcr.io/zammad/zammad:7.0.0
    container_name: zammad-railsserver
    restart: unless-stopped
    depends_on:
      - zammad-init
    command: ["zammad-railsserver"]
    environment:
      - POSTGRESQL_HOST=zammad-postgresql
      - POSTGRESQL_PORT=5432
      - POSTGRESQL_DB=zammad_production
      - POSTGRESQL_USER=zammad
      - POSTGRESQL_PASS=change_this_strong_password
      - POSTGRESQL_OPTIONS=?pool=50
      - MEMCACHE_SERVERS=zammad-memcached:11211
      - REDIS_URL=redis://zammad-redis:6379
      - ELASTICSEARCH_HOST=zammad-elasticsearch
      - ELASTICSEARCH_PORT=9200
      - ELASTICSEARCH_SCHEMA=http
      - ELASTICSEARCH_NAMESPACE=zammad
      - ELASTICSEARCH_ENABLED=true
    volumes:
      - zammad-storage:/opt/zammad/storage
    networks:
      - zammad

  zammad-scheduler:
    image: ghcr.io/zammad/zammad:7.0.0
    container_name: zammad-scheduler
    restart: unless-stopped
    depends_on:
      - zammad-init
    command: ["zammad-scheduler"]
    environment:
      - POSTGRESQL_HOST=zammad-postgresql
      - POSTGRESQL_PORT=5432
      - POSTGRESQL_DB=zammad_production
      - POSTGRESQL_USER=zammad
      - POSTGRESQL_PASS=change_this_strong_password
      - POSTGRESQL_OPTIONS=?pool=50
      - MEMCACHE_SERVERS=zammad-memcached:11211
      - REDIS_URL=redis://zammad-redis:6379
      - ELASTICSEARCH_HOST=zammad-elasticsearch
      - ELASTICSEARCH_PORT=9200
      - ELASTICSEARCH_SCHEMA=http
      - ELASTICSEARCH_NAMESPACE=zammad
      - ELASTICSEARCH_ENABLED=true
    volumes:
      - zammad-storage:/opt/zammad/storage
    networks:
      - zammad

  zammad-websocket:
    image: ghcr.io/zammad/zammad:7.0.0
    container_name: zammad-websocket
    restart: unless-stopped
    depends_on:
      - zammad-init
    command: ["zammad-websocket"]
    environment:
      - POSTGRESQL_HOST=zammad-postgresql
      - POSTGRESQL_PORT=5432
      - POSTGRESQL_DB=zammad_production
      - POSTGRESQL_USER=zammad
      - POSTGRESQL_PASS=change_this_strong_password
      - POSTGRESQL_OPTIONS=?pool=50
      - MEMCACHE_SERVERS=zammad-memcached:11211
      - REDIS_URL=redis://zammad-redis:6379
      - ELASTICSEARCH_HOST=zammad-elasticsearch
      - ELASTICSEARCH_PORT=9200
      - ELASTICSEARCH_SCHEMA=http
      - ELASTICSEARCH_NAMESPACE=zammad
      - ELASTICSEARCH_ENABLED=true
    networks:
      - zammad

  zammad-nginx:
    image: ghcr.io/zammad/zammad:7.0.0
    container_name: zammad-nginx
    restart: unless-stopped
    depends_on:
      - zammad-railsserver
      - zammad-websocket
    command: ["zammad-nginx"]
    ports:
      - "8080:8080"
    environment:
      - NGINX_SERVER_SCHEME=http
      - NGINX_CLIENT_MAX_BODY_SIZE=50M
    volumes:
      - zammad-storage:/opt/zammad/storage
    networks:
      - zammad

volumes:
  elasticsearch-data:
  postgresql-data:
  redis-data:
  zammad-storage:

networks:
  zammad:

Before starting Zammad, set the Elasticsearch memory map limit (required on the host):

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

Start the stack:

docker compose up -d

Initialization takes 3-10 minutes depending on your hardware. Zammad creates the database schema, seeds initial data, and builds the Elasticsearch index. Access the web UI at http://your-server:8080 and follow the setup wizard to create your admin account.

The difference in operational complexity is stark. FreeScout: 2 containers, ~300 MB RAM. Zammad: 9 containers, ~3-4 GB RAM. Choose accordingly.

Performance and Resource Usage

MetricFreeScoutZammad
Minimum RAM256 MB4 GB
Recommended RAM512 MB6-8 GB
Idle CPUNegligibleLow-moderate (Elasticsearch indexing)
Disk (application)~200 MB~2 GB
Disk (data, 10k tickets)~500 MB~3-5 GB (includes Elasticsearch index)
Container count29
Startup time2-5 minutes3-10 minutes

FreeScout runs comfortably on a 1 vCPU / 1 GB VPS. Zammad needs at least a 2 vCPU / 4 GB machine, and 8 GB is recommended for production with Elasticsearch. The Elasticsearch JVM alone reserves 1 GB by default (ES_JAVA_OPTS=-Xms1g -Xmx1g).

If you are running other services on the same server, FreeScout is far easier to colocate. Zammad will compete for memory with anything else on the box.

Extensibility

FreeScout: Paid Module Ecosystem

FreeScout’s core is intentionally minimal. Advanced features come through modules, many of which are paid:

  • Free modules: Custom fields, Slack integration, Telegram, language packs
  • Paid modules ($2-20 each): Knowledge base, satisfaction ratings, time tracking, LDAP, reports, webhooks, WhatsApp, two-factor authentication, SLA management

This model keeps the base application lightweight but can add up. A fully loaded FreeScout with knowledge base, LDAP, time tracking, satisfaction surveys, and advanced reports costs roughly $60-80 in one-time module purchases. That said, these are perpetual licenses — not subscriptions.

Custom module development is possible through Laravel’s standard patterns. The FreeScout developer community publishes free modules on GitHub as well.

Zammad: Everything Included

Zammad ships every feature in the open-source edition. Knowledge base, live chat, phone integration, LDAP/SAML/OAuth, SLAs, macros, triggers, webhooks, text modules, time accounting, and reporting — all included. No paid tiers, no feature gating.

Zammad also provides a comprehensive REST API and supports custom integrations through triggers, webhooks, and schedulers. The codebase is well-structured Ruby on Rails, making custom development straightforward if you know the framework.

The trade-off: you get everything, but you run everything. There is no “lightweight mode” where you skip Elasticsearch to save resources (you technically can disable it, but search performance degrades significantly with large ticket volumes).

Community and Support

AspectFreeScoutZammad
GitHub stars~2,800~4,500
Contributors~50~400
Release cadenceWeekly patchesMonthly patches, yearly major
DocumentationGood (wiki-style)Excellent (structured, versioned)
Commercial supportPaid modules include email supportZammad GmbH offers paid support plans
Community forumGitHub DiscussionsCommunity forums + GitHub
Development paceActive, solo maintainer + communityActive, backed by Zammad GmbH

Zammad has a significantly larger contributor base and is backed by a company (Zammad GmbH) that sells hosted and support plans. This means long-term maintenance is more predictable. FreeScout is primarily maintained by a single developer, which is both a strength (consistent vision, fast patches) and a risk (bus factor of one).

Both projects are actively maintained as of early 2026. FreeScout ships patches nearly weekly. Zammad follows a more structured release cycle with major versions yearly and patches monthly.

Use Cases

Choose FreeScout If…

  • Your support team has 1-5 agents
  • Email is your primary (or only) support channel
  • You want the simplest possible deployment
  • You are running on limited hardware (1 GB RAM VPS, Raspberry Pi, shared hosting)
  • You prefer Help Scout’s clean shared-inbox workflow
  • You only need a few extra features and are fine paying $20-40 for modules
  • You want something running in 10 minutes, not an hour

Choose Zammad If…

  • Your team has 5+ agents or is growing
  • You handle support across email, chat, phone, and social media
  • You need enterprise features: LDAP, SAML SSO, SLAs with escalation
  • You search through tickets frequently and need fast full-text search
  • You want a built-in knowledge base without extra cost
  • You have the infrastructure to spare (4+ GB RAM, 2+ vCPU)
  • Long-term maintainability and a company-backed project matter to you

Final Verdict

FreeScout is the right choice for small teams that primarily do email support. It is light, fast, easy to deploy, and does the shared-inbox workflow better than anything else in the self-hosted space. If you are a small SaaS, a freelancer, or a small business handling a manageable ticket volume, FreeScout gets out of your way and lets you focus on actually helping customers.

Zammad is the right choice for teams that need a real ticketing system. Once you need multi-channel support, SLAs, enterprise authentication, or you are searching through thousands of tickets daily, FreeScout’s simplicity becomes a limitation. Zammad is heavier, but it replaces Zendesk feature-for-feature without the per-agent pricing.

For the most common self-hosting use case — a small to mid-size team looking to replace Zendesk or Freshdesk — Zammad is the stronger pick. The infrastructure overhead is worth it. You get every feature on day one with no module costs, the project has strong long-term backing, and you will not outgrow it as your team scales. Start with FreeScout only if you are certain you will stay small and email-only.

Related Articles

best

Best Self-Hosted Helpdesk Software in 2026

The best self-hosted helpdesk and ticketing systems compared for 2026. Zammad, FreeScout, LibreDesk, osTicket, OTOBO, an...

replace

Self-Hosted Alternatives to Freshdesk

Best self-hosted Freshdesk alternatives for helpdesk ticketing. Zammad, FreeScout, LibreDesk, and OTOBO compared — featu...

replace

Self-Hosted Alternatives to Intercom

Best self-hosted Intercom alternatives for live chat, helpdesk, and customer messaging. Chatwoot, Zammad, FreeScout, and...

compare

FreeScout vs GlitchTip: Which Should You Self-Host?

FreeScout vs GlitchTip compared for self-hosted support workflows. Customer help desk shared inbox versus application er...

compare

LibreDesk vs FreeScout: Which Helpdesk to Self-Host?

LibreDesk vs FreeScout comparison for self-hosted helpdesk. Modern Go single-binary against mature PHP shared inbox — fe...

compare

osTicket vs Zammad: Which Helpdesk to Self-Host?

osTicket vs Zammad compared: resource usage, features, multi-channel support, and which self-hosted helpdesk fits your t...

Read Next Best Self-Hosted Helpdesk Software in 2026

Comments