WeKan vs Focalboard: Self-Hosted Project Boards

Quick Verdict

WeKan is the clear winner. It is actively maintained (v8.34 as of February 2026), packed with kanban features like swimlanes, WIP limits, and custom fields, and has a healthy release cadence. Focalboard’s standalone version is abandoned — Mattermost stopped maintaining it in late 2023 and folded the functionality into Mattermost Boards. Unless you are already running Mattermost and want the built-in boards plugin, choose WeKan.

Overview

WeKan is an open-source kanban board inspired by Trello. It is built on Meteor/Node.js with MongoDB as its database. WeKan has been around since 2015 (originally “LibreBoard”) and ships features that Trello charges for: swimlanes, WIP limits, custom fields, card voting, time tracking, and granular permissions. It receives frequent updates — multiple releases per month — and supports LDAP, OIDC, SAML, and OAuth2 authentication.

Focalboard was a project management tool by Mattermost that offered kanban boards alongside table, gallery, and calendar views. The standalone personal server used SQLite and was easy to deploy. However, Mattermost deprecated the standalone version, redirecting development into Mattermost Boards (a core Mattermost feature). The standalone repository is marked “currently not maintained” on GitHub. The last standalone-compatible release was v7.11.4 in September 2023; v8.0.0 (June 2024) is a Mattermost plugin only.

This comparison covers the standalone versions of both tools. If you need Focalboard functionality today, you need to deploy the full Mattermost stack.

Feature Comparison

Feature	WeKan	Focalboard (Standalone)
License	MIT	AGPL-3.0 (was MIT)
Active development	Yes (v8.34, Feb 2026)	No (unmaintained since 2023)
Language	Meteor/Node.js	Go + TypeScript
Database	MongoDB (required)	SQLite / PostgreSQL
Kanban boards	Yes	Yes
Table view	Yes	Yes
Calendar view	Yes	Yes
Gallery view	No	Yes
Swimlanes	Yes	No
WIP limits	Yes	No
Custom fields	Yes (text, number, date, dropdown, checkbox)	Yes (properties system)
Card voting	Yes	No
Time tracking	Yes	No
Due dates	Yes	Yes
Checklists	Yes	Yes
File attachments	Yes	Yes
Comments	Yes	Yes
Board templates	Yes	Yes (extensive)
Subtasks	Yes	No
Card colors/labels	Yes	Yes
LDAP/OIDC/SAML	Yes (all three)	Mattermost version only
REST API	Yes	Yes
Webhooks	Yes	Limited
Multi-language	50+ languages	~20 languages
Mobile support	Responsive web	Responsive web
RAM usage (idle)	200-400 MB (app + MongoDB)	50-100 MB (SQLite mode)

Installation Complexity

WeKan requires two containers: the WeKan application and MongoDB. The Docker Compose setup is straightforward but MongoDB adds overhead — you need to allocate at least 1 GB of RAM for a comfortable experience. Configuration happens through environment variables, and there are dozens of them. The essentials (database URL, root URL) are simple, but fine-tuning authentication or email requires reading the docs.

Focalboard standalone was the simpler deployment — a single container with SQLite, no external database needed. Run docker run -p 80:8000 mattermost/focalboard and you had a working board. The trade-off: SQLite does not handle concurrent users well, and since the project is abandoned, Docker images may stop working as dependencies age.

Winner: Focalboard was easier to deploy, but that advantage is moot since it is no longer maintained. WeKan’s two-container setup is the only viable option.

Docker Compose: WeKan

services:
  wekandb:
    image: mongo:7.0.16
    container_name: wekan-db
    restart: unless-stopped
    command: mongod --oplogSize 128
    volumes:
      - wekan-db:/data/db
      - wekan-db-dump:/dump
    networks:
      - wekan-net

  wekan:
    image: ghcr.io/wekan/wekan:v8.34
    container_name: wekan-app
    restart: unless-stopped
    ports:
      - "3001:8080"  # Web UI on port 3001
    environment:
      # -- Required --
      - MONGO_URL=mongodb://wekandb:27017/wekan
      - ROOT_URL=http://localhost:3001  # Change to your domain
      - WRITABLE_PATH=/data

      # -- Email (optional, for notifications) --
      # - MAIL_URL=smtp://user:[email protected]:587/
      # - [email protected]

      # -- API --
      - WITH_API=true  # Enable REST API and data export

      # -- Authentication (uncomment what you need) --
      # LDAP
      # - LDAP_ENABLE=true
      # - LDAP_HOST=ldap.example.com
      # - LDAP_PORT=389

      # OIDC
      # - OAUTH2_ENABLED=true
      # - OAUTH2_LOGIN_STYLE=redirect
      # - OAUTH2_CLIENT_ID=your-client-id
      # - OAUTH2_SECRET=your-client-secret
      # - OAUTH2_SERVER_URL=https://auth.example.com
    volumes:
      - wekan-files:/data
    networks:
      - wekan-net
    depends_on:
      - wekandb

volumes:
  wekan-db:
  wekan-db-dump:
  wekan-files:

networks:
  wekan-net:
    driver: bridge

Start it:

docker compose up -d

Access the web UI at http://your-server:3001. Register the first account — it becomes the admin.

Docker Compose: Focalboard (Standalone)

Warning: Focalboard standalone is abandoned. This config works as of the last release (v7.11.4) but will receive no security patches or bug fixes. Use at your own risk.

services:
  focalboard:
    image: mattermost/focalboard:7.11.4
    container_name: focalboard
    restart: unless-stopped
    ports:
      - "8000:8000"  # Web UI
    volumes:
      - focalboard-data:/opt/focalboard/data  # SQLite database and uploads
    environment:
      - FOCALBOARD_PORT=8000  # Internal server port
    networks:
      - focalboard-net

volumes:
  focalboard-data:

networks:
  focalboard-net:
    driver: bridge

Start it:

docker compose up -d

Access the web UI at http://your-server:8000. Click “Register” to create the first user. Focalboard standalone uses a local account system — no external auth without the Mattermost integration.

Performance and Resource Usage

Metric	WeKan	Focalboard
Idle RAM (app)	150-250 MB	30-60 MB
Idle RAM (database)	100-200 MB (MongoDB)	0 (SQLite is in-process)
Total idle RAM	250-450 MB	30-60 MB
CPU at idle	Low	Very low
Disk (application)	~500 MB (image + MongoDB)	~100 MB
Startup time	10-15 seconds	2-3 seconds
Concurrent users	Handles 50+ with adequate RAM	SQLite struggles past 5-10

Focalboard is lighter because SQLite runs in-process and the Go binary is compact. WeKan’s MongoDB requirement makes it heavier but also more capable under concurrent load. For a team of more than a few people, WeKan’s architecture scales better.

Community and Support

WeKan has an active community. The GitHub repository shows consistent releases (multiple per month in early 2026), an active issue tracker, and a dedicated maintainer (xet7). Documentation lives at wekan.github.io and covers most deployment scenarios. Community support happens through GitHub issues and a community chat.

Focalboard has a stale community. The GitHub repo is marked as unmaintained. Issues pile up without responses. The last meaningful development happened in 2023. Documentation still exists but links to deprecated features. If you hit a bug, you are on your own.

Use Cases

Choose WeKan If…

• You want a full-featured, Trello-like kanban board that is actively maintained
• You need swimlanes, WIP limits, or card voting — features Focalboard never had
• You need LDAP, OIDC, or SAML authentication for a team deployment
• You want a project that will still receive updates next year
• You are managing multiple boards across teams with different permissions

Choose Focalboard If…

• You are already running Mattermost and want integrated boards (use Mattermost Boards, not the standalone)
• You need multiple views (kanban + table + gallery + calendar) in a single tool
• You want the lightest possible deployment for personal use and accept the maintenance risk
• You specifically need board templates for recurring project types

Final Verdict

WeKan wins this comparison decisively. The decisive factor is not even features — it is maintenance status. Focalboard’s standalone version is dead software. It will not receive security patches, bug fixes, or compatibility updates. Deploying abandoned software for a team is a liability.

On features alone, WeKan still wins for pure kanban workflows. Swimlanes, WIP limits, card voting, time tracking, and subtasks give it depth that Focalboard never matched. Focalboard’s advantage was its multi-view approach (kanban + table + gallery + calendar), which is genuinely useful for project management beyond kanban. But that advantage now lives inside Mattermost — not in a standalone tool.

If you want a self-hosted kanban board, deploy WeKan. If you want the multi-view project management that Focalboard offered, look at Vikunja or Plane instead — both are actively maintained and offer similar flexibility.

Related

• How to Self-Host Vikunja
• How to Self-Host Plane
• Focalboard vs Planka
• Planka vs WeKan
• Kanboard vs WeKan
• Docker Compose Basics
• Reverse Proxy Setup
• Backup Strategy