Personal Kanban With Planka or Focalboard

Trello is great until the free tier's board limits bite, your cards vanish into someone else's data, or you want to integrate a board with your own scripts. Self-hosted kanban tools fill that gap without sacrificing the drag-and-drop planning flow. Planka and Focalboard are two modern, open-source options that run neatly on a VPS and keep your projects on infrastructure you control.

A personal kanban board is a surprisingly effective way to run a release, a side project, or a study plan, and self-hosting it removes the board-count and member limits that plague free tiers. You get unlimited cards, your own automation hooks, and a board that is still there tomorrow.

This guide compares them and walks through deploying each with Docker Compose, plus how to move between them if you change your mind.

Planka vs Focalboard

• Planka is the closest Trello clone: boards, lists, cards, labels, due dates, comments, and real-time updates. It is lightweight, runs on a Node stack, and feels instantly familiar.
• Focalboard (Mattermost's tool) is more of a structured workspace with multiple view types, including boards, tables, calendars, and gallery views. It favours organization over the pure kanban aesthetic.

For a clean kanban workflow pick Planka. For a flexible project workspace mixing boards with tables and calendars, pick Focalboard.

Both are licenced openly and free to use, so there is no cost to trying one and switching if it does not click. The data is small on either, which means you can stand up a second instance side by side, run a real project for a week, and let the workflow decide rather than reading comparisons forever.

Deploying Planka

Planka ships an app plus Postgres. Compose makes it painless:

services:
  planka:
    image: ghcr.io/plankanban/planka:latest
    container_name: planka
    environment:
      - BASE_URL=https://board.example.com
      - DATABASE_URL=postgres://planka:secret@db:5432/planka
      - SECRET_KEY=generate-a-strong-random-key
    depends_on:
      - db
    ports:
      - "127.0.0.1:1337:1337"
    restart: unless-stopped

  db:
    image: postgres:16-alpine
    environment:
      - POSTGRES_DB=planka
      - POSTGRES_USER=planka
      - POSTGRES_PASSWORD=secret
    volumes:
      - ./db:/var/lib/postgresql/data
    restart: unless-stopped

Generate SECRET_KEY with openssl rand -hex 32. After first login create projects, boards, and invite teammates by email.

Planka's data model is database-backed and self-contained, which makes it easy to back up: one Postgres dump plus the app volume covers everything. Because it is a familiar Trello-style board, adoption needs no training. You can reorganize lists, tag cards with labels, set due dates, and attach comments without anyone having to learn a new paradigm, which is often the deciding factor for a small team.

Deploying Focalboard

Focalboard is a single container with its own embedded storage by default:

services:
  focalboard:
    image: mattermost/focalboard
    container_name: focalboard
    volumes:
      - ./data:/data
    ports:
      - "127.0.0.1:8000:8000"
    restart: unless-stopped
    environment:
      - ENABLE_TELEMETRY=false

The default SQLite storage is fine for personal use. Disable telemetry with the environment flag shown, then create a workspace and start structuring work as boards with card properties, checklists, and custom views.

Focalboard's superpower is the view switcher. The same underlying cards render as a kanban board, a sortable table, a calendar, or a gallery, so you can plan on a board one week and review on a calendar the next without duplicating data. That flexibility makes it a better long-term home for data that behaves like structured tasks with dates and fields rather than purely visual to-do columns.

Automating Board Updates

Both tools look better when cards move programmatically. Planka exposes a REST API; a simple create-and-assign script looks like:

curl -X POST https://board.example.com/api/boards   -H "Content-Type: application/json"   -d '{"name":"Release 2026","background":"#22d3ee"}'

Use such calls to spawn a card per release ticket, or to sync an external issue tracker's state into your board.

For a personal workflow, a cron job that opens a daily review card, or a script that moves a card to Done when a linked deploy succeeds, turns the board from a record of work into an actual driver of it. Because the API is local to your network, these integrations are fast and carry no per-request cost, so you can afford generous automation without thinking about quotas.

Takeaway

A self-hosted kanban board keeps your roadmaps, tasks, and cards on your own server, with API access for automation and no board-count limits. Pick Planka for pure kanban or Focalboard for flexible structured views.

Run either on a 1 GB Ubuntu VPS from Netbay — deployed in under 60 seconds at netbayhosts.in.