GlitchTip vs Sentry: Which Error Tracker to Self-Host?

GlitchTip accepts the same Sentry SDKs, uses the same DSN format, and runs in 512 MB of RAM. Sentry self-hosted needs 16 GB of RAM and 40+ containers. That resource gap is the entire conversation for most self-hosters.

Feature Comparison

Feature	GlitchTip	Sentry Self-Hosted
Error tracking	Yes	Yes
Performance monitoring	Basic (transaction tracking)	Full (traces, spans, flame charts)
Session replay	No	Yes
Alerting / notifications	Email, webhooks	Email, Slack, PagerDuty, webhooks, 50+ integrations
SDK compatibility	Uses Sentry SDKs (same DSN)	Native Sentry SDKs
Language/framework SDKs	All Sentry SDKs work	All Sentry SDKs (official support)
Uptime monitoring	Yes (built-in)	Yes (Crons)
Release tracking	Basic	Full (deploys, commits, suspect commits)
Source maps	Yes	Yes (with Symbolicator)
Resource usage (RAM)	512 MB recommended (256 MB minimal)	16 GB minimum (32 GB recommended)
Container count	4 (web, worker, PostgreSQL, Redis)	40+ (Kafka, ClickHouse, Snuba, Relay, etc.)
Setup complexity	docker compose up -d	Custom install script + manual configuration
License	MIT	BSL 1.1 (converts to Apache 2.0 after 36 months)
Pricing (self-hosted)	Free	Free
Pricing (cloud)	Free tier + $4.50/user/month	$26/month per developer

Quick Verdict

GlitchTip is the right choice for most self-hosters. It covers the core job — catching errors, alerting you, and showing stack traces — while using a fraction of the resources. You get Sentry SDK compatibility out of the box, so your application code is identical either way. Only pick Sentry self-hosted if you genuinely need performance monitoring with full distributed tracing, session replay, or the deep integrations ecosystem.

Overview

GlitchTip is a lightweight, open-source error tracking platform written in Django (Python) and Vue.js. It was built from the ground up as a simpler alternative to Sentry that reuses Sentry’s client SDKs. The project launched in 2020 and has steadily added features — uptime monitoring, performance tracking, and team management — while keeping resource requirements minimal. GlitchTip 6, released February 2026, added improved stacktraces and performance improvements.

Sentry is the original open-source error tracking platform that pioneered the space. The self-hosted version runs the same codebase as Sentry’s cloud service, which means you get every feature — performance monitoring, session replay, release tracking, suspect commits, and a massive integrations catalog. The trade-off is complexity: Sentry self-hosted requires Kafka, ClickHouse, Snuba, Relay, Symbolicator, PostgreSQL, Redis, Memcached, Nginx, and dozens of specialized consumer workers. Version 26.1.0 (January 2025) is the latest stable self-hosted release.

Installation Complexity

This is where the two platforms diverge dramatically.

GlitchTip: Simple Docker Compose

GlitchTip runs four containers — the web app, a Celery worker for background tasks, PostgreSQL, and Redis. Create a docker-compose.yml:

services:
  postgres:
    image: postgres:16.8
    restart: unless-stopped
    environment:
      POSTGRES_DB: glitchtip
      POSTGRES_USER: glitchtip
      # Change this to a strong password
      POSTGRES_PASSWORD: glitchtip_db_password
    volumes:
      - pg-data:/var/lib/postgresql/data

  redis:
    image: redis:7.4.7
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 3

  web:
    image: glitchtip/glitchtip:v6.0.10
    restart: unless-stopped
    depends_on:
      - postgres
      - redis
    ports:
      - "8000:8000"
    environment:
      DATABASE_URL: postgres://glitchtip:glitchtip_db_password@postgres:5432/glitchtip
      SECRET_KEY: change-this-to-a-random-64-char-string
      PORT: "8000"
      GLITCHTIP_DOMAIN: https://glitchtip.example.com
      DEFAULT_FROM_EMAIL: [email protected]
      EMAIL_URL: smtp://user:[email protected]:587
      VALKEY_URL: redis://redis:6379/0
      # How long to retain events (days). Default: 90
      GLITCHTIP_MAX_EVENT_LIFE_DAYS: "90"
    volumes:
      - uploads:/code/uploads

  worker:
    image: glitchtip/glitchtip:v6.0.10
    restart: unless-stopped
    command: bin/run-celery-with-beat.sh
    depends_on:
      - postgres
      - redis
    environment:
      DATABASE_URL: postgres://glitchtip:glitchtip_db_password@postgres:5432/glitchtip
      SECRET_KEY: change-this-to-a-random-64-char-string
      GLITCHTIP_DOMAIN: https://glitchtip.example.com
      DEFAULT_FROM_EMAIL: [email protected]
      EMAIL_URL: smtp://user:[email protected]:587
      VALKEY_URL: redis://redis:6379/0
      CELERY_WORKER_AUTOSCALE: "1,3"
      CELERY_WORKER_MAX_TASKS_PER_CHILD: "10000"

  migrate:
    image: glitchtip/glitchtip:v6.0.10
    depends_on:
      - postgres
      - redis
    command: ./manage.py migrate
    environment:
      DATABASE_URL: postgres://glitchtip:glitchtip_db_password@postgres:5432/glitchtip
      SECRET_KEY: change-this-to-a-random-64-char-string
      VALKEY_URL: redis://redis:6379/0

volumes:
  pg-data:
  uploads:

Start it:

docker compose up -d

Create your first user at http://your-server:8000. That is the entire setup.

GlitchTip also supports an all-in-one mode that drops Redis and combines the web and worker processes into a single container. This runs on as little as 256 MB of RAM — viable for a Raspberry Pi or a minimal VPS.

Sentry Self-Hosted: Install Script Required

Sentry self-hosted cannot be deployed with a simple docker-compose.yml you write yourself. The project provides an install script that generates configuration and orchestrates 40+ containers.

# Clone the self-hosted repo at a stable release tag
git clone https://github.com/getsentry/self-hosted.git --branch 26.1.0
cd self-hosted

# Run the installer (interactive — prompts for email/password)
./install.sh

# Start all services
docker compose up --wait

The install script sets up:

• PostgreSQL 14 — primary database
• ClickHouse — analytics and event storage
• Kafka — event streaming and processing
• Redis — caching
• Memcached — sourcemap cache
• Snuba — query layer over ClickHouse
• Relay — event ingestion and filtering
• Symbolicator — debug symbol processing
• Nginx — reverse proxy
• SeaweedFS — S3-compatible object storage
• PgBouncer — PostgreSQL connection pooling
• 30+ Kafka consumers — specialized workers for errors, transactions, profiles, replays, metrics, monitors, and more

You cannot reasonably write or maintain this docker-compose.yml by hand. The generated file is over 1,000 lines. Updates require pulling the new release tag and running ./install.sh again.

Access the web UI at http://your-server:9000 after installation.

Performance and Resource Usage

This is the deciding factor for most self-hosters.

Resource	GlitchTip	Sentry Self-Hosted
Minimum RAM	256 MB (all-in-one)	16 GB + 16 GB swap
Recommended RAM	512 MB	32 GB
CPU cores	1	4
Disk space	1–5 GB (depends on retention)	20 GB minimum (grows fast with ClickHouse)
Disk I/O	Low	High (ClickHouse and Kafka are I/O-heavy)
Container count	4–5	40+
Idle memory footprint	~300 MB	~8 GB
Startup time	10–30 seconds	2–5 minutes

GlitchTip is a Django application backed by PostgreSQL. That architecture is simple and predictable — memory grows linearly with event volume, and a single $5/month VPS can handle thousands of events per day.

Sentry self-hosted runs a distributed data pipeline. Kafka handles event ingestion, ClickHouse stores and queries event data, Snuba translates queries, and dozens of consumer workers process different event types in parallel. This architecture powers Sentry’s cloud platform at scale, but on a single server it means most of your RAM is consumed by infrastructure, not your error data.

If you are running Sentry alongside other services on the same server, plan for at least 32 GB of RAM. GlitchTip can share a 2 GB VPS with a dozen other containers.

SDK Compatibility

GlitchTip uses Sentry’s own SDKs. Your application code is identical for both platforms — you just change the DSN (Data Source Name) URL.

# Python — works with both GlitchTip and Sentry
import sentry_sdk
sentry_sdk.init(
    dsn="https://[email protected]/1",  # Just change this URL
    traces_sample_rate=0.1,
)

// JavaScript — works with both GlitchTip and Sentry
import * as Sentry from "@sentry/browser";
Sentry.init({
  dsn: "https://[email protected]/1",
  tracesSampleRate: 0.1,
});

Supported SDKs include Python, JavaScript, Node.js, Ruby, PHP, Go, Java, .NET, Rust, Elixir, Flutter, React Native, and more. GlitchTip processes the event payloads that these SDKs send — error events, breadcrumbs, tags, user context, and basic transaction data.

The caveat: GlitchTip implements a subset of the Sentry event protocol. Error tracking, breadcrumbs, tags, and basic performance data work. Advanced Sentry features like session replay, profiling, and detailed distributed traces rely on protocol extensions that GlitchTip does not process. Those events are accepted but silently dropped.

Migrating between the two is a DSN change. No code refactoring, no SDK swap.

Use Cases

Choose GlitchTip If…

• You want error tracking without dedicating a server to it
• You run a small to medium team (1–50 developers)
• Your server has limited RAM (under 4 GB)
• You want a simple, quick deployment you can maintain yourself
• SDK compatibility with Sentry is important (keeps the migration door open)
• You need basic uptime monitoring alongside error tracking
• You value a straightforward Django admin interface over a feature-rich UI
• Your primary need is “tell me when something breaks and show me the stack trace”

Choose Sentry Self-Hosted If…

• You need full performance monitoring with distributed tracing and flame charts
• Session replay is a requirement for debugging frontend issues
• You need the deep integrations ecosystem (Slack, PagerDuty, Jira, GitHub, GitLab, etc.)
• You have a dedicated server with 32+ GB of RAM available
• You have a platform team that can maintain a complex Docker deployment
• You need suspect commits, release tracking with deploy metadata, and code owners
• You are running a larger engineering organization (50+ developers) that needs audit logs and fine-grained permissions
• You are evaluating Sentry before committing to their cloud pricing

Final Verdict

GlitchTip wins for the vast majority of self-hosting scenarios. It does the core job — catch errors, show stack traces, send alerts — with 30x less RAM and a fraction of the operational complexity. The fact that it accepts Sentry’s own SDKs means you lose nothing on the client side, and you can migrate to Sentry’s cloud or self-hosted later by changing a single DSN string.

Sentry self-hosted is the better platform in absolute terms. Its performance monitoring, session replay, and integrations ecosystem are unmatched. But those features come at a real cost: 16 GB of RAM minimum, 40+ containers, and a maintenance burden that most small teams cannot justify for error tracking.

The practical recommendation: start with GlitchTip. If you outgrow it — and you will know when you do, because you will want distributed traces or session replay — migrate to Sentry at that point. The SDK compatibility makes this a painless switch.

Related

• How to Self-Host GlitchTip
• Best Self-Hosted Helpdesk and Support Tools
• Self-Hosted Alternatives to Sentry
• Docker Compose Basics
• Reverse Proxy Setup
• Best Self-Hosted Monitoring Tools