WeKan vs Focalboard in 2026: Self-Hosted Kanban Boards Compared

TL;DR

Both WeKan and Focalboard are open source Trello alternatives that eliminate per-seat kanban costs. WeKan is the feature-complete kanban specialist — swimlanes, WIP limits, card aging, time tracking, and 50+ integrations. Focalboard is the versatile lightweight board tool — board, table, gallery, and calendar views in a single lightweight Go binary, with native Mattermost integration. For teams that need serious kanban methodology: WeKan. For teams that want multiple views and Mattermost integration: Focalboard.

Key Takeaways

WeKan (MIT, 19K+ stars) is the most feature-complete open source Trello replacement — swimlanes, WIP limits, card aging, rules automation, and detailed API
Focalboard (MIT, 22K+ stars) supports board/table/gallery/calendar views, custom properties, and ships as a lightweight Go binary (100 MB RAM)
Trello Standard costs $5/user/month — a 12-person team pays $720/year
WeKan uses Meteor + MongoDB (heavier stack, 500 MB+ RAM); Focalboard uses Go + SQLite (much lighter)
Focalboard has native Mattermost integration and a standalone desktop app
Both are MIT licensed — free for commercial self-hosting

Choosing Between Kanban Tools

The kanban tool market has fragmented into two camps: specialized kanban tools that focus on the methodology (WIP limits, swimlanes, flow metrics) and general task management tools that happen to have a board view (custom properties, multiple views, spreadsheet-like interface).

WeKan belongs to the first camp. It's a kanban purist's tool — every feature is oriented around managing flow, reducing WIP, and visualizing work.

Focalboard belongs to the second camp. It's closer to Notion's database views than to a traditional kanban board. You can view the same data as cards, a table, a gallery, or a calendar — which makes it flexible for teams that don't exclusively use kanban methodology.

WeKan — The Feature-Complete Kanban

WeKan has been in development since 2015 and has accumulated every kanban feature you could ask for. The feature depth is impressive; it has features that Trello itself doesn't offer.

# WeKan Docker Compose
services:
  wekan:
    image: ghcr.io/wekan/wekan:latest
    restart: unless-stopped
    ports:
      - "3000:8080"
    environment:
      - MONGO_URL=mongodb://mongodb:27017/wekan
      - ROOT_URL=https://wekan.yourdomain.com
      - WITH_API=true
      - WRITABLE_PATH=/data
      - MAIL_URL=smtp://user:pass@smtp.yourdomain.com:587/
      - MAIL_FROM=WeKan <noreply@yourdomain.com>
      - BIGEVENTS_DAYS=2
    volumes:
      - wekan_data:/data
    depends_on:
      - mongodb
  mongodb:
    image: mongo:6
    restart: unless-stopped
    volumes:
      - wekan_db:/data/db
    command: mongod --oplogSize 128
volumes:
  wekan_db:
  wekan_data:

Swimlanes are WeKan's flagship feature — a horizontal dimension that cuts across all columns on a board. A development team's board might have swimlanes for "Frontend", "Backend", "DevOps", and "QA", each swimming through the same workflow columns (Backlog → In Progress → Review → Done). Each lane can have its own WIP limits and card counts.

WIP limits enforce kanban discipline. Set a maximum number of cards per column (or per swimlane), and WeKan highlights the column in red when you exceed the limit. This surface-level constraint prevents the anti-pattern of piling cards into "In Progress" without finishing them.

Card aging is a visual feedback mechanism unique to WeKan — cards that haven't been touched fade out based on inactivity. The longer a card sits without movement, the more transparent it becomes. This makes stale work visually obvious without needing to run a report.

Rule automation handles simple event-driven workflows:

"When a card is moved to Done, notify the card creator"
"When a card label 'urgent' is added, assign to @oncall"
"When a card due date passes, move to 'Overdue' list"

These rules eliminate manual follow-up work for common board maintenance tasks.

Custom fields let teams capture domain-specific data on cards. A bug tracker board might add "Severity", "Browser", and "Affected Version" fields. A client services board might add "Contract Value" and "SLA Tier". Custom fields appear on the card detail view and can be used for filtering.

Time tracking lets team members log hours directly on cards. The time report aggregates total time by board, by team member, or by card label — useful for billing clients or estimating future work based on historical data.

Key features:

Swimlanes (board horizontal dimension)
WIP limits per column
Card aging (visual fade for old cards)
Rule-based automation
Custom fields (text, number, date, dropdown)
Time tracking per card
Board templates
Trello import (JSON export)
Calendar view
Gantt chart view (experimental)
LDAP/AD integration
SAML SSO support
REST API
50+ webhook/integration endpoints
MIT license

Limitations:

Meteor.js + MongoDB — dated stack, 500 MB+ RAM
Slower startup time than modern frameworks
UI feels functional but not modern
MongoDB adds operational complexity vs PostgreSQL or SQLite

Focalboard — The Lightweight Multi-View Tool

Focalboard was built by the Mattermost team as their project management module. It started as a Notion-like database tool and evolved into a standalone product. The technical difference from WeKan is dramatic — Focalboard is written in Go, stores data in SQLite by default, and runs in 100 MB RAM. It's one of the lightest self-hosted project management tools available.

# Focalboard standalone (no Docker needed)
# Download binary from GitHub releases
wget https://github.com/mattermost/focalboard/releases/latest/download/focalboard-server-linux-amd64.tar.gz
tar xzf focalboard-server-linux-amd64.tar.gz
./bin/focalboard-server

# Or via Docker
docker run -d \
  -p 8000:8000 \
  -v focalboard_data:/opt/focalboard/data \
  mattermost/focalboard

Multiple views are the core differentiator. Every "board" in Focalboard is actually a database — and you can view that database as:

Board view — traditional kanban columns (the Trello equivalent)
Table view — spreadsheet-style with sortable columns (the Airtable equivalent)
Gallery view — visual card grid showing images (good for content pipelines)
Calendar view — cards organized by due date

This flexibility means Focalboard serves use cases that WeKan can't. A content team might use gallery view to review article drafts. A marketing team might use calendar view to see the publication schedule. The same underlying data powers all four views.

// Focalboard REST API — create a card programmatically
const response = await fetch('http://focalboard.yourdomain.com/api/v2/boards/board_id/cards', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Auth-Token': 'your-auth-token',
  },
  body: JSON.stringify({
    title: 'New feature: dark mode',
    fields: {
      status: 'In Progress',
      priority: 'High',
      assignee: 'user_123',
      due_date: '2026-04-15',
    },
  }),
});

Custom properties work like custom columns in a spreadsheet — each property is typed (text, number, select, multi-select, date, person, URL, email, phone, checkbox) and appears in both board card detail and table view columns. Properties replace Trello's rigid label system with a flexible, queryable data model.

Mattermost integration is native — Focalboard ships as a Mattermost plugin, so teams already using Mattermost get project boards without a separate deployment. Cards link to Mattermost channels; mentions notify via DM. If your team is on Mattermost, Focalboard is the obvious choice.

Desktop app is available for Windows, macOS, and Linux. The desktop app syncs with your self-hosted server and works offline with conflict resolution on reconnect.

Key features:

Board, table, gallery, and calendar views
Custom properties (text, number, select, date, person, URL, etc.)
Card templates
Board templates
Trello import
Native Mattermost plugin
Desktop app (Windows, macOS, Linux)
REST API
Lightweight: 100 MB RAM (SQLite default, PostgreSQL supported)
22K+ stars, MIT license

Limitations:

No swimlanes
No WIP limits
Less kanban methodology depth than WeKan
Focalboard standalone development has slowed (Mattermost focuses on the plugin version)

Side-by-Side Comparison

Feature	WeKan	Focalboard
License	MIT	MIT
Stars	19K+	22K+
Stack	Meteor + MongoDB	Go + SQLite/PostgreSQL
Min RAM	500 MB+	100 MB+
Board views	Board only	Board, Table, Gallery, Calendar
Swimlanes	✅	❌
WIP limits	✅	❌
Card aging	✅	❌
Custom fields	✅	✅ (properties)
Time tracking	✅	❌
Automation rules	✅	❌
Card templates	✅	✅
Board templates	✅	✅
Trello import	✅	✅
Mattermost integration	❌	✅ Native
Desktop app	❌	✅
LDAP/SSO	✅	Via Mattermost
Setup complexity	Medium	Low

Decision Framework

Choose WeKan if:

You practice strict kanban methodology (WIP limits, swimlanes are required)
Card aging visualization helps your team spot stalled work
Time tracking per card is needed for billing or estimating
Rule-based automation handles repetitive board maintenance
LDAP/AD integration is required for enterprise auth

Choose Focalboard if:

You want multiple views of the same data (board + table + calendar)
Your team uses Mattermost and wants native integration
Lightweight deployment matters (Go binary, SQLite, 100 MB RAM)
You want a desktop app for offline access
Your team's use case fits a flexible database tool more than a strict kanban board

The Third Option: Planka

If you want a modern, beautiful kanban board without WeKan's heavyweight stack and without Focalboard's complexity, consider Planka — a React + PostgreSQL kanban board with a clean UI and real-time updates. It lacks swimlanes and WIP limits like Focalboard, but the user experience is the best in the open source kanban category.

Cost Comparison

Solution	Annual Cost (10 users)
Trello Standard	$600/year
Trello Premium	$1,200/year
Asana Starter	$1,188/year
WeKan self-hosted	$100–150/year (needs more RAM)
Focalboard self-hosted	$60–80/year (lightweight VPS)

Migrating from Trello to WeKan or Focalboard

Both tools support Trello board imports, but the process and fidelity differ significantly.

WeKan's Trello import: Export your Trello board as JSON (Board → Show Menu → More → Print and Export → Export as JSON). In WeKan, go to the board list → Import → Trello, and upload the JSON file. WeKan recreates the full board structure: lists, cards, checklists, member assignments, labels, and due dates. Attachments in Trello are stored as links in the card descriptions rather than re-downloaded files — you'll need to manually save and re-upload any attachments that need to stay accessible after closing your Trello account. Custom fields created via Trello's Butler automation don't transfer, but WeKan's custom fields can recreate the same data model.

Focalboard's Trello import: Similar JSON import process. Focalboard preserves cards, list structure, and card descriptions well. However, Focalboard's board view maps Trello's lists to swimlanes, while Focalboard's table view exposes the same cards in a spreadsheet format. The mapping takes some getting used to if you're accustomed to Trello's pure board metaphor. Checklists in Trello become subtasks in Focalboard. Member assignments transfer but member accounts need to be created in Focalboard first and matched to Trello member names during import.

Practical migration advice: Before migrating, archive or delete any Trello cards that are older than 3 months and already closed. Migrating years of completed cards adds noise to your new board without value. Export only the active lists (currently in-progress work) plus perhaps one archive list for reference. Run both tools in parallel for 1–2 weeks while the team finishes any in-flight work in Trello, then close the Trello workspace once the active board is fully recreated.

For teams managing larger Trello workspaces across multiple boards, consider whether a board-per-project structure still makes sense or whether consolidating into a single WeKan/Focalboard instance with swimlanes per project is more maintainable. WeKan's swimlane feature is particularly suited to teams that previously used multiple Trello boards to separate work types.

See open source alternatives to Wekan on OSSAlt.

WeKan vs Focalboard in 2026: Which Kanban Board?