Leantime: Self-Hosted Project Management for People Who Hate Jira

Every team needs some way to track work. But somehow the project management tool always becomes a project in itself. Jira requires a certified admin to configure. Monday.com costs $10/seat/month and still doesn't do what you need. ClickUp has so many features that finding the right view takes longer than doing the actual work. You wanted to track tasks, not learn enterprise software.

Photo by Sammyayot254 on Unsplash

Leantime is an open-source, self-hosted project management tool built specifically for people who aren't professional project managers. It gives you kanban boards, timesheets, goals and OKRs, Gantt charts, and a clean modern UI — without the soul-crushing complexity of enterprise tools. It's the project management equivalent of choosing a sharp knife over a Swiss Army knife.

Why Leantime

Most open-source project management tools fall into one of two categories: either they're glorified to-do lists that break down once you need timelines and reporting, or they're Jira clones that replicate all of Jira's complexity without any of its ecosystem. Leantime occupies the middle ground.

It was designed around the idea that most people managing projects aren't PMPs with Agile certifications. They're developers, designers, small business owners, and freelancers who need to see what's happening, what's overdue, and what's next — without configuring a workflow engine first.

Key things that set Leantime apart:

• Opinionated defaults — Sensible out-of-the-box configuration. You create a project, add tasks, and start working. No sprint setup wizard. No issue type taxonomy.
• Built-in strategy tools — Goals, OKRs, and milestones aren't plugins. They're first-class features connected to your tasks.
• Time tracking included — Log time directly on tasks. No Toggl integration required.
• Research and ideation boards — Lean canvas and idea boards for the planning stage, before work becomes tasks.
• Clean UI — It looks like a modern SaaS product, not a 2010-era PHP app.

Core Features

Task management

Tasks support statuses, priorities, due dates, assignees, tags, subtasks, comments, and file attachments. The basics are all here, and they work without ceremony.

Multiple views

Switch between views depending on how you think:

• Kanban board — Drag-and-drop cards across status columns
• List view — Dense table view for scanning lots of tasks quickly
• Gantt chart — Timeline view with dependencies for deadline-driven work
• Calendar view — See tasks by due date

Time tracking and timesheets

Every task has a built-in timer. Start it when you begin work, stop it when you're done. Leantime aggregates this into timesheets you can export — useful for freelancers billing hourly or teams tracking capacity.

Goals and OKRs

Define company or team goals, attach key results with measurable targets, and link tasks to those goals. This is where Leantime goes beyond simple task management. You can see whether the work your team is doing actually connects to what matters.

Milestones

Group tasks into milestones with target dates. The Gantt chart visualizes milestone progress, making it easy to spot when a deadline is at risk.

Reports and dashboards

Project dashboards show task completion rates, overdue items, time logged, and milestone progress at a glance. Nothing groundbreaking, but enough to answer "are we on track?" without running a custom query.

Installation with Docker Compose

Leantime is a PHP application backed by MySQL (or MariaDB). The official Docker image bundles everything except the database.

Basic setup

# docker-compose.yml
services:
  leantime:
    image: leantime/leantime:latest
    environment:
      LEAN_DB_HOST: db
      LEAN_DB_USER: leantime
      LEAN_DB_PASSWORD: changeme
      LEAN_DB_DATABASE: leantime
      LEAN_SITENAME: "My Projects"
      LEAN_LANGUAGE: en-US
      LEAN_DEFAULT_TIMEZONE: America/Los_Angeles
      LEAN_SESSION_EXPIRATION: 28800
    ports:
      - "8080:80"
    depends_on:
      - db
    restart: unless-stopped

  db:
    image: mariadb:11
    environment:
      MYSQL_ROOT_PASSWORD: rootchangeme
      MYSQL_DATABASE: leantime
      MYSQL_USER: leantime
      MYSQL_PASSWORD: changeme
    volumes:
      - ./db_data:/var/lib/mysql
    restart: unless-stopped

docker compose up -d

Visit http://your-server:8080 and complete the setup wizard. You'll create your admin account and first project.

Production setup with S3 file storage

For production, you probably want file uploads stored in S3-compatible storage rather than the container filesystem:

services:
  leantime:
    image: leantime/leantime:latest
    environment:
      LEAN_DB_HOST: db
      LEAN_DB_USER: leantime
      LEAN_DB_PASSWORD: changeme
      LEAN_DB_DATABASE: leantime
      LEAN_SITENAME: "Acme Projects"
      LEAN_LANGUAGE: en-US
      LEAN_DEFAULT_TIMEZONE: America/Los_Angeles
      LEAN_SESSION_EXPIRATION: 28800
      LEAN_S3_KEY: your-access-key
      LEAN_S3_SECRET: your-secret-key
      LEAN_S3_BUCKET: leantime-files
      LEAN_S3_REGION: us-east-1
      LEAN_S3_END_POINT: https://s3.example.com
      LEAN_S3_USE_PATH_STYLE_ENDPOINT: "true"
      LEAN_EMAIL_RETURN: [email protected]
      LEAN_EMAIL_USE_SMTP: "true"
      LEAN_EMAIL_SMTP_HOSTS: smtp.example.com
      LEAN_EMAIL_SMTP_PORT: 587
      LEAN_EMAIL_SMTP_USERNAME: your-smtp-user
      LEAN_EMAIL_SMTP_PASSWORD: your-smtp-pass
      LEAN_EMAIL_SMTP_AUTO_TLS: "true"
    ports:
      - "8080:80"
    depends_on:
      - db
    restart: unless-stopped

  db:
    image: mariadb:11
    environment:
      MYSQL_ROOT_PASSWORD: rootchangeme
      MYSQL_DATABASE: leantime
      MYSQL_USER: leantime
      MYSQL_PASSWORD: changeme
    volumes:
      - ./db_data:/var/lib/mysql
    restart: unless-stopped

The S3 configuration works with MinIO, Wasabi, Backblaze B2, or any S3-compatible provider. If you're already running MinIO in your homelab, point Leantime at it and your file attachments are automatically backed up with the rest of your object storage.

Configuration

Leantime is configured entirely through environment variables. No config file to mount. Here are the ones worth setting:

SMTP is worth configuring even for small teams. Leantime sends email notifications when tasks are assigned, commented on, or approaching their due date. Without SMTP, users have to check the app manually to see what changed.

Reverse Proxy Configuration

Caddy

projects.example.com {
    reverse_proxy leantime:80
}

Nginx

server {
    listen 443 ssl http2;
    server_name projects.example.com;

    ssl_certificate /etc/letsencrypt/live/projects.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/projects.example.com/privkey.pem;

    client_max_body_size 50M;

    location / {
        proxy_pass http://leantime:80;
        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 $scheme;
    }
}

Note the client_max_body_size directive. Leantime supports file attachments on tasks, and the default Nginx limit of 1 MB will block most uploads. Set it to 50M or higher depending on your needs.

Comparison: Leantime vs Alternatives

When to choose Leantime

Pick Leantime when you need actual project management — timesheets, goals, milestones, Gantt charts — but don't want Jira-level complexity. It's ideal for small teams, freelancers, or anyone who needs to track hours alongside tasks.

When to choose Vikunja

Pick Vikunja when you need a personal task manager or a lightweight team to-do list. If your workflow is closer to Todoist than Jira, Vikunja is simpler and lighter. The CalDAV support is also a significant advantage if you want tasks syncing to your phone's native reminders app.

When to choose Plane

Pick Plane when your team thinks in terms of GitHub-style issues and sprints. Plane is closer to Linear or Jira — it's built for software development teams who want issue tracking with cycles and modules.

When to choose Taiga

Pick Taiga when your team does formal Scrum with sprints, story points, and burndown charts. Taiga is the most opinionated about Agile methodology.

Hardware Requirements

Leantime is modest in its resource needs:

The PHP application itself uses around 128-256 MB of RAM. MariaDB adds another 128-256 MB. Total footprint for a small deployment is well under 1 GB, which means it runs comfortably on a Raspberry Pi 4 or a $5 VPS.

Storage is dominated by file attachments. If your team uploads screenshots and documents to tasks, plan for that growth. Using S3-compatible storage offloads this from your local disk.

Backup and Data Management

Database backup

The MySQL/MariaDB database contains all your project data, task history, user accounts, and configuration:

docker exec leantime-db-1 mariadb-dump -u leantime -pchangeme leantime > leantime-backup-$(date +%F).sql

File attachments

If you're using local storage (the default), back up the container's upload directory:

docker cp leantime-leantime-1:/var/www/html/userfiles ./userfiles-backup-$(date +%F)

If you're using S3 storage, your files are already on a separate system. Just make sure your S3 bucket has versioning or its own backup policy.

Restore

# Restore database
docker exec -i leantime-db-1 mariadb -u leantime -pchangeme leantime < leantime-backup-2026-02-15.sql

# Restore files (local storage)
docker cp ./userfiles-backup-2026-02-15/. leantime-leantime-1:/var/www/html/userfiles

Automated backup script

#!/bin/bash
BACKUP_DIR="/backups/leantime"
DATE=$(date +%F)

mkdir -p "$BACKUP_DIR"

# Dump database
docker exec leantime-db-1 mariadb-dump -u leantime -pchangeme leantime \
  | gzip > "$BACKUP_DIR/db-$DATE.sql.gz"

# Copy uploads (skip if using S3)
docker cp leantime-leantime-1:/var/www/html/userfiles "$BACKUP_DIR/userfiles-$DATE"

# Prune backups older than 30 days
find "$BACKUP_DIR" -type f -mtime +30 -delete
find "$BACKUP_DIR" -type d -empty -delete

Plugins and Integrations

Leantime has a plugin system for extending functionality. The plugin marketplace is still growing, but the built-in features cover most needs. Notable integrations:

• Slack and Microsoft Teams — Notifications when tasks change
• Calendars — iCal feed export for subscribing in your calendar app
• Webhooks — Trigger external actions on task events
• API — Full REST API for building custom integrations or connecting to n8n

The API is particularly useful if you want to create tasks programmatically — for example, turning form submissions or monitoring alerts into tracked work items.

Tips from Production Use

1. Set up SMTP first. Without email notifications, task assignments and due date reminders go unnoticed. Even a free SMTP relay like Brevo (formerly Sendinblue) works fine for small teams.

2. Use milestones, not just tasks. It's tempting to dump everything into a flat kanban board. But milestones give you the "zoom out" view that prevents deadline surprises.

3. Configure the timezone. Leantime defaults to America/Los_Angeles. If your team is elsewhere, set LEAN_DEFAULT_TIMEZONE correctly or due dates will confuse everyone.

4. Enable two-factor authentication. Leantime supports TOTP-based 2FA. Turn it on for all users, especially if the instance is internet-facing.

5. Keep MariaDB tuned. For larger teams, adjust MariaDB's innodb_buffer_pool_size to about 50-70% of your available RAM allocated to the database container. The default is usually 128 MB, which is fine for small teams but will slow down with thousands of tasks.

The Bottom Line

Leantime fills a gap that most self-hosted project management tools miss. Vikunja is great for personal tasks but lacks timesheets and strategic planning. Plane and Taiga are built for developers running formal Agile processes. Leantime is for everyone else — the small team that needs to track work, log hours, set goals, and see a Gantt chart without first earning a PMP certification.

It runs on minimal hardware, deploys in minutes with Docker Compose, and stays out of your way once configured. If you've been managing projects in spreadsheets because every "real" project management tool felt like overkill, Leantime is worth a look. It gives you the structure without the bureaucracy.