Planka: A Self-Hosted Trello Alternative Built on Open Source

Trello revolutionized project management with its simple kanban board interface. Then Atlassian bought it, limited the free tier, and started pushing enterprise features most people don't need. Meanwhile, the self-hosted world has quietly built several excellent alternatives.

Photo by Boitumelo on Unsplash

Planka is a self-hosted kanban board inspired by Trello's original simplicity. It gives you boards, lists, cards, labels, due dates, file attachments, checklists, and team collaboration — all the core features of Trello without the SaaS pricing or data privacy concerns.

Why Self-Host a Kanban Board

Trello's free tier limits you to 10 boards per workspace. Notion charges per user. Asana gets expensive at scale. Monday.com is enterprise-focused and overpriced for small teams.

Self-hosting means:

• Unlimited boards and cards — no artificial limits
• No per-user pricing — add your whole team without cost
• Your data stays private — sensitive projects stay on your infrastructure
• No vendor lock-in — export your data anytime, migrate freely
• Customization — integrate with your existing tools and workflows

Planka runs on a $5/month VPS and scales to handle dozens of users and hundreds of boards.

Planka vs. Focalboard vs. Vikunja vs. Wekan

The self-hosted project management space has several strong options:

Choose Planka if you:

• Want a Trello clone with minimal learning curve
• Prefer simple, focused kanban boards
• Need fast real-time collaboration
• Value clean, uncluttered UI
• Don't need multiple view types (tables, calendars, timelines)

Choose Focalboard if you:

• Want Notion-style flexibility (boards + tables + galleries)
• Need multiple views of the same data
• Are already using Mattermost (Focalboard integrates natively)
• Want enterprise-grade features and support

Choose Vikunja if you:

• Prefer task lists over kanban boards
• Need Getting Things Done (GTD) workflows
• Want the lightest resource footprint
• Like fine-grained task filtering and organization

Choose Wekan if you:

• Are already comfortable with Wekan (it's been around since 2015)
• Need maximum customization via plugins
• Don't mind higher resource usage

For most teams migrating from Trello, Planka is the easiest transition — it looks and feels like Trello, just self-hosted.

Docker Compose Setup

Planka requires PostgreSQL for storage:

services:
  planka:
    image: ghcr.io/plankanban/planka:latest
    restart: unless-stopped
    ports:
      - "3000:1337"
    volumes:
      - planka_user_avatars:/app/public/user-avatars
      - planka_project_background_images:/app/public/project-background-images
      - planka_attachments:/app/private/attachments
    environment:
      BASE_URL: https://planka.yourdomain.com
      DATABASE_URL: postgresql://planka:${DB_PASSWORD}@planka-db/planka
      SECRET_KEY: ${SECRET_KEY}

      # Default admin user (change after first login)
      DEFAULT_ADMIN_EMAIL: [email protected]
      DEFAULT_ADMIN_PASSWORD: ${ADMIN_PASSWORD}
      DEFAULT_ADMIN_NAME: Admin
      DEFAULT_ADMIN_USERNAME: admin

      # Optional: OIDC authentication
      # OIDC_ISSUER: https://auth.yourdomain.com
      # OIDC_CLIENT_ID: planka
      # OIDC_CLIENT_SECRET: ${OIDC_SECRET}
      # OIDC_SCOPES: openid email profile
      # OIDC_ADMIN_ROLES: admin

    depends_on:
      planka-db:
        condition: service_healthy

  planka-db:
    image: postgres:16-alpine
    restart: unless-stopped
    volumes:
      - planka_db:/var/lib/postgresql/data
    environment:
      POSTGRES_DB: planka
      POSTGRES_USER: planka
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U planka"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  planka_db:
  planka_user_avatars:
  planka_project_background_images:
  planka_attachments:

Create a .env file:

DB_PASSWORD=your-secure-db-password
SECRET_KEY=$(openssl rand -hex 32)
ADMIN_PASSWORD=your-admin-password

Generate a random SECRET_KEY:

openssl rand -hex 32

Start the stack:

docker compose up -d

Visit http://your-server:3000 and log in with the admin credentials from your .env.

First-Time Setup

After logging in:

1. Change the admin password — Settings → Security
2. Update admin email — Settings → Profile
3. Create your first board — Click "Create project"
4. Invite team members — Settings → Users → Add user

Core Features

Boards and Lists

Planka uses Trello's terminology:

• Board (project) = a workspace for a specific project or team
• List = a vertical column (e.g., "To Do", "In Progress", "Done")
• Card = an individual task or item

Create a board:

1. Click Add project on the homepage
2. Name your board
3. Add lists (Backlog, To Do, In Progress, Review, Done)
4. Start adding cards

Drag cards between lists to update their status.

Cards

Cards are the core unit of work. Each card supports:

• Title and description — markdown-formatted
• Labels — color-coded tags (Bug, Feature, Urgent, etc.)
• Due dates — with optional notifications
• Checklists — sub-tasks within a card
• Attachments — upload files or link external resources
• Comments — team discussion on the card
• Members — assign users to the card
• Activity log — audit trail of changes

Click a card to open the detail view and edit any of these fields.

Labels

Create custom labels per board:

1. Open a card
2. Click Labels
3. Create new labels with custom names and colors
4. Apply multiple labels to a card

Labels are board-specific — each board has its own label set.

Common label schemes:

• Priority: High, Medium, Low
• Type: Bug, Feature, Documentation
• Status: Blocked, Waiting, Urgent
• Team: Backend, Frontend, Design

Checklists

Break cards into sub-tasks:

1. Open a card
2. Add a checklist
3. Add items to the checklist
4. Check off items as they're completed

Progress is shown as a percentage on the card face (e.g., "3/5 checklist items complete").

File Attachments

Upload files directly to cards:

• Drag and drop files onto a card
• Or click Attachments → Upload
• Supports images, PDFs, documents, etc.

Files are stored in the Docker volume (planka_attachments) or optionally in S3-compatible storage.

Comments and Activity

Team members can discuss cards via comments:

• @mention other users to notify them
• Use markdown for formatting
• View full activity history (who moved the card, who added labels, etc.)

All changes are logged in the card's activity feed.

User Management and Collaboration

Adding team members

1. Settings → Users → Add user
2. Enter email, username, and password
3. New users receive an account and can log in immediately

(Or enable OIDC for single sign-on — see below.)

Board permissions

Planka has simple permission levels:

• Board member: Can view and edit the board
• Non-member: Cannot see the board at all

Add members to a board:

1. Open the board
2. Click Members
3. Add users from your organization

Each board's members are independent — users only see boards they're added to.

User roles

Planka has two global roles:

• Admin: Can manage all boards, users, and settings
• User: Can only access boards they're a member of

Set roles in Settings → Users.

OIDC Authentication

Integrate Planka with Authentik, Keycloak, or another OIDC provider:

environment:
  OIDC_ISSUER: https://auth.yourdomain.com
  OIDC_CLIENT_ID: planka
  OIDC_CLIENT_SECRET: ${OIDC_SECRET}
  OIDC_SCOPES: openid email profile
  OIDC_ADMIN_ROLES: admin
  OIDC_EMAIL_ATTRIBUTE: email
  OIDC_NAME_ATTRIBUTE: name
  OIDC_USERNAME_ATTRIBUTE: preferred_username

Users log in via your identity provider. Planka creates accounts automatically on first login.

Assign admin privileges based on OIDC roles (e.g., users with the admin role become Planka admins).

Notifications

Planka sends notifications for:

• Card assignments: When you're added to a card
• Due dates: When a card you're assigned to is due soon
• @mentions: When someone mentions you in a comment

Notifications appear in the Planka web UI (bell icon). Email notifications are not yet implemented but are on the roadmap.

Mobile Access

Planka is a Progressive Web App (PWA):

1. Open Planka in your mobile browser
2. Add to home screen (iOS: Share → Add to Home Screen; Android: Menu → Add to Home Screen)
3. Planka launches like a native app

The mobile UI is responsive and touch-optimized. Real-time updates work on mobile (cards move when teammates drag them).

There's no native iOS/Android app yet, but the PWA experience is solid.

API Access

Planka exposes a REST API for automation and integrations:

• Endpoint: https://planka.yourdomain.com/api
• Authentication: Session-based (cookie auth after login)

Example: Create a card via API:

curl -X POST https://planka.yourdomain.com/api/cards \
  -H "Content-Type: application/json" \
  -H "Cookie: session=YOUR_SESSION_COOKIE" \
  -d '{
    "listId": "LIST_ID",
    "name": "New card from API",
    "position": 0
  }'

Use the API to:

• Automate card creation from external events (GitHub issues, monitoring alerts)
• Sync Planka with other tools (calendar, chat, CRM)
• Build custom integrations

API documentation is minimal but available in the GitHub repo.

Data Export and Backup

Backup strategy

1. PostgreSQL database: Back up the planka_db volume or use pg_dump
2. File attachments: Back up the planka_attachments volume
3. User avatars and images: Back up planka_user_avatars and planka_project_background_images

Example backup:

docker compose down
tar czf planka-backup.tar.gz \
  /var/lib/docker/volumes/planka_db \
  /var/lib/docker/volumes/planka_attachments \
  /var/lib/docker/volumes/planka_user_avatars \
  /var/lib/docker/volumes/planka_project_background_images
docker compose up -d

Export to JSON

Planka doesn't have built-in export yet, but you can:

• Query the PostgreSQL database directly to extract card data
• Use the API to fetch boards, lists, and cards as JSON

For migration to another tool, export via API and transform the JSON to match the target format.

Resource Requirements

| Component | RAM | CPU | Storage | |---|---|---| | Planka (Node.js) | 100-150 MB | Low (0.5 cores) | 50 MB | | PostgreSQL | 50-100 MB | Low | 100-500 MB | | File attachments | — | — | Variable (depends on uploads) | | Total | **150-250 MB** | < 1 core | < 1 GB |

Planka runs comfortably on a 1GB RAM VPS. Storage depends on file uploads — plan 100-500 MB for the database plus however much space you need for attachments.

Integrations

Planka doesn't have official integrations yet, but you can build custom ones via the API:

GitHub Issues → Planka Cards

Use webhooks or GitHub Actions to create Planka cards when issues are opened:

# .github/workflows/sync-to-planka.yml
on:
  issues:
    types: [opened]

jobs:
  sync:
    runs-on: ubuntu-latest
    steps:
      - name: Create Planka card
        run: |
          curl -X POST ${{ secrets.PLANKA_URL }}/api/cards \
            -H "Cookie: session=${{ secrets.PLANKA_SESSION }}" \
            -d '{"listId":"${{ secrets.PLANKA_LIST_ID }}","name":"${{ github.event.issue.title }}"}'

Monitoring Alerts → Planka Cards

Send monitoring alerts (Uptime Kuma, Grafana) to Planka via webhooks:

curl -X POST https://planka.yourdomain.com/api/cards \
  -H "Cookie: session=YOUR_SESSION" \
  -d '{"listId":"ALERTS_LIST_ID","name":"Server down: api.example.com"}'

Chat Notifications

Post Planka activity to Discord, Slack, or Matrix:

• Set up a webhook in your chat platform
• Use Planka's activity log (API) to detect new cards or comments
• Send a message to the webhook

Honest Limitations

• No native mobile apps: The PWA works well, but some users prefer native apps.
• Limited integrations: No official Slack, GitHub, or Jira integrations (yet).
• No built-in time tracking: You can add time estimates to card descriptions, but there's no native timer.
• No calendar view: Cards with due dates appear in lists, but there's no calendar or timeline view.
• Email notifications not yet implemented: Notifications only appear in the web UI.
• Single attachment per upload: You must upload files one at a time (drag-and-drop of multiple files doesn't batch upload).
• Smaller community than Trello: Fewer third-party tools, templates, and power-ups.

For basic kanban project management, these aren't deal-breakers. For complex enterprise workflows, you might need Focalboard or a commercial tool.

Comparison with Trello

Planka doesn't have Trello's polish or ecosystem, but it has no artificial limits and full control over your data.

The Bottom Line

Planka is a solid Trello alternative for teams that want to self-host their project management without learning a new tool. It doesn't try to be Notion or Jira — it's a focused kanban board with real-time collaboration, file attachments, and team management.

If you're already using Trello and frustrated by the free tier limits, Planka is a straightforward migration. If you need advanced features like time tracking, calendar views, or extensive integrations, consider Focalboard or Vikunja.

For most small teams and personal projects, Planka hits the sweet spot between simplicity and functionality.

Resources

• Planka documentation
• Planka GitHub
• Planka demo — try it without installing
• API documentation