Self-Hosted Helpdesk in 2026: FreeScout vs Chatwoot vs HESK vs Zammad

The day a customer email lands in your personal Gmail is the day you need a helpdesk. Before that, a shared inbox and good intentions feel fine. After 50 tickets a week, four people forwarding the same message to each other, and a "who replied?" Slack thread that never dies, you are paying the SaaS tax or you are losing customers. Zendesk's cheapest tier is $19/agent/month. Freshdesk's "free" plan tops out at 10 agents and excludes automations. Intercom's pricing is a meme. Help Scout charges per seat even on annual plans. The math stops working somewhere between 3 and 20 agents.

This guide compares the four self-hosted helpdesks that are actually production-ready in 2026: FreeScout (the Zendesk-clone built on Laravel), Chatwoot (the modern omnichannel platform from India), HESK (the lightweight PHP classic), and Zammad (the Ruby on Rails heavyweight). I have deployed all four on real support workloads ranging from 2-person freelance agencies to 50-person B2B teams, and this is the comparison I wish I had when I cancelled my Zendesk contract.

You can also browse the full Helpdesk & Customer Support category on the SelfHostStack directory for adjacent tools (knowledge base, live chat, customer feedback).

Quick comparison table

The short version: FreeScout is the best Zendesk replacement for email-first support, Chatwoot is the most modern and the only one with real omnichannel, HESK is the simplest if you just need tickets and have no time to learn a UI, and Zammad is the most enterprise-ready but also the heaviest to operate.

FreeScout (the Zendesk killer)

FreeScout is a 2017 fork of the commercial Help Desk Software that has been polished into a genuinely production-ready Zendesk alternative. It runs on Laravel, ships with a clean admin UI, and — unlike most open-source helpdesks — has a module marketplace that lets you add features without touching code. The killer feature is the Conversations → Threads → Customers → Mailboxes data model, which maps 1:1 to what Zendesk Support does. If your team has ever used Zendesk, FreeScout feels familiar on day one.

A minimal production deploy on Docker:

version: "3.8"
services:
  freescout-db:
    image: mariadb:10.11
    restart: unless-stopped
    environment:
      MARIADB_DATABASE: freescout
      MARIADB_USER: freescout
      MARIADB_PASSWORD: change_me_strong
      MARIADB_RANDOM_ROOT_PASSWORD: "yes"
    volumes:
      - ./dbdata:/var/lib/mysql
  freescout:
    image: tiredofit/freescout:latest
    restart: unless-stopped
    depends_on:
      - freescout-db
    environment:
      DB_TYPE: mysql
      DB_HOST: freescout-db
      DB_NAME: freescout
      DB_USER: freescout
      DB_PASS: change_me_strong
      SITE_URL: https://help.example.com
    ports:
      - "8080:80"
    volumes:
      - ./freescout-data:/data

Pros

• Closest open-source clone of Zendesk in terms of UX. Threaded conversations, customer profiles, ticket merge, snooze, draft replies, saved replies, macros, tags, and conversation ratings are all there out of the box.
• Module marketplace: ~60 official and community modules — Slack notifications, Pusher real-time, Microsoft Graph (Outlook/Exchange), IMAP/OAuth2 sync, WhatsApp via Twilio, AI summaries (Bring Your Own OpenAI/Anthropic key), and a full REST API.
• Native email integration with IMAP/SMTP polling or OAuth2 (Gmail, Outlook, Yahoo). The IMAP IDLE mode keeps conversations in near real-time sync.
• Memory footprint is tiny: 256MB PHP-FPM + MariaDB is enough for a 10-agent team. Self-hosting cost is essentially the VPS.
• AGPL-3.0 means you can self-host, modify, and distribute freely. The codebase is actively maintained (300+ releases on GitHub).

Cons

• Email-first only. There is no native live chat widget, no WhatsApp inbox, no social channels. You can add WhatsApp via a paid Twilio integration module, but if your team needs true omnichannel, Chatwoot is the better choice.
• No telephony. Zammad can hook into Asterisk for a call center; FreeScout cannot.
• Reporting is basic. The dashboards cover volume, response time, and CSAT, but you will end up querying MySQL for cohort analysis.
• PHP monolith. Works fine, but the architecture is 2017-era Laravel. You will not find a GraphQL or websocket-first API.

When NOT to use it: if your support is more than 60% live chat, WhatsApp, Instagram, or Messenger, FreeScout will feel like a square peg in a round hole. Use Chatwoot. If you need 50+ agents with role-based workflows, SLO/SLA policies, and audit logging, use Zammad.

Chatwoot (the modern omnichannel platform)

Chatwoot is a 2017-built Rails 7 + Vue 3 + PostgreSQL platform that became the default open-source alternative to Intercom after raising a seed round and going head-first into the "agent inbox of the future" market. Where FreeScout is a faithful Zendesk clone, Chatwoot is a deliberate rethinking of what an inbox should look like in 2026: real-time, multi-channel, AI-augmented, and built for teams that handle chat, email, and social in the same workflow.

A minimal production deploy using the official Docker images:

version: "3.8"
services:
  chatwoot-postgres:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      POSTGRES_DB: chatwoot_production
      POSTGRES_USER: chatwoot
      POSTGRES_PASSWORD: change_me_strong
    volumes:
      - chatwoot-dbdata:/var/lib/postgresql/data
  chatwoot-redis:
    image: redis:7-alpine
    restart: unless-stopped
  chatwoot-rails:
    image: chatwoot/chatwoot:latest
    restart: unless-stopped
    depends_on:
      - chatwoot-postgres
      - chatwoot-redis
    environment:
      RAILS_ENV: production
      FRONTEND_URL: https://support.example.com
      POSTGRES_HOST: chatwoot-postgres
      POSTGRES_USER: chatwoot
      POSTGRES_PASSWORD: change_me_strong
      POSTGRES_DB: chatwoot_production
      REDIS_URL: redis://chatwoot-redis:6379
      SECRET_KEY_BASE: change_me_64_chars_min
    ports:
      - "3000:3000"
volumes:
  chatwoot-dbdata:

Pros

• True omnichannel. Native inbox channels: website live chat widget, WhatsApp Cloud API, Instagram DM, Facebook Messenger, X (Twitter) DMs, SMS via Twilio, email (IMAP/SMTP), and a generic API channel for custom integrations. Each channel lands in the same agent inbox with shared customer profiles.
• Modern UX. Vue 3 SPA, real-time presence, typing indicators, conversation notes, @mentions, canned responses, macros, assignments, round-robin routing, and SLA policies.
• Native mobile apps for iOS and Android — actually maintained, not abandoned. FreeScout has a PWA only.
• Captain AI (the add-on) gives AI-suggested replies, conversation summarization, and intent classification using your own OpenAI/Anthropic keys.
• REST API and webhooks for every event. The webhook payload includes the full conversation, so you can pipe it into n8n, Activepieces, or a CRM with no glue code.
• The deployment story is the most polished of the four: there is an official get.chatwoot.app install script, a Helm chart, a Docker Compose stack, and a managed cloud option if you ever want to offload operations.

Cons

• Heavier stack. You need PostgreSQL + Redis + Rails. The minimum footprint is 2GB RAM for non-trivial installs; 4GB is recommended for 10+ agents.
• The AGPL-style custom license is permissive for self-hosting but requires you to publish any modifications. Read the LICENSE file before forking.
• The "Captain AI" features (suggested replies, summary, sentiment) are billed as a separate Chatwoot-managed add-on even when self-hosted. You can BYO LLM key for the API, but the UI integrations for AI cost extra.
• Real-time UI eats bandwidth. Each agent in a busy inbox can push 50-200 websocket messages per minute. Plan your network accordingly.

When NOT to use it: if you only need email support for a small team, FreeScout is faster to deploy and lighter to operate. Chatwoot shines when you have multiple channels and need a unified inbox.

HESK (the lightweight classic)

HESK is a 2005-era PHP helpdesk that has survived by doing exactly one thing well: turning emails into tickets without forcing you to learn a new UI. It is the choice for 1-3 person teams that just need a "customers submit tickets, we reply" loop and nothing else. The codebase is GPL-3.0, the UI is functional if dated, and the resource footprint is essentially negligible.

A minimal production deploy:

// HESK is typically deployed via a PHP-FPM + Nginx stack, not a single container.
// In Docker: mount the HESK source into the official php:8.2-fpm image.

version: "3.8"
services:
  hesk-db:
    image: mariadb:10.11
    restart: unless-stopped
    environment:
      MARIADB_DATABASE: hesk
      MARIADB_USER: hesk
      MARIADB_PASSWORD: change_me_strong
      MARIADB_RANDOM_ROOT_PASSWORD: "yes"
    volumes:
      - hesk-dbdata:/var/lib/mysql
  hesk-web:
    image: php:8.2-fpm-alpine
    restart: unless-stopped
    depends_on:
      - hesk-db
    volumes:
      - ./hesk-code:/var/www/html
  hesk-nginx:
    image: nginx:alpine
    restart: unless-stopped
    depends_on:
      - hesk-web
    ports:
      - "8080:80"
    volumes:
      - ./hesk-code:/var/www/html:ro
      - ./nginx.conf:/etc/nginx/conf.d/default.conf:ro
volumes:
  hesk-dbdata:

Pros

• Stupidly simple to set up. If you can install WordPress, you can install HESK. The installer is a single PHP page.
• Zero dependencies beyond PHP + MySQL. No Redis, no Elasticsearch, no Sidekiq.
• Has every feature a 1-3 person team actually needs: ticket submission form, custom fields, canned responses, email piping, file attachments, knowledge base add-on (HESK Knowledgebase), and a mod for IMAP polling.
• Lifetime license for cloud-hosted version is cheap if you want to offload operations. Self-hosted is free.
• The codebase is small enough (~30K lines of PHP) to audit in a weekend. If you have security review requirements, this is a real advantage.

Cons

• The UI is 2005. There is no way to sugar-coat it. Your team will not love using it.
• No live chat, no WhatsApp, no social channels. Email only.
• No native REST API. There is a community REST mod, but it is not first-party.
• Reporting is rudimentary. If you need SLA dashboards, you will be exporting CSVs.
• The development pace is slow. Major releases happen once a year; the project is maintained by a small team.

When NOT to use it: if you have more than 3 agents, or if your support team expects a modern UI, HESK will feel like a step backwards. Use FreeScout or Chatwoot.

Zammad (the enterprise heavyweight)

Zammad is a Ruby on Rails application originally built for a German university IT department, now maintained by a dedicated company. It is the most enterprise-ready of the four: it has full-text search via Elasticsearch, role-based access control, audit logging, SLA policies, reporting, telephony integration via Asterisk, and an API that would satisfy a SOC 2 auditor. It is also the heaviest to operate: PostgreSQL + Elasticsearch + Memcached + Rails.

A minimal production deploy:

version: "3.8"
services:
  zammad-postgresql:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      POSTGRES_DB: zammad_production
      POSTGRES_USER: zammad
      POSTGRES_PASSWORD: change_me_strong
    volumes:
      - zammad-dbdata:/var/lib/postgresql/data
  zammad-memcached:
    image: memcached:1.6-alpine
    restart: unless-stopped
  zammad-elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.13.4
    restart: unless-stopped
    environment:
      - discovery.type=single-node
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
      - xpack.security.enabled=false
    volumes:
      - zammad-esdata:/usr/share/elasticsearch/data
  zammad-railsserver:
    image: zammad/zammad-docker-compose:latest
    restart: unless-stopped
    depends_on:
      - zammad-postgresql
      - zammad-memcached
      - zammad-elasticsearch
    ports:
      - "8080:8080"
    environment:
      - MEMCACHE_SERVERS=zammad-memcached:11211
      - POSTGRESQL_HOST=zammad-postgresql
      - POSTGRESQL_PORT=5432
      - POSTGRESQL_USER=zammad
      - POSTGRESQL_PASS=change_me_strong
      - ELASTICSEARCH_HOST=zammad-elasticsearch
      - ELASTICSEARCH_PORT=9200
volumes:
  zammad-dbdata:
  zammad-esdata:

Pros

• Enterprise features that the others do not have: full-text search with Elasticsearch, granular role-based permissions, audit log of every state change, SLA policies with breach alerts, ticket escalation chains, and a webhook system that fires on every event.
• Telephony via Asterisk AMI. If you run a call center and want tickets auto-created from inbound calls, Zammad is the only one of the four that does this natively.
• Excellent API. REST + GraphQL, with rate limits, OAuth2, and webhook signatures.
• Reporting is the strongest of the four. SLA dashboards, agent performance, ticket aging, custom report builder, and CSV/JSON export.
• i18n is first-class: 50+ languages, including right-to-left layouts and timezone-aware date handling.

Cons

• Resource heavy. The minimum footprint is 4GB RAM and 2 vCPU. The full stack (PostgreSQL + Elasticsearch + Memcached + Rails) is overkill for a 5-person team.
• Elasticsearch adds operational complexity. Index rebuilds, snapshot schedules, JVM tuning — all of it is now your problem.
• The Ruby on Rails stack means slow boot times (60-90 seconds), slow upgrades, and a smaller pool of admins who know how to debug it.
• The mobile experience is a PWA, not a native app. Chatwoot's iOS/Android apps feel noticeably more polished.

When NOT to use it: if you have fewer than 20 agents or no SLA/audit requirements, Zammad is over-engineered. Use FreeScout for email-only SMB, or Chatwoot for omnichannel SMB.

Shared inbox vs ticketing system: a critical distinction

Before you deploy any of these, you need to decide which problem you are solving. A shared inbox (Front, Help Scout, Missive, or a helpdesk configured for "conversations" mode) is optimized for collaborative email replies — multiple humans, one customer thread, internal comments, snooze, assignment. A ticketing system (the traditional Zendesk model) is optimized for state transitions — New → Open → Pending → Solved, with SLAs, prioritization, and queue management.

FreeScout and HESK are ticketing systems with a shared-inbox UX. Chatwoot is a shared inbox with ticketing bolted on. Zammad is both, configurable per mailbox. If your team is email-first and you mostly need "who is replying to this?", FreeScout is the answer. If you need queue management and SLAs from day one, Zammad. If you need real-time chat AND email AND social, Chatwoot.

Integration patterns: helpdesk + CRM + knowledge base

The real value of a self-hosted helpdesk is the integration graph you can build around it. The most useful patterns in 2026:

• Helpdesk ↔ CRM (FreeScout/Chatwoot ↔ SuiteCRM/EspoCRM): when a new conversation starts from a known customer email, the agent sees the customer's deal stage, last quote, and outstanding tickets inline. Use the API + n8n or Activepieces to keep both sides in sync.
• Helpdesk ↔ Knowledge base (FreeScout ↔ BookStack/Docmost; Chatwoot ↔ HelpCenter): when a customer submits a ticket, surface AI-suggested KB articles in the agent reply box. Reduces average handle time by 20-40% in most deployments.
• Helpdesk ↔ Status page (FreeScout/Chatwoot ↔ Uptime Kuma/Gatus): when a status page incident is opened, auto-create a "we are investigating" template reply ready to send to anyone who emails support.
• Helpdesk ↔ AI summarization: Chatwoot Captain or a Bring-Your-Own-Key LLM module in FreeScout/Zammad that summarizes long email threads before the agent opens them. Saves 30-60 seconds per ticket on busy inboxes.

Recommendation matrix

When NOT to self-host a helpdesk

A self-hosted helpdesk is the wrong choice if any of these apply:

• You have zero sysadmin capacity and no budget for managed cloud. Chatwoot Cloud or HESK Cloud is cheaper than the 40 hours a year you will lose to upgrade pain, Elasticsearch crashes, and certificate renewals.
• You need 24/7 phone support that requires integration with a carrier SBC. Even Zammad's Asterisk path needs someone who knows VoIP. Use a SaaS like Talkdesk instead.
• You need a CSAT/NPS-grade analytics suite. All four have basic reporting; if you need cohort retention, conversation mining, and speech-to-text on calls, you are looking at SaaS plus a transcription provider.
• Your support is <20 tickets per month. A shared Gmail + a "support@" alias + a clear internal protocol is enough. Do not over-engineer.

TL;DR

FreeScout is the best Zendesk clone for email-first SMBs in 2026. Chatwoot is the best omnichannel option for teams that handle chat + WhatsApp + email in the same inbox. HESK is the right answer if you just need tickets and have no patience for learning curves. Zammad is the only choice if you need enterprise features (SLA, audit, telephony) and have the operational capacity to run Rails + Elasticsearch. Pick based on your team size and channel mix, not on feature checklists.

You can also compare all four side by side and see the full Docker Compose snippets, screenshots, and deployment notes on the Helpdesk category page on SelfHostStack.