How to Self-Host Taiga with Docker Compose

What Is Taiga?

Taiga is an open-source agile project management platform for Scrum and Kanban teams. It includes sprint planning, backlogs, user stories, tasks, epics, wiki, and a clean UI that non-technical team members can use without training. It replaces Jira, Trello, and Asana for agile teams that want full control of their project data.

Prerequisites

A Linux server (Ubuntu 22.04+ recommended)
Docker and Docker Compose installed (guide)
3 GB of free disk space
2 GB of RAM (minimum)
A domain name (recommended — Taiga generates absolute URLs using the configured domain)

Docker Compose Configuration

Clone the official Taiga Docker repository and configure it:

git clone https://github.com/taigaio/taiga-docker.git ~/taiga
cd ~/taiga
git checkout stable
cp .env.example .env

Edit the .env file with your settings:

# Domain and scheme — change these to match your setup
TAIGA_SCHEME=http
TAIGA_DOMAIN=localhost:9000
SUBPATH=""
WEBSOCKETS_SCHEME=ws

# Security — MUST change these from defaults
TAIGA_SECRET_KEY=change-this-to-a-long-random-string
POSTGRES_PASSWORD=change-this-to-a-strong-password
RABBITMQ_PASS=change-this-to-another-password
RABBITMQ_ERLANG_COOKIE=change-this-random-erlang-cookie

# Database
POSTGRES_USER=taiga
POSTGRES_DB=taiga

# RabbitMQ
RABBITMQ_USER=taiga
RABBITMQ_VHOST=taiga

# Email — set to "smtp" for production
EMAIL_BACKEND=console
EMAIL_HOST=smtp.example.com
EMAIL_PORT=587
EMAIL_HOST_USER=[email protected]
EMAIL_HOST_PASSWORD=email-password
EMAIL_DEFAULT_FROM=[email protected]
EMAIL_USE_TLS=True
EMAIL_USE_SSL=False

# Optional
ENABLE_TELEMETRY=False

Generate secure values for the secrets:

sed -i "s/change-this-to-a-long-random-string/$(openssl rand -hex 32)/" .env
sed -i "s/change-this-to-a-strong-password/$(openssl rand -hex 16)/" .env
sed -i "s/change-this-to-another-password/$(openssl rand -hex 16)/" .env
sed -i "s/change-this-random-erlang-cookie/$(openssl rand -hex 24)/" .env

The official docker-compose.yml is included in the repository. It defines 9 services:

Service	Image	Purpose
`taiga-db`	`postgres:12.3`	PostgreSQL database
`taiga-back`	`taigaio/taiga-back:6.9.0`	Django REST API
`taiga-async`	`taigaio/taiga-back:6.9.0`	Celery worker for background tasks
`taiga-async-rabbitmq`	`rabbitmq:3.8-management-alpine`	Message queue for async tasks
`taiga-front`	`taigaio/taiga-front:6.9.0`	Angular frontend SPA
`taiga-events`	`taigaio/taiga-events:6.9.0`	WebSocket server for real-time updates
`taiga-events-rabbitmq`	`rabbitmq:3.8-management-alpine`	Message queue for events
`taiga-protected`	`taigaio/taiga-protected:6.9.0`	Secure file serving
`taiga-gateway`	`nginx:1.19-alpine`	Nginx reverse proxy tying it all together

Start the stack:

./launch-taiga.sh

Or manually:

docker compose up -d

First startup takes 1-2 minutes while the database initializes.

Initial Setup

Create an admin account:

cd ~/taiga
./taiga-manage.sh createsuperuser

Open http://your-server-ip:9000 in your browser
Log in with the superuser credentials you just created
Create your first project — choose between Scrum (sprints, backlogs) or Kanban (board-only)
Invite team members via email or share the registration link

Configuration

Setting	Variable	Description
Domain	`TAIGA_DOMAIN`	Must match exactly how users access Taiga (including port). Taiga generates absolute URLs using this value.
Scheme	`TAIGA_SCHEME`	`http` or `https`. Set to `https` when behind SSL proxy.
WebSockets	`WEBSOCKETS_SCHEME`	`ws` for HTTP, `wss` for HTTPS. Must match `TAIGA_SCHEME`.
Secret key	`TAIGA_SECRET_KEY`	Django secret key. Changing this invalidates all sessions and tokens.
Email	`EMAIL_BACKEND`	Set to `console` (logs only) or `smtp` (sends email). SMTP required for invitations and notifications.
Telemetry	`ENABLE_TELEMETRY`	Anonymous usage stats. Set to `False` to disable.

Important: TAIGA_DOMAIN must NOT include the scheme (no http://). Just the hostname and port: projects.example.com or localhost:9000.

Advanced Configuration (Optional)

HTTPS with Reverse Proxy

When putting Taiga behind a reverse proxy with SSL:

# In .env
TAIGA_SCHEME=https
TAIGA_DOMAIN=projects.example.com
WEBSOCKETS_SCHEME=wss

Remove the port mapping from taiga-gateway in docker-compose.yml and let your reverse proxy forward to port 9000.

OAuth Authentication (GitHub/GitLab)

Taiga supports OAuth login. Add to your .env:

ENABLE_GITHUB_AUTH=True
GITHUB_API_CLIENT_ID=your-client-id
GITHUB_API_CLIENT_SECRET=your-secret

Note: Public registration must be enabled for OAuth to work.

Custom Backend Configuration

For advanced Django settings, mount a custom config file:

# Add to taiga-back service in docker-compose.yml
volumes:
  - ./config.py:/taiga-back/settings/config.py

Reverse Proxy

Taiga exposes port 9000 through its built-in Nginx gateway. Put your external reverse proxy in front of that.

Important: Taiga uses WebSockets for real-time updates. Your reverse proxy must support WebSocket forwarding. Nginx Proxy Manager handles this automatically with the “WebSocket Support” toggle.

For detailed setup: Reverse Proxy Setup

Backup

Back up the database and media volumes:

# Database backup
docker exec taiga-docker-taiga-db-1 pg_dump -U taiga taiga > taiga-backup-$(date +%Y%m%d).sql

# Media backup (user uploads, attachments)
docker run --rm -v taiga-docker_taiga-media-data:/data -v $(pwd):/backup alpine \
  tar czf /backup/taiga-media-$(date +%Y%m%d).tar.gz -C /data .

Back up your .env file separately — it contains all configuration secrets. See Backup Strategy.

Troubleshooting

Taiga frontend shows “Unable to connect”

Symptom: Frontend loads but can’t reach the API. Fix: Verify TAIGA_DOMAIN matches your actual access URL. If you’re accessing via 192.168.1.100:9000, that’s what TAIGA_DOMAIN must be — not localhost:9000. Restart all services after changing.

WebSocket events not working (no real-time updates)

Symptom: Changes by other users don’t appear until page refresh. Fix: Check that WEBSOCKETS_SCHEME matches your setup (ws for HTTP, wss for HTTPS). If behind a reverse proxy, ensure WebSocket forwarding is enabled.

Email notifications not sending

Symptom: Invitations and notifications don’t arrive. Fix: Verify EMAIL_BACKEND=smtp (not console) and that your SMTP credentials are correct. You cannot use both EMAIL_USE_TLS=True and EMAIL_USE_SSL=True simultaneously — pick one.

RabbitMQ connection errors in logs

Symptom: Backend logs show Connection refused for RabbitMQ. Fix: RabbitMQ takes 10-20 seconds to start. The backend retries automatically. If persistent, check that RABBITMQ_PASS and RABBITMQ_ERLANG_COOKIE match between your .env and the running containers. Recreate the RabbitMQ volumes if credentials were changed after initial setup.

Database migration errors on upgrade

Symptom: Backend crashes after pulling a new image version. Fix: Migrations run automatically on startup. If they fail, check the backend logs: docker compose logs taiga-back. Common cause: insufficient disk space or corrupted migration state. Back up your database before any upgrade.

Resource Requirements

Resource	Requirement
RAM	~1.5 GB idle (9 containers combined), ~2.5 GB under load
CPU	Medium — Django backend is the heaviest component
Disk	~2 GB for application, plus user uploads and database growth

Taiga is heavier than single-container tools like Planka or Kanboard due to its microservices architecture (9 containers). The trade-off is a much richer feature set.

Verdict

Taiga is the best self-hosted option for agile teams that follow Scrum or Kanban methodologies. Sprint planning, backlogs, user stories, epics, burndown charts — it has the full agile toolkit with a UI that’s cleaner than Jira. The 9-container architecture is complex but the official Docker setup handles orchestration well.

If you need Gantt charts and traditional project management, OpenProject is a better fit. If you just need a simple Kanban board without Scrum ceremonies, Planka or Plane are lighter alternatives. Taiga sits in the middle — full agile features without the enterprise complexity of OpenProject.

Frequently Asked Questions

Is Taiga free for self-hosting?

Yes. Taiga is licensed under MPL-2.0 (backend) and AGPL-3.0 (frontend) with no usage restrictions. All features — Scrum, Kanban, epics, wiki, and the API — are available in the self-hosted version. There is no paid tier for self-hosted deployments. The company offers a paid cloud-hosted version with support.

How does Taiga compare to Jira?

Taiga covers the core agile workflows — sprint planning, backlogs, user stories, epics, burndown charts, and Kanban boards — with a cleaner UI than Jira. Jira has deeper integrations (Confluence, Bitbucket), more advanced reporting, and enterprise features like custom workflows. For small-to-medium agile teams, Taiga is a strong Jira replacement. For enterprise environments with complex approval processes, Jira or OpenProject are better fits.

Why does Taiga need 9 containers?

Taiga uses a microservices architecture: separate containers for the Django API, Angular frontend, WebSocket server, background scheduler, file server, two RabbitMQ instances, PostgreSQL, and an Nginx gateway. This adds complexity but allows each component to scale independently. The official Docker setup handles orchestration, so you don’t need to configure inter-service communication manually.

Can I use Taiga for Kanban without Scrum?

Yes. When creating a project, choose the Kanban template instead of Scrum. This gives you a board view without sprints, backlogs, or story points. You can customize columns, set WIP limits, and use swimlanes. If you only need a simple Kanban board, Planka or Plane are lighter alternatives.

Yes. Taiga supports GitHub and GitLab OAuth out of the box via environment variables. For SAML, LDAP, or other SSO providers, you need to configure the Django backend directly using a custom config file mounted into the container. Public registration must be enabled for OAuth to work.

Can I import data from Jira or Trello into Taiga?

Yes. Taiga has built-in importers for Jira, Trello, GitHub, and Asana. Access them from the project creation screen — select “Import” and follow the wizard. The importers transfer projects, user stories, tasks, and comments. Some metadata (custom fields, advanced workflows) may not transfer perfectly and needs manual adjustment.