How to Install Discourse on Ubuntu 24.04 — Self-Host Your Own Community Forum

Discourse is the modern, open-source forum platform that powers communities for companies like Stack Overflow, BoingBoing, and tens of thousands of open-source projects. It replaces outdated phpBB/vBulletin installations with a clean, real-time interface built around trust levels, intelligent categorization, and a first-class mobile experience. This guide walks you through installing Discourse on an Ubuntu 24.04 VPS, from the initial SSH connection to a fully SSL-secured production forum with plugins, backups, and email delivery configured.

Why run your own? The official Discourse-hosted plan starts at $100/month. A self-hosted install on a 4 vCPU / 8 GB VPS costs less than EUR 25/month and gives you full control over plugins, data, and themes. Launch a Professional VPS now and follow this guide.

Table of Contents

What is Discourse?

Discourse is a modern discussion platform written in Ruby on Rails with an Ember.js frontend. It was founded in 2013 by Jeff Atwood (co-founder of Stack Overflow) with the explicit goal of making forum software that did not feel stuck in 2003. The software is 100% open source under the GPLv2 license and is used by more than 20,000 active communities across open-source projects, SaaS companies, gaming clans, news sites, and internal corporate knowledge bases.

The feature set is deep: infinite-scroll topics with real-time updates via WebSockets, a trust-level system that promotes trusted users automatically, inline reply quoting, embedded media oneboxing, full-text search with PostgreSQL, a polished mobile web app, and an extensive plugin architecture. Discourse ships with built-in email integration — users can read and reply to topics entirely via email if they prefer, and staff can moderate via email. Badges, likes, bookmarks, tags, categories, sub-categories, and user groups all work out of the box.

For self-hosters, the most important property of Discourse is that it is distributed as a single curated Docker image. The team publishes discourse/discourse_docker as the official install mechanism, and this is the only supported path — no manual Ruby/Rails setup, no Postgres tuning from scratch, no Nginx wrangling. The launcher script handles building, upgrading, backing up, and rebuilding the container on every config change. This tutorial follows that official path exactly. The best community resource for questions beyond this guide is meta.discourse.org, the official Discourse-run forum where plugin authors, theme developers, and the core team answer questions daily.

Why Self-Host Discourse Instead of the $100/mo Hosted Plan?

Discourse's own managed hosting starts at $100/month for the "Standard" plan (up to 25k pageviews, no plugins) and scales to $300/month for "Business" (plugins allowed) and $900/month for "Enterprise". While the hosted product is excellent, self-hosting on your own VPS offers real advantages:

• Cost — A 4 vCPU / 8 GB / 100 GB NVMe VPS costs around EUR 24.99/month on the Professional plan. Against the $100/mo hosted Standard plan, self-hosting pays back within the first month and saves over $900/year.
• Unrestricted plugins — The Standard hosted plan does not allow third-party plugins. On your own server you can install any plugin from the official directory or GitHub — Akismet, Data Explorer, Chat, AI, Solved, Patreon, Discord integration, custom SSO, whatever your community needs.
• Data sovereignty — All forum content, user data, uploads, and backups live on your VPS under your control. This matters for GDPR, HIPAA-adjacent use cases, and any organization that cannot send PII to third-party SaaS.
• Custom branding and themes — Full control over themes, component development, custom CSS, and custom JavaScript without needing an Enterprise plan.
• Email deliverability — Use your own transactional email provider (Postmark, Mailgun, AWS SES) with your own reputation and DKIM/SPF on your own domain.
• Resource headroom — An 8 GB VPS comfortably handles a mid-sized community (low thousands of DAU) with overhead left for additional services. Discourse-hosted Standard caps you at 25k pageviews — a busy launch day can exceed that.
• Integration flexibility — Run Discourse alongside your other self-hosted services (Mastodon, Matrix, Rocket.Chat, GitLab, internal tools) on the same infrastructure.

Cost Comparison: Self-Hosted vs. Discourse Hosted

Prerequisites

Before you begin, make sure you have:

• A VPS running Ubuntu 24.04 LTS with root or sudo access
• At least 4 vCPU and 8 GB of RAM (Discourse's official minimum is 1 GB RAM + 2 GB swap, but real-world use with plugins needs 4 GB+ RAM for smooth operation)
• At least 40 GB of SSD/NVMe storage (100 GB recommended to accommodate uploads, backups, and growth)
• A registered domain name with DNS control (you will create an A record pointing to the VPS IP)
• An SMTP provider account — Discourse requires transactional email to send signup confirmations, password resets, and topic notifications. Use Postmark, Mailgun, SendGrid, or AWS SES. Home ISP SMTP will not work.
• SSH access to the VPS
• Ports 80 and 443 open on the VPS firewall (needed for Let's Encrypt and web traffic)

Recommended Plan: Professional

We recommend the Professional VPS plan for Discourse:

- 4 vCPU cores

- 8 GB RAM

- 100 GB NVMe SSD

- Unmetered bandwidth

- EUR 24.99/month

This gives you room for the Discourse app container (Rails + Sidekiq + Redis + PostgreSQL bundled), two or three plugins, and a buffer for growth. For communities under a few hundred DAU the smaller Starter plan can work, but 8 GB RAM is the sweet spot.

Connect to your server via SSH:

ssh root@your-server-ip

Step 1: Prepare the Server

Update the system and configure swap — Discourse's installer explicitly checks for swap and will warn if none is present.

Update package lists and upgrade:

sudo apt update && sudo apt upgrade -y

Set the hostname (replace with your forum's domain):

sudo hostnamectl set-hostname forum.example.com

Add a 2 GB swap file (skip if your VPS already has swap):

sudo fallocate -l 2G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

Verify swap is active:

free -h

Expected output:

total        used        free      shared  buff/cache   available
Mem:           7.8Gi       412Mi       6.8Gi       2.0Mi       628Mi       7.1Gi
Swap:          2.0Gi          0B       2.0Gi

Open HTTP and HTTPS in the firewall:

sudo ufw allow OpenSSH
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw --force enable

Create the DNS A Record

In your DNS provider (Cloudflare, Route 53, your registrar), create an A record pointing your chosen subdomain to the VPS public IP. For example:

Type: A
Name: forum
Value: 203.0.113.50
TTL: 300
Proxy: DNS only (Cloudflare users: disable the orange cloud — Let's Encrypt needs direct access during issuance)

Verify propagation before continuing:

dig +short forum.example.com

The command should return your VPS IP. Wait a few minutes and retry if it returns nothing.

Step 2: Install Docker

Discourse requires Docker. Install it from the official Docker repository rather than the older docker.io package in Ubuntu's archive:

sudo apt install -y ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \
  sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu noble stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io

Verify Docker is running:

sudo systemctl status docker --no-pager
docker --version

Expected output:

Docker version 27.3.1, build ce12230

Step 3: Clone the Discourse Docker Repository

The official installer lives in the discourse/discourse_docker repository. By convention it is cloned to /var/discourse:

sudo -i
git clone https://github.com/discourse/discourse_docker.git /var/discourse
cd /var/discourse

The directory contains:

• launcher — the main management script (start/stop/rebuild/backup/restore)
• discourse-setup — interactive wizard that generates containers/app.yml
• samples/ — example YAML configurations
• containers/ — where your live config lives after setup

Step 4: Run the discourse-setup Wizard

The interactive wizard generates a working containers/app.yml for you:

./discourse-setup

You will be prompted for the following values:

Hostname for your Discourse? [discourse.example.com]: forum.example.com
Email address for admin account(s)? [[email protected]]: [email protected]
SMTP server address? [smtp.example.com]: smtp.postmarkapp.com
SMTP port? [587]: 587
SMTP user name? [[email protected]]: <your-postmark-server-token>
SMTP password? [pa$$word]: <your-postmark-server-token>
Notification email address? [[email protected]]: [email protected]
Optional email address for Let's Encrypt warnings? [[email protected]]: [email protected]

Notes on each value:

• Hostname — Must match the DNS A record you created. Let's Encrypt will issue a certificate for this name.
• Admin email — The email address you will register with as the first account. Whoever owns this address becomes the initial admin.
• SMTP settings — Use your transactional provider's credentials. For Postmark, both username and password are the same server token. For Mailgun, use the SMTP credentials from the domain settings (not your API key).
• Let's Encrypt email — Used for expiry warnings.

Expected output at the end:

Your site is ready! Visit:
https://forum.example.com

If the bootstrap fails, scroll up in the logs for the specific error — usually a DNS or SMTP misconfiguration. Fix it and re-run ./discourse-setup (it is idempotent) or edit containers/app.yml directly and run ./launcher rebuild app.

Step 5: Review and Tune app.yml

Open the generated configuration:

nano /var/discourse/containers/app.yml

Key sections to understand:

templates:
  - "templates/postgres.template.yml"
  - "templates/redis.template.yml"
  - "templates/web.template.yml"
  - "templates/web.ratelimited.template.yml"
  - "templates/web.ssl.template.yml"          # Let's Encrypt SSL
  - "templates/web.letsencrypt.ssl.template.yml"
expose:
  - "80:80"    # HTTP (redirects to 443)
  - "443:443"  # HTTPS
params:
  db_default_text_search_config: "pg_catalog.english"
  db_shared_buffers: "2048MB"   # ~25% of host RAM, auto-tuned by wizard
  db_work_mem: "40MB"
  version: tests-passed
env:
  LANG: en_US.UTF-8
  UNICORN_WORKERS: 4
  DISCOURSE_HOSTNAME: 'forum.example.com'
  DISCOURSE_DEVELOPER_EMAILS: '[email protected]'
  DISCOURSE_SMTP_ADDRESS: smtp.postmarkapp.com
  DISCOURSE_SMTP_PORT: 587
  DISCOURSE_SMTP_USER_NAME: <token>
  DISCOURSE_SMTP_PASSWORD: <token>
  LETSENCRYPT_ACCOUNT_EMAIL: '[email protected]'

Important tuning notes:

• UNICORN_WORKERS — Rails application workers. Default is 4. If you have 8 GB RAM and run plugins, keep at 4. On 4 GB RAM drop to 2. On 16 GB you can raise to 6.
• db_shared_buffers — PostgreSQL shared memory. The wizard autodetects and sets ~25% of host RAM. Do not raise above this.
• version — tests-passed tracks the latest build that passed CI. For maximum stability change to stable (less frequent updates, better tested).
• web.letsencrypt.ssl.template.yml — Handles cert issuance and renewal automatically inside the container. No external certbot needed.

Step 6: Rebuild the App Container

The wizard already runs this during setup, but this is the command you will use for every future config change or Discourse upgrade:

cd /var/discourse
./launcher rebuild app

The rebuild process:

Expected total time: 5-10 minutes on the Professional plan. During the rebuild the forum is offline — plan maintenance windows accordingly. After completion, visit https://forum.example.com and you should see the Discourse welcome screen with a valid SSL certificate (padlock icon, cert issued by Let's Encrypt).

Step 7: Create the First Admin Account

Open your forum URL in a browser:

https://forum.example.com

Click Sign Up and register with the email address you provided as DISCOURSE_DEVELOPER_EMAILS. Discourse automatically grants admin privileges to any account registered with an email address listed in that variable.

Check your inbox for the confirmation email — if it doesn't arrive within a minute, SMTP is misconfigured. From the server, check the mail queue:

cd /var/discourse
./launcher enter app
rails c
Inside the Rails console:
ActionMailer::Base.deliveries

The most common SMTP issue is wrong credentials or port 587 blocked by your SMTP provider's IP allowlist. Fix the credentials in app.yml, rebuild, and retry.

Once confirmed, click the welcome banner to run the Admin Quick Start — Discourse walks you through branding, the welcome topic, and essential settings.

Step 8: Configure Categories, Tags, and Trust Levels

Healthy Discourse communities rely on the right mix of categories (hierarchical, permissioned) and tags (flat, free-form, cross-cutting).

Create Core Categories

Go to Admin > Categories > + New Category and create an initial structure:

• Announcements (staff-only posting)
• General Discussion
• Support (for help-seeking)
• Feedback (for product feedback, if applicable)
• Off-Topic (watercooler / lounge)

• Security — Who can see, reply, and create topics
• Moderators — Which groups have mod powers in this category
• Email in — Optional email alias for posting via email
• Auto-close — Automatically lock topics after N days of inactivity

Enable Tagging

Go to Admin > Settings and search for tagging. Enable:

• tagging enabled = true
• min trust to create tag = 3 (members can create tags)
• min trust level to tag topics = 1

Trust Levels

Discourse's trust level system automates community health. The defaults are sensible and you generally should not change them in the first 90 days:

• TL0 (New) — Just signed up. Rate-limited.
• TL1 (Basic) — After 10 minutes reading, 5 topics viewed, 30 posts read. Can upload, post links.
• TL2 (Member) — After 15 days, 100 likes given/received, 20 topics entered. Can invite.
• TL3 (Regular) — Earned by sustained participation. Can recategorize/rename topics.
• TL4 (Leader) — Granted manually. Staff-adjacent powers.

Step 9: Install Essential Plugins

Plugins are declared in app.yml under the hooks: section. After editing, run ./launcher rebuild app. The three plugins below cover the vast majority of community needs.

Open the config:

nano /var/discourse/containers/app.yml

Find the hooks: section (scroll toward the bottom) and replace the after_code block with:

hooks:
  after_code:
    - exec:
        cd: $home/plugins
        cmd:
          - git clone https://github.com/discourse/docker_manager.git
          - git clone https://github.com/discourse/discourse-chat.git
          - git clone https://github.com/discourse/discourse-data-explorer.git
          - git clone https://github.com/discourse/discourse-akismet.git

Rebuild:

cd /var/discourse
./launcher rebuild app

What each plugin does:

• docker_manager (bundled by default) — Admin UI for one-click Discourse upgrades. Browse to /admin/upgrade to update without SSHing into the box.
• Discourse Chat — Real-time chat channels integrated directly into Discourse. Adds a sidebar for DMs and topic-style chat channels. Great for communities that want a Slack/Discord-lite experience alongside async forum threads.
• Data Explorer — Gives admins a SQL console to query the Discourse PostgreSQL database directly. Essential for building custom analytics dashboards, cohort queries, or exporting data. Ships with dozens of curated query templates.
• Akismet Anti-Spam — Sends posts from new users through the Akismet spam classifier. Requires a free or paid Akismet API key configured at /admin/site_settings/category/spam. Catches 95%+ of spam at TL0.

• Solved — Mark replies as "solution" in Q&A categories
• AI — Summarization, auto-tagging, AI-assisted replies
• Calendar/Events — Event scheduling and calendar view
• Policy — Track acknowledgments of staff announcements

Step 10: Configure Automated Backups

Discourse includes a built-in backup system that runs in-process and saves a full snapshot (database + uploads) as a .tar.gz file.

Go to Admin > Backups and configure:

• automatic backups enabled = true
• backup frequency = 7 (days — weekly is typical; daily for busy forums)
• maximum backups = 5 (number of rotated backups to keep locally)
• backup time of day = 04:00 (UTC, off-peak)

Enable Off-Site Backups to S3

Keeping backups only on the VPS is risky — if the box is compromised or deleted you lose everything. Configure S3-compatible storage:

• s3 backup bucket = your-discourse-backups
• s3 access key id = <your-key>
• s3 secret access key = <your-secret>
• s3 region = eu-central-1 (or your bucket's region)
• backup location = s3

Manual Backup from the CLI

You can also trigger a backup from the host at any time:

cd /var/discourse
./launcher enter app
discourse backup
exit

Backup files land in /var/discourse/shared/standalone/backups/default/ inside the host filesystem (bind-mounted from the container).

Restoring from Backup

To restore, enable restores first (Admin > Backups > allow restore), then upload the .tar.gz via the admin UI and click Restore. The process stops the site, replaces the database, and restarts — plan for 5-15 minutes of downtime depending on backup size.

Step 11: Nginx Pass-Through or Direct 443

By default, the Discourse container binds directly to ports 80 and 443 on the host and handles Let's Encrypt itself. This is the supported and recommended configuration. However, many sysadmins run additional services on the same host (marketing site, API, other apps) and need a front-door proxy.

Option A: Direct 443 (Recommended — Default)

This is what discourse-setup configures. Discourse handles SSL termination and Let's Encrypt renewal inside the container. No host Nginx is needed. Pros: least config, officially supported, zero-touch cert renewal. Cons: port 80/443 are exclusive to Discourse.

No action needed — this is your current setup.

Option B: Host Nginx Pass-Through (Multi-Site VPS)

If you need to host other services on the same VPS, run a host-level Nginx that reverse-proxies to Discourse on an internal port. Edit /var/discourse/containers/app.yml to expose Discourse only on a local port:

expose:
  - "127.0.0.1:8080:80"   # bind to localhost only
templates:
  - "templates/postgres.template.yml"
  - "templates/redis.template.yml"
  - "templates/web.template.yml"
  - "templates/web.ratelimited.template.yml"
  # Comment out the SSL and Let's Encrypt templates — host Nginx handles TLS:
  # - "templates/web.ssl.template.yml"
  # - "templates/web.letsencrypt.ssl.template.yml"

Rebuild:

./launcher rebuild app

Then install Nginx and Certbot on the host:

sudo apt install -y nginx certbot python3-certbot-nginx

Create /etc/nginx/sites-available/discourse:

server {
    listen 80;
    server_name forum.example.com;
    return 301 https://$host$request_uri;
}
server {
    listen 443 ssl http2;
    server_name forum.example.com;
    ssl_certificate     /etc/letsencrypt/live/forum.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/forum.example.com/privkey.pem;
    client_max_body_size 50m;
    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto https;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_read_timeout 300s;
    }
}

Enable and obtain cert:

sudo ln -s /etc/nginx/sites-available/discourse /etc/nginx/sites-enabled/
sudo certbot --nginx -d forum.example.com
sudo nginx -t && sudo systemctl reload nginx

Unless you specifically need the multi-site setup, stick with Option A. The in-container Let's Encrypt template is battle-tested and one less moving part.

Ongoing Maintenance

Discourse is an actively developed project and requires regular upgrades. The good news: docker_manager makes this a one-click operation.

Upgrading Discourse

In the admin UI, visit /admin/upgrade. You will see a list of updates: Discourse core, each plugin, and the Docker manager itself. Click Update All and wait 2-5 minutes.

For major version upgrades or plugin changes that require a container rebuild, the UI will prompt you to run:

cd /var/discourse
./launcher rebuild app

Monitoring

Check the container status:

cd /var/discourse
./launcher logs app

Tail Discourse's internal logs (Rails, Sidekiq, Nginx-in-container):

./launcher enter app
tail -f /var/log/rails/production.log
tail -f /shared/log/rails/sidekiq.log

The admin dashboard at /admin shows active users, pending queue size, error rates, and version status — check it weekly.

Troubleshooting

FAQ

How many concurrent users can a 4 vCPU / 8 GB Discourse VPS handle?

Comfortably a few hundred DAU (daily active users) with 10-30k pageviews per day on the Professional plan, assuming default plugins and normal forum usage patterns. Discourse is Ruby on Rails under Unicorn workers, and performance scales with RAM (more workers) and CPU (faster requests). If your community grows beyond that, move to an 8 vCPU / 16 GB plan and bump UNICORN_WORKERS to 6-8. For very large communities (100k+ DAU) the usual next step is a separate PostgreSQL server and Redis server, which Discourse supports via additional Docker containers on the same or separate hosts.

Can I migrate an existing phpBB, vBulletin, or XenForo forum to Discourse?

Yes. Discourse ships with official import scripts for phpBB, vBulletin, Vanilla, SMF, bbPress, Drupal, NodeBB, Kunena, XenForo, and others. The scripts live in /var/www/discourse/script/import_scripts/ inside the container. The process is: export your old forum's database, copy it into the container, run the matching import script, then run a set of post-import rake tasks to rebuild search indexes and thumbnails. Plan for several hours on large forums and do a dress rehearsal on a staging VPS first. The official migration guide on meta.discourse.org covers every supported source platform.

Does Discourse replace Slack, Discord, Mastodon, or Matrix for my community?

Partially, and the answer depends on your community's communication style. Discourse excels at asynchronous, long-form, searchable discussion — the kind of content that is still useful a year from now. It does not replace real-time chat. For that, install the official Discourse Chat plugin for a Slack-lite experience integrated with your forum, or pair Discourse with a dedicated chat platform. Many communities run Discourse for announcements and long-form discussion alongside Matrix Synapse for federated encrypted chat, or Rocket.Chat for a Slack-like self-hosted experience. If your community is outward-facing and you want a presence on the fediverse, Mastodon covers that social/microblogging angle. Discourse, Matrix, and Mastodon together cover forum + chat + social without any SaaS lock-in.

How do I handle DKIM, SPF, and DMARC for Discourse email?

Transactional email deliverability is about your SMTP provider, not Discourse itself. Use a reputable provider (Postmark, Mailgun, AWS SES) and configure the provider's published DKIM and SPF records on your sending domain's DNS. Postmark and Mailgun provide exact DNS snippets you paste into Cloudflare or your registrar. Then add a DMARC record like v=DMARC1; p=quarantine; rua=mailto:[email protected]. Use the DISCOURSE_NOTIFICATION_EMAIL to set the From address to something like [email protected] on a domain you control. Verify deliverability with mail-tester.com before launch.

Is it safe to run Discourse on the same VPS as my main website?

Technically yes with host Nginx pass-through (Step 11 Option B), but we recommend a dedicated VPS for anything beyond a small community. Discourse's Ruby workers have bursty memory usage, and a busy Sidekiq background job run can briefly pressure RAM on a shared host. A 4 vCPU / 8 GB Professional plan dedicated to Discourse is clean, isolated, and easy to upgrade or migrate. If you must co-locate, reserve at least 8 GB RAM for Discourse alone and run your marketing site on a separate host or container.

How do I enable single sign-on (SSO) so users log in through my main app?

Discourse supports two SSO modes: DiscourseConnect (formerly "SSO") and OAuth2/SAML. DiscourseConnect is a simple shared-secret protocol where your main app generates a signed payload that Discourse trusts — perfect if you already have a Rails/Django/Node app with its own user database. Configure at /admin/site_settings/category/login by setting enable discourse connect, discourse connect url, and discourse connect secret. For OAuth2 (Google, GitHub, Microsoft), use the built-in providers — no plugin needed, just enter the client ID/secret. For SAML (enterprise IdPs like Okta, Auth0, Azure AD), install the discourse-saml plugin.

What happens if Discourse stops releasing updates or goes commercial?

Discourse is GPLv2 open source and the entire codebase is on GitHub. Even if the company pivoted or closed tomorrow, the software would continue to run on your VPS indefinitely and the community would fork it — this is exactly what happened with phpBB, Mastodon, and countless other projects. You own the data (full Postgres dump via backup), you own the uploads (in /var/discourse/shared/), and you can export everything at any time. That is the core reason to self-host: you are never one pricing change or acquisition away from losing your community.

Next Steps

Now that Discourse is running, here are the highest-impact follow-ups:

• Brand the forum — Go to /admin/customize/themes and install a community theme, upload your logo, and set the color palette. Check out the official theme directory on meta.discourse.org for polished starting points.
• Pair with real-time chat — Install Matrix Synapse for federated encrypted chat or Rocket.Chat for a Slack-style experience on the same infrastructure.
• Add a microblog presence — Self-host Mastodon to give your community a fediverse front door that links back to long-form discussions on Discourse.
• Set up monitoring — Deploy Uptime Kuma on a separate VPS to monitor https://forum.example.com and page you when it goes down. Discourse admins should never learn about downtime from users.
• Write your first welcome topics — Pin a "Start Here" topic, a community FAQ, and a community guidelines topic. These single-handedly shape the tone of new-user behavior.
• Join meta.discourse.org — The official community for Discourse admins. Run by the Discourse team, full of plugin authors, theme developers, and fellow self-hosters. Every question you will have has been answered there.

Skip the Manual Install — Deploy a Pre-Configured Community Stack

Our Professional VPS plans give you the headroom to run Discourse comfortably, and you can add Matrix, Rocket.Chat, or Mastodon on the same or neighboring boxes for a complete self-hosted community stack.

- 4 vCPU, 8 GB RAM, 100 GB NVMe

- Ubuntu 24.04 LTS with root access

- Unmetered bandwidth

- Daily automated VPS-level backups available

Deploy Your Professional VPS Now — Plans start at EUR 24.99/month.