Taiga: Agile Project Management

Introduction

Taiga is a beautiful, open-source project management platform designed specifically for agile development teams. Built for both Scrum and Kanban methodologies, Taiga offers an intuitive interface with powerful features including user stories, sprints, epics, issues, and detailed analytics. With over 10,000 GitHub stars and used by companies worldwide, Taiga has established itself as the premier self-hosted agile management solution.

Why Choose Taiga?

Built for Agile Teams

Taiga is designed from the ground up for agile development. It understands sprints, user stories, epics, and velocity tracking natively, without forcing you to configure complex workflows.

Beautiful Design

Unlike enterprise tools with cluttered interfaces, Taiga provides a clean, modern design that makes project management enjoyable. The interface is colorful, intuitive, and focuses on usability.

Flexible Methodology Support

Whether your team uses Scrum, Kanban, or a hybrid approach, Taiga adapts to your workflow. Switch between methodologies per project or combine them as needed.

Complete Privacy

Your development roadmap, sprint planning, and project data remain on your infrastructure. Perfect for startups, agencies, and teams working on confidential projects.

Zero Licensing Costs

Commercial agile tools like Jira cost $7.75+/user/month. For a 20-person development team, that’s $1,860+ annually. Taiga is completely free with unlimited users and projects.

Key Features:

Multiple projects and workspaces
Scrum board with sprints
Kanban board for continuous flow
User stories with tasks and acceptance criteria
Epic management for large features
Issues and bug tracking
Wiki pages for documentation
Timeline and roadmap views
Burndown and velocity charts
Custom fields and attributes
Video conferencing integration
GitHub, GitLab, Bitbucket integration
Import from Jira, Trello, Asana
RESTful API
Webhooks for automation
Custom themes and branding
Multi-language support

Understanding the Architecture

Taiga consists of three main components:

Internet/Local Network
        │
        ▼
┌───────────────┐
│ Reverse Proxy │ (Nginx, Caddy, Traefik)
│  HTTPS/SSL    │
└───────┬───────┘
        │
        ▼
┌───────────────┐
│  Taiga Front  │ (Angular Frontend - Port 9000)
│  (Web UI)     │
└───────┬───────┘
        │
    ┌───┴────┬──────────┐
    │        │          │
    ▼        ▼          ▼
┌──────┐ ┌──────┐ ┌────────┐
│Backend│ │Events│ │Protected│
│ API  │ │Server│ │ Static │
│:8000 │ │:8888 │ │ Files  │
└──┬───┘ └──────┘ └────────┘
   │
   ├──────┬────────┐
   │      │        │
   ▼      ▼        ▼
┌────┐ ┌─────┐ ┌──────┐
│Post│ │Rabbit│ │ Media│
│gres│ │ MQ  │ │Storage│
└────┘ └─────┘ └──────┘

Prerequisites

Hardware Requirements

Minimum Configuration:

RAM: 2GB (suitable for small teams up to 10 users)
CPU: 2 cores
Storage: 20GB SSD
Network: Standard homelab network

Recommended Configuration:

RAM: 4GB (better for 25+ users)
CPU: 4 cores
Storage: 50GB+ SSD
Network: Gigabit ethernet

Production Environment (50+ users):

RAM: 8GB+
CPU: 8+ cores
Storage: 100GB+ SSD
Dedicated database server recommended

Software Requirements

Docker Engine v24+ with docker-compose
Linux (Ubuntu 22.04/24.04 LTS recommended)
Domain name (optional, for HTTPS)
SMTP server (optional, for email notifications)

Pre-Deployment Checklist

# Verify Docker installation
docker --version
docker compose version

# Check available resources
free -h
df -h

# Test network connectivity
ping -c 3 google.com

Installation and Deployment

Step 1: Create Project Directory

# Create directory structure
mkdir -p ~/taiga/{media,static}
cd ~/taiga

# Set permissions
chmod 755 ~/taiga

Step 2: Generate Secrets

# Generate secure secrets
export POSTGRES_PASSWORD=$(openssl rand -base64 24)
export SECRET_KEY=$(openssl rand -hex 32)
export RABBITMQ_PASSWORD=$(openssl rand -base64 24)

echo "Save these credentials:"
echo "POSTGRES_PASSWORD: $POSTGRES_PASSWORD"
echo "SECRET_KEY: $SECRET_KEY"
echo "RABBITMQ_PASSWORD: $RABBITMQ_PASSWORD"

Step 3: Create Environment Configuration

Create .env file:

cat > .env <<'EOF'
# Taiga Configuration
TAIGA_SCHEME=http
TAIGA_DOMAIN=YOUR-SERVER-IP:9000
TAIGA_URL=http://YOUR-SERVER-IP:9000
SUBPATH=""

# Backend Configuration
TAIGA_SECRET_KEY=REPLACE-WITH-YOUR-SECRET-KEY
TAIGA_SITES_SCHEME=http
TAIGA_SITES_DOMAIN=YOUR-SERVER-IP:9000

# Database Configuration
POSTGRES_USER=taiga
POSTGRES_PASSWORD=REPLACE-WITH-YOUR-POSTGRES-PASSWORD
POSTGRES_DB=taiga
POSTGRES_HOST=taiga-db

# RabbitMQ Configuration
RABBITMQ_USER=taiga
RABBITMQ_PASS=REPLACE-WITH-YOUR-RABBITMQ-PASSWORD
RABBITMQ_VHOST=taiga
RABBITMQ_ERLANG_COOKIE=secret-erlang-cookie

# Email Configuration (Optional)
# EMAIL_BACKEND=django.core.mail.backends.smtp.EmailBackend
# [email protected]
# EMAIL_HOST=smtp.gmail.com
# EMAIL_PORT=587
# [email protected]
# EMAIL_HOST_PASSWORD=your-app-password
# EMAIL_USE_TLS=True
# EMAIL_USE_SSL=False

# Registration Settings
PUBLIC_REGISTER_ENABLED=True

# GitHub Integration (Optional)
# ENABLE_GITHUB_AUTH=True
# GITHUB_CLIENT_ID=
# GITHUB_CLIENT_SECRET=

# GitLab Integration (Optional)
# ENABLE_GITLAB_AUTH=True
# GITLAB_CLIENT_ID=
# GITLAB_CLIENT_SECRET=
# GITLAB_URL=https://gitlab.com

# Advanced Settings
CELERY_ENABLED=True
ENABLE_TELEMETRY=False
EOF

# Replace placeholders with actual values
sed -i "s/REPLACE-WITH-YOUR-SECRET-KEY/${SECRET_KEY}/" .env
sed -i "s/REPLACE-WITH-YOUR-POSTGRES-PASSWORD/${POSTGRES_PASSWORD}/" .env
sed -i "s/REPLACE-WITH-YOUR-RABBITMQ-PASSWORD/${RABBITMQ_PASSWORD}/" .env
sed -i "s/YOUR-SERVER-IP/$(hostname -I | awk '{print $1}')/" .env

# Secure the file
chmod 600 .env

Step 4: Create Docker Compose Configuration

Create docker-compose.yml:

version: "3.8"

x-environment:
  &default-environment
  POSTGRES_DB: ${POSTGRES_DB}
  POSTGRES_USER: ${POSTGRES_USER}
  POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
  POSTGRES_HOST: ${POSTGRES_HOST}
  TAIGA_SECRET_KEY: ${TAIGA_SECRET_KEY}
  TAIGA_SITES_SCHEME: ${TAIGA_SITES_SCHEME}
  TAIGA_SITES_DOMAIN: ${TAIGA_SITES_DOMAIN}
  TAIGA_SUBPATH: ${SUBPATH}
  RABBITMQ_USER: ${RABBITMQ_USER}
  RABBITMQ_PASS: ${RABBITMQ_PASS}
  RABBITMQ_VHOST: ${RABBITMQ_VHOST}
  PUBLIC_REGISTER_ENABLED: ${PUBLIC_REGISTER_ENABLED}
  CELERY_ENABLED: ${CELERY_ENABLED}
  ENABLE_TELEMETRY: ${ENABLE_TELEMETRY}

services:
  # PostgreSQL Database
  taiga-db:
    image: postgres:14-alpine
    container_name: taiga-db
    restart: unless-stopped
    environment:
      POSTGRES_DB: ${POSTGRES_DB}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    volumes:
      - postgres-data:/var/lib/postgresql/data
    networks:
      - taiga-network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U taiga"]
      interval: 10s
      timeout: 5s
      retries: 5

  # RabbitMQ Message Queue
  taiga-rabbitmq:
    image: rabbitmq:3.11-management-alpine
    container_name: taiga-rabbitmq
    restart: unless-stopped
    environment:
      RABBITMQ_DEFAULT_USER: ${RABBITMQ_USER}
      RABBITMQ_DEFAULT_PASS: ${RABBITMQ_PASS}
      RABBITMQ_DEFAULT_VHOST: ${RABBITMQ_VHOST}
      RABBITMQ_ERLANG_COOKIE: ${RABBITMQ_ERLANG_COOKIE}
    volumes:
      - rabbitmq-data:/var/lib/rabbitmq
    networks:
      - taiga-network
    healthcheck:
      test: ["CMD", "rabbitmq-diagnostics", "ping"]
      interval: 30s
      timeout: 10s
      retries: 5

  # Taiga Backend API
  taiga-backend:
    image: taigaio/taiga-back:latest
    container_name: taiga-backend
    restart: unless-stopped
    depends_on:
      taiga-db:
        condition: service_healthy
      taiga-rabbitmq:
        condition: service_healthy
    environment:
      <<: *default-environment
    volumes:
      - taiga-media:/taiga-back/media
      - taiga-static:/taiga-back/static
    networks:
      - taiga-network

  # Taiga Asynchronous Tasks
  taiga-async:
    image: taigaio/taiga-back:latest
    container_name: taiga-async
    restart: unless-stopped
    depends_on:
      - taiga-backend
    environment:
      <<: *default-environment
    command: ["/taiga-back/docker/async_entrypoint.sh"]
    volumes:
      - taiga-media:/taiga-back/media
    networks:
      - taiga-network

  # Taiga Frontend
  taiga-frontend:
    image: taigaio/taiga-front:latest
    container_name: taiga-frontend
    restart: unless-stopped
    depends_on:
      - taiga-backend
    environment:
      TAIGA_URL: ${TAIGA_URL}
      TAIGA_WEBSOCKETS_URL: ws://YOUR-SERVER-IP:9000
      TAIGA_SUBPATH: ${SUBPATH}
      PUBLIC_REGISTER_ENABLED: ${PUBLIC_REGISTER_ENABLED}
    networks:
      - taiga-network

  # Taiga Events (WebSockets)
  taiga-events:
    image: taigaio/taiga-events:latest
    container_name: taiga-events
    restart: unless-stopped
    depends_on:
      - taiga-rabbitmq
    environment:
      RABBITMQ_URL: amqp://${RABBITMQ_USER}:${RABBITMQ_PASS}@taiga-rabbitmq:5672/${RABBITMQ_VHOST}
      TAIGA_SECRET_KEY: ${TAIGA_SECRET_KEY}
    networks:
      - taiga-network

  # Taiga Protected Files Server
  taiga-protected:
    image: taigaio/taiga-protected:latest
    container_name: taiga-protected
    restart: unless-stopped
    environment:
      MAX_AGE: 360
      SECRET_KEY: ${TAIGA_SECRET_KEY}
    volumes:
      - taiga-media:/taiga/media:ro
    networks:
      - taiga-network

  # Nginx Gateway
  taiga-gateway:
    image: nginx:1.25-alpine
    container_name: taiga-gateway
    restart: unless-stopped
    depends_on:
      - taiga-frontend
      - taiga-backend
      - taiga-events
    ports:
      - "9000:80"
    volumes:
      - ./nginx.conf:/etc/nginx/conf.d/default.conf:ro
      - taiga-static:/taiga/static:ro
      - taiga-media:/taiga/media:ro
    networks:
      - taiga-network

volumes:
  postgres-data:
  rabbitmq-data:
  taiga-media:
  taiga-static:

networks:
  taiga-network:
    driver: bridge

Step 5: Create Nginx Configuration

Create nginx.conf:

server {
    listen 80 default_server;
    server_name _;

    large_client_header_buffers 4 32k;
    client_max_body_size 50M;
    charset utf-8;

    # Frontend
    location / {
        proxy_pass http://taiga-frontend:80;
        proxy_set_header Host $http_host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Scheme $scheme;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_redirect off;
    }

    # Backend API
    location /api/ {
        proxy_pass http://taiga-backend:8000/api/;
        proxy_set_header Host $http_host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Scheme $scheme;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_redirect off;
    }

    # Backend Admin
    location /admin/ {
        proxy_pass http://taiga-backend:8000/admin/;
        proxy_set_header Host $http_host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Scheme $scheme;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_redirect off;
    }

    # Static files
    location /static/ {
        alias /taiga/static/;
    }

    # Media files
    location /_protected/ {
        internal;
        alias /taiga/media/;
        add_header Content-disposition "attachment";
    }

    # Unprotected media
    location /media/exports/ {
        alias /taiga/media/exports/;
        add_header Content-disposition "attachment";
    }

    location /media/ {
        proxy_pass http://taiga-protected:8003/;
        proxy_set_header Host $http_host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Scheme $scheme;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_redirect off;
    }

    # Events (WebSockets)
    location /events {
        proxy_pass http://taiga-events:8888/events;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_connect_timeout 7d;
        proxy_send_timeout 7d;
        proxy_read_timeout 7d;
    }
}

Step 6: Deploy Taiga

# Update WebSocket URL in .env
sed -i "s/YOUR-SERVER-IP/$(hostname -I | awk '{print $1}')/" docker-compose.yml

# Pull images
docker compose pull

# Start services
docker compose up -d

# Monitor startup (takes 2-3 minutes)
docker compose logs -f

# Wait for "Listening at: http://0.0.0.0:8000"
# Press Ctrl+C to exit

# Verify all containers are running
docker compose ps

Step 7: Create Initial Admin User

# Create superuser account
docker compose exec taiga-backend python manage.py createsuperuser

# Follow prompts:
# Username: admin
# Email: [email protected]
# Password: (enter secure password)
# Password (again): (confirm)

Step 8: Access Taiga

Navigate to http://YOUR-SERVER-IP:9000 in your browser.

Login with your admin credentials:

Username: admin
Password: (password you just created)

Initial Setup and Configuration

Create Your First Project

1. Click "+ New Project" in sidebar
2. Select template:
   - Scrum (for sprint-based development)
   - Kanban (for continuous flow)
   - Issues (simple issue tracking)
3. Project Details:
   - Name: "Website Redesign"
   - Description: "Complete redesign of company website"
   - Privacy: Private (only team members)
4. Click "Create Project"

Configure Project Settings

General Settings:

Settings → Project Details:
├─ Project Name
├─ Description
├─ Tags: web, design, frontend
├─ Looking for people: Enable/Disable
└─ Video Conference URL: meet.yourdomain.com/PROJECT-NAME

Modules:

Settings → Modules:
├─ Epics: Enabled
├─ User Stories: Enabled
├─ Tasks: Enabled
├─ Issues: Enabled
├─ Wiki: Enabled
└─ Meetups: Enabled

Custom Attributes:

Settings → Attributes → User Stories:
Click "Add attribute"
- Name: "Browser Compatibility"
- Type: Multiple select
- Options: Chrome, Firefox, Safari, Edge

Settings → Attributes → Issues:
- Name: "Severity"
- Type: Dropdown
- Options: Critical, High, Medium, Low

Customize Workflow

User Story Status:

Settings → Attributes → Statuses (User Stories):
Default statuses:
├─ New (initial)
├─ Ready
├─ In Progress
├─ Ready for Test
└─ Done (closed)

Customize:
- Add "Code Review" status
- Add "Design Review" status
- Reorder as needed

Issue Types:

Settings → Attributes → Types (Issues):
Default types:
├─ Bug
├─ Question
└─ Enhancement

Add custom types:
- Security
- Performance
- Documentation

Set Up Tags

Settings → Attributes → Tags:
Create common tags:
- frontend
- backend
- database
- api
- urgent
- needs-discussion

User Management

Invite Team Members

1. Click Settings → Members
2. Click "Add Member"
3. Enter email address
4. Select role:
   - Admin: Full project control
   - Member: Create and edit items
   - Viewer: Read-only access
5. Click "Add"
6. User receives invitation email

Configure Member Roles

Role Permissions:

Admin:
- Modify project settings
- Manage members
- Delete project
- All member permissions

Member:
- Create user stories, tasks, issues
- Edit assigned items
- Comment on items
- View project

Viewer:
- View user stories, tasks, issues
- View wiki
- Cannot create or edit

Create Teams

Organize members by function:

Common team structure:
├─ Frontend Team
├─ Backend Team
├─ Design Team
├─ QA Team
└─ DevOps Team

Assign team members to appropriate teams
Use teams for filtering and workload distribution

Working with Agile Features

Create Epics

1. Navigate to project
2. Click "Epics" in sidebar
3. Click "+ Create Epic"
4. Fill details:
   - Subject: "User Authentication System"
   - Description: Complete auth implementation
   - Assigned to: Team lead
   - Tags: backend, security
   - Color: Choose color for visual identification
5. Click "Create"

Create User Stories

1. Click "Backlog" in sidebar
2. Click "+ Create User Story"
3. Fill details:
   - Subject: "As a user, I want to login with email"
   - Description: Detailed acceptance criteria
   - Epic: User Authentication System
   - Assigned to: Developer
   - Status: New
   - Points: 5 (story points)
   - Sprint: Assign to current sprint
4. Add custom attributes:
   - Browser Compatibility: All browsers
5. Click "Create"

Plan Sprints

1. Click "Backlog"
2. Click "+ New Sprint"
3. Configure sprint:
   - Name: "Sprint 1"
   - Start Date: 2025-01-20
   - End Date: 2025-02-03
   - Estimated Points: 40
4. Drag user stories from backlog to sprint
5. Click "Activate Sprint"
6. Monitor progress in Taskboard

Use Kanban Board

1. Click "Kanban" in sidebar
2. View columns matching your workflow
3. Create cards:
   - Click "+" in any column
   - Or drag from backlog
4. Move cards by dragging between columns
5. Customize:
   - Add/remove columns
   - Set WIP limits
   - Color coding
   - Filters by assignee, tags, etc.

Track Issues

1. Click "Issues" in sidebar
2. Click "+ Create Issue"
3. Fill details:
   - Subject: "Login button not responsive on mobile"
   - Type: Bug
   - Severity: High
   - Priority: High
   - Assigned to: Developer
   - Due date: 2025-01-25
4. Add attachments:
   - Screenshots
   - Error logs
   - Related files
5. Click "Create"

Use Wiki

1. Click "Wiki" in sidebar
2. Click "+ Create Page"
3. Page options:
   - Title: "API Documentation"
   - Slug: api-documentation
4. Write content using Markdown:
   - Headers, lists, code blocks
   - Link to user stories
   - Embed images
5. Save
6. Create links between pages

Backup Procedures

What to Backup

Component	Priority	Contains
PostgreSQL	Critical	Projects, user stories, tasks, users
Media Files	Important	Attachments, avatars, project images
.env File	Critical	Configuration and secrets
RabbitMQ	Optional	Message queue, can rebuild

Automated Backup Script

Create ~/taiga/backup.sh:

#!/bin/bash

# Configuration
BACKUP_DIR="/mnt/backups/taiga"
DATE=$(date +%Y%m%d_%H%M%S)
RETENTION_DAYS=30

# Load environment
source ~/taiga/.env

# Create backup directory
mkdir -p "$BACKUP_DIR"

echo "Starting Taiga backup at $(date)"

# Backup PostgreSQL
docker exec taiga-db pg_dump -U ${POSTGRES_USER} ${POSTGRES_DB} |   gzip > "$BACKUP_DIR/taiga-db-${DATE}.sql.gz"

if [ $? -eq 0 ]; then
    echo "Database backed up successfully"
else
    echo "Database backup FAILED" >&2
    exit 1
fi

# Backup media files
docker run --rm   -v taiga_taiga-media:/source:ro   -v "$BACKUP_DIR":/backup   alpine tar czf /backup/taiga-media-${DATE}.tar.gz -C /source .

echo "Media files backed up"

# Backup environment file
cp ~/taiga/.env "$BACKUP_DIR/env-${DATE}.txt"

# Create manifest
cat > "$BACKUP_DIR/manifest-${DATE}.txt" <<EOF
Taiga Backup
Date: $(date)
Database: taiga-db-${DATE}.sql.gz
Media: taiga-media-${DATE}.tar.gz
Config: env-${DATE}.txt
EOF

# Clean old backups
find "$BACKUP_DIR" -name "*.gz" -mtime +$RETENTION_DAYS -delete
find "$BACKUP_DIR" -name "*.txt" -mtime +$RETENTION_DAYS -delete

echo "Backup completed at $(date)"

Schedule backups:

chmod +x ~/taiga/backup.sh

# Add to crontab
crontab -e
# Add: 0 3 * * * /home/user/taiga/backup.sh >> /var/log/taiga-backup.log 2>&1

Restore from Backup

# Stop Taiga
cd ~/taiga
docker compose down

# Restore database
gunzip < /mnt/backups/taiga/taiga-db-YYYYMMDD.sql.gz |   docker exec -i taiga-db psql -U ${POSTGRES_USER} ${POSTGRES_DB}

# Restore media
docker run --rm   -v taiga_taiga-media:/dest   -v /mnt/backups/taiga:/backup   alpine tar xzf /backup/taiga-media-YYYYMMDD.tar.gz -C /dest

# Restore config
cp /mnt/backups/taiga/env-YYYYMMDD.txt .env

# Start Taiga
docker compose up -d

# Verify
docker compose logs -f

Troubleshooting

Issue: Can’t Access Web Interface

# Check all containers are running
docker compose ps

# Check gateway logs
docker compose logs taiga-gateway

# Verify port is not in use
sudo netstat -tlnp | grep :9000

# Restart gateway
docker compose restart taiga-gateway

Issue: WebSockets Not Working (Real-time Updates)

# Verify events service
docker compose logs taiga-events

# Check RabbitMQ connection
docker exec taiga-rabbitmq rabbitmqctl status

# Update WebSocket URL in browser DevTools
# Should connect to: ws://YOUR-IP:9000/events

# Restart events service
docker compose restart taiga-events

Issue: Email Notifications Not Sending

# Verify email settings in .env
cat .env | grep EMAIL

# Test SMTP from backend
docker exec -it taiga-backend python manage.py shell

# In Python shell:
from django.core.mail import send_mail
send_mail('Test', 'Test message', '[email protected]', ['[email protected]'])

# Check logs
docker compose logs taiga-backend | grep -i mail

Issue: File Upload Failing

# Check media volume
docker volume inspect taiga_taiga-media

# Verify permissions
docker exec taiga-backend ls -la /taiga-back/media

# Check client_max_body_size in nginx.conf
# Should be 50M or higher

# Restart backend and gateway
docker compose restart taiga-backend taiga-gateway

Issue: Slow Performance

# Check resource usage
docker stats

# Optimize PostgreSQL
docker exec taiga-db psql -U taiga -c "VACUUM ANALYZE;"

# Clear RabbitMQ queues
docker exec taiga-rabbitmq rabbitmqctl purge_queue taiga

# Restart all services
docker compose restart

Advanced Configuration

Enable GitHub Integration

# Create GitHub OAuth App:
# https://github.com/settings/developers
# Homepage: http://YOUR-SERVER-IP:9000
# Callback: http://YOUR-SERVER-IP:9000/login

# Get Client ID and Secret

# Update .env:
ENABLE_GITHUB_AUTH=True
GITHUB_CLIENT_ID=your_client_id
GITHUB_CLIENT_SECRET=your_client_secret

# Restart
docker compose restart taiga-backend taiga-frontend

Import from Jira

1. Login as admin
2. Settings → Import/Export
3. Select "Jira"
4. Enter Jira credentials
5. Select project to import
6. Map fields and statuses
7. Click "Import"
8. Wait for completion

Set Up Webhooks

1. Project Settings → Integrations
2. Click "+ Add Webhook"
3. Configure:
   - Name: "Slack Notification"
   - URL: https://hooks.slack.com/services/YOUR/WEBHOOK
   - Secret Key: (optional)
   - Events: Task created, Task updated, Sprint closed
4. Save
5. Test webhook

Custom Branding

1. Admin Panel → Customization
2. Upload logo (400x80px recommended)
3. Set brand colors:
   - Primary color
   - Accent color
   - Background color
4. Custom CSS (optional)
5. Save changes

Conclusion

Taiga provides a beautiful, powerful agile project management experience without vendor lock-in or per-user costs. With native support for Scrum and Kanban, comprehensive features, and complete self-hosting, it’s the ideal solution for development teams.

What You’ve Accomplished:

Deployed complete Taiga platform with all services
Configured PostgreSQL, RabbitMQ, and WebSockets
Set up projects with custom workflows
Implemented automated backups
Configured user management and roles
Enabled real-time collaboration

Next Steps:

Import existing projects from Jira or Trello
Set up GitHub/GitLab integration
Configure email notifications
Create project templates
Set up custom workflows per project
Train team on agile best practices

Start managing your agile projects with the freedom and control of self-hosting!