Self-hosted alternatives to Trello: Planka, Kanboard and WeKan compared

The short answer

Pick Planka if you want the board that feels most like Trello: it updated our second browser in under half a second, emailed card members without any setup and imported our Trello export with its lists, labels, checklists and comments, in about 100 MB. But its licence is not open source, and templates, single sign-on, exports and a phone layout are in its paid Pro edition. Pick Kanboard for a light, plain tool with 43 automatic actions, a JSON-RPC API and LDAP, all free under the MIT licence, if you can live without a Trello importer, live updates and more than one person per card. Pick WeKan for the longest feature list for free, also under MIT: rules, templates, single sign-on, a phone layout and an importer for Trello and a dozen other tools. Expect to babysit it: it used almost a whole processor core at rest in our setup, and its outgoing webhook locked two of our users out.

All three are maintained today, so we kept all three; release dates are under Updates and backups. For sprints, a backlog or Gantt charts, see the Jira alternatives instead.

What we tested

We installed all three on the same fresh Melonslab VC-P Alloy (2 vCPU, 8 GB) with Debian 13, each under a user of its own, as rootless Podman Quadlet units behind the same Caddy, with PostgreSQL 17 as the database and every password as a Podman secret. We have no guide for any of them yet, so How we ran them has the unit files, on top of the Podman guide.

Then we built the same board in all three, a website relaunch:

• 5 lists, Backlog, To do, Doing, Review and Done, with 40 cards;
• 5 labels (Bug, Feature, Design, Content, Urgent) on every card, due dates on 15 cards, a checklist on 10, two PNG images and a PDF attached, and 12 comments;
• three users: Anna, who owns the board, Erik, a member, and Lisa, who may only read. Anna or Erik, or both, were members of 35 cards.

We built the boards through each app's API and checked them in a browser. Then we had Anna and Erik open the board in two headless browsers while cards were moved, by one of them and by both at once, and set up automation, email to a local test mail server, a Trello import, exports, webhooks, a read-only member, a phone-sized screen and Swedish. We rebooted the server, measured memory at rest and while Anna and Erik worked, and backed up and restored each app.

Trello itself was not tested. We did not sign up. What this page says about Trello comes from Atlassian's own pages, linked where we use them and read on 14 October 2026.

The numbers

Memory is the sum of each app's containers, measured with podman stats from four to seven and a half minutes after a reboot. The peak is the highest reading while Anna and Erik opened the board and cards, moved cards and commented through each app's API for three minutes, about five requests a second between them. Processor use at rest is each app user's share over one minute, ten minutes after the test. The setup time is how long the commands took to run, mostly downloading images, not the time you need to read and type them.

Setup

All three are two or three containers behind Caddy, and all three were answering within a minute and a half. The differences are in the first account.

• Planka creates its first admin from settings in the unit file, with the password from a Podman secret. On their first sign-in, everyone has to accept Planka's terms of use, a page you can replace with your own. Nobody can sign up: the admin creates the accounts.
• Kanboard starts with admin and the password admin. We changed it with Kanboard's own command before the board went online. There is no sign-up page.
• WeKan has no account at all at first: the first person to sign up becomes the admin, and sign-up stays open to anyone until you switch it off in the Admin Panel, after which it asks for an invitation code. We signed up Anna over the local port first, then switched sign-up off.

WeKan's own Compose file downloads a FerretDB binary every time its database container starts, from the newest release of WeKan's own FerretDB fork. We downloaded one release once, checked its checksum and pinned it instead; How we ran WeKan shows how.

Day-to-day use

Planka looks and works the most like Trello: a dark project page, boards as tabs, lists side by side, cards with cover images, label chips, a checklist bar, due dates and avatars. You open a card in a window and drag cards with the mouse. It also has a grid and a list view of the same board.

Kanboard is plainer: columns in a table, yellow cards numbered #11, #12, with the assignee's name, tags, the due date and counters for subtasks, comments and files. A board can have swimlanes, limits per column, categories, priorities and time estimates. A task has one assignee, so the cards that both Anna and Erik were members of got Anna only. Checklists are subtasks, with a status each.

WeKan puts the most on each card: checklists shown open on the board, labels in strong colours, due dates with "8 days left", members and badges for comments and attachments. It has swimlanes, a calendar, card dependencies, custom fields, voting and much more in its menus. Its interface is busier and slower to load than the other two.

Two people on the same board

Anna and Erik each had the board open in a headless browser. Anna moved a card through the API, and we timed how long it took to move in Erik's browser without a reload. Then both moved the same card to different lists at the same moment. We ran this three times in each app.

• Planka moved the card in Erik's browser within 0.2 to 0.5 seconds. When both moved it at once, both browsers showed the same list within five seconds, the one whose move came last.
• WeKan took about two seconds, 1.9 to 2.6, and also agreed on the last move within five seconds. Its Compose files say that with FerretDB, WeKan checks for changes by polling instead of being told about them, which is what that delay is.
• Kanboard reloads the board in the background, every 10 seconds by default (Settings > Board settings). A move showed up after about three seconds in Erik's browser, and after both moved the card at once, both browsers agreed after 10 seconds. In our first round, Anna's own browser still showed the old list after 15 seconds, until we reloaded the page.

None of them warned anyone that the card had been moved by someone else at the same time: the last move simply won, and the server and both browsers agreed in the end.

Templates

• Planka's Community Edition has no templates. Card and board templates and recurring cards are in Pro, according to the Planka Pro page. You can duplicate a single card.
• Kanboard can Duplicate a project, choosing which parts to bring: permissions, roles, categories, tags, automatic actions, filters and tasks. Our copy had all 40 tasks with their subtasks and the automatic action. Predefined contents fills new task descriptions from templates.
• WeKan has a Templates page where each user keeps card, list and board templates, and can copy a board: our copy through the API had all 40 cards.

Automation instead of Power-Ups

• Kanboard has 43 Automatic actions per project, such as assigning a user, changing a colour, closing a task or sending it by email when it is moved, created or left alone too long. We set "Assign the task to a specific user" when a task is moved to Review; Anna moved a card there, and it was Erik's.
• WeKan has Rules: a trigger, such as a card moved to a list, a label or member added or a checklist done, and an action, such as adding a member or label, setting a date, archiving or sending an email. Our rule, "moved to Review: add Erik", added Erik to the card next to Anna.
• Planka has no automation. It can pass notifications on to other services through Apprise, and send webhooks to your own scripts.

None of them has an equal to Trello's Power-Up directory; Kanboard has a plugin directory with 165 plugins, among them Gantt charts and a calendar, many of them not updated in years.

Email notifications

We pointed all three at a local test mail server; sending through a real email provider was not tested.

• Planka emailed card members without any setup: Erik got "You Were Added to Card" for each card he was added to, and "New Comment" and "Card Moved" when Anna commented on or moved one of his cards, within a second.
• Kanboard sends nothing until each user turns on Email under Notifications in their profile and picks which tasks. After Erik did, Anna's comment and move on his task each gave him an email within seconds.
• WeKan sets new members to Muted for the board. Erik got an email about Anna's comment on his card about 40 seconds later, but none about her moving it. It also emailed Anna to confirm her address when she signed up.

Import from Trello

We did not use a real Trello account. We built a small export by hand in the JSON format a Trello board exports, which Trello's documentation describes: 3 lists, 8 cards, one of them archived, 3 labels, due dates, one of them marked complete, 2 checklists, 3 comments by two members and a link attachment. This was a constructed export, not one from trello.com.

• Planka imports a Trello file when you create a board. Lists, cards, labels with their colours, descriptions, due dates and the complete mark, checklists with their ticks and comments came through. The comments were posted as Anna, with a note at the bottom saying who wrote them and when. Card members and the link attachment were dropped, and the archived card was left out.
• WeKan imports a Trello file as a new board, and has you match Trello's members to its own users. Everything Planka brought came through, and also the members of each card and the right author on each comment; the archived card arrived archived. The complete mark on the due date and the link attachment were lost. WeKan also imports from Jira, Kanboard, CSV, Asana and others, according to its API documentation.
• Kanboard has no Trello importer, and none in its plugin directory. It imports tasks from a CSV file, which Trello only exports on its Premium plan; we did not test that.

Real Trello exports link to attachments on trello.com, which need your Trello login to download, so plan on moving files by hand or with a script.

Export

• Planka's Community Edition has no board export in its menus. PDF and HTML export are in Pro. Its API returns a board with all its cards as JSON.
• Kanboard exports tasks, subtasks, transitions and a daily summary as CSV, from the project menu or with its command line; our task export listed all 40 tasks with column, assignee, due date and tags.
• WeKan exports a board as JSON or CSV, which we tested: the CSV held all 40 cards. Its API documentation also lists TSV, Excel, PDF and a ZIP file with attachments, and its 12.40 release notes an export back to Trello.

An export is a copy to read elsewhere, not a backup.

API and webhooks

• Planka has a documented REST API with keys per user, and webhooks that an admin sets for the whole server, choosing events such as cardUpdate and commentCreate. Our webhook got the moved card within a second.
• Kanboard has a JSON-RPC API, for an app token or each user's password, and one webhook URL for the whole server under Settings > Webhooks. Our moved task arrived at once. Kanboard blocks webhooks to private addresses unless you allow them, which we did for our local test receiver.
• WeKan has a REST API and outgoing webhooks per board, under the board menu > Integrations. It refused our local receiver's private address. With a public address, nothing arrived. Worse, twice in a row, as first Anna and then Erik worked on that board in a browser, WeKan logged a "HookBleed" security event, "client tried to send 'act-addComment' through webhook", and disabled their account. Neither could sign in again until we switched them back on in the database. After we removed the webhook, it did not happen again. We would not use WeKan's webhooks in 12.40.

Permissions

All three kept Lisa read-only. She saw all 40 cards, and her attempts to add a card, move one and comment were refused with "Forbidden" in each.

• Planka has board roles: Editor and Viewer, where a viewer may be allowed to comment. Users are Admin, Project owner or Board user on the whole server. Worker and guest roles are in Pro.
• Kanboard has Project manager, Project member and Project viewer per project, and Custom roles of your own.
• WeKan has the most board roles: admin, normal, comment only, no comments, worker, read only and versions limited to cards assigned to you. It also logged Lisa's attempts as a security event, without locking her out.

Sign-in and single sign-on

We tested passwords in all three, and no single sign-on.

• Planka's Community Edition has passwords and two-factor codes. Its API documentation lists a sign-in with OpenID Connect, but the Community image has no such code: single sign-on with OpenID Connect is in Pro.
• Kanboard has passwords, two-factor codes, LDAP and sign-in through headers from a reverse proxy built in. Its plugin directory has a generic OAuth2 plugin, last updated in 2020.
• WeKan has OpenID Connect and OAuth2, such as authentik or Keycloak, LDAP, SAML and CAS, all free and set in the unit file.

Phones

We opened each board in a phone-sized headless browser, as an iPhone 13.

• Planka's Community Edition shows the desktop board: the page was 1,432 pixels wide on a 390-pixel screen, so you scroll sideways between lists. A touch layout is new in Pro 2.5.0. There is no official app; Planka's apps page lists a community app for adding cards.
• Kanboard also shows its desktop board, 1,230 pixels wide. There is no official app.
• WeKan switched to a phone layout of its own, with the lists stacked and opened one at a time. Its store apps are a full-screen browser for WeKan's own cloud, according to WeKan's app page; for your own server, you add the site to your home screen.

Swedish

All three come in Swedish, chosen per user.

• Planka: each user picks Svenska as their language. Lisa saw "Medlemmar", "Etiketter" and "Sök kort…".
• Kanboard: Language under Edit profile, Svenska. Lisa saw "Översikt", "Tavla" and "Antal uppgifter". Changing a user's language through the API's updateUser failed with an SQL error; the profile page worked.
• WeKan picked Swedish from Lisa's browser language by itself: "Sortera kort", "Filtrera" and "Simbanor". You can also pick it under Change Language.

Resources

Kanboard is a PHP app and the smallest by far: 20 MB at rest and 27 MB at its peak, almost all of it its web server and PHP. Planka is a Node.js app at about 95 MB at rest, which grew to 386 MB under our three minutes of use and was back at 119 MB right after. WeKan is a Meteor app on Node.js, on FerretDB, which translates MongoDB's protocol into PostgreSQL: about 220 MB at rest and 500 MB at the peak, of which WeKan itself 338 MB.

The surprise was the processor. At rest, with nobody signed in, WeKan, FerretDB and PostgreSQL together kept almost a whole core busy, 88% of one core, polling each other for changes; Planka and Kanboard used 2 to 3%. On our 2-vCPU server that is a cost you pay all day. WeKan's database had also grown to 238 MB after the test, against 66 MB for the other two, most of it activity records.

Kanboard was slowest per request: building the board through its API took 67 seconds, against 16 for Planka and 56 for WeKan.

Updates and backups

We checked each project's releases on 14 October 2026.

• Planka released 2.2.1 on 10 August 2026 and 2.2.0 the day before; 2.1.0 came in March. Its paid Pro edition is at 2.5.0. Our units pin 2.2.1; you update by changing the tag after reading the release notes.
• Kanboard has released roughly every month, 1.2.49 in January to 1.2.54 on 29 August 2026. Its README says it "is in maintenance mode": its author adds no major features, but fixes and contributions are released regularly. We pinned v1.2.54.
• WeKan released six versions between 12 and 14 October 2026, up to 12.40, and its FerretDB fork three versions in the same three days. That is the opposite of unmaintained, but it means a lot of change: pin both, as we did, and read the changelog before you move.

Each backup is a pg_dump of the database and an export of the volume with the attachments: 204 KB for Planka, 476 KB for Kanboard and 33.5 MB for WeKan in our test. We dropped each database, restored the dump and the volume, and the 40 cards and all three attachments came back with the same sizes. All three came back by themselves after a reboot, within 48 seconds.

How we ran Planka

Planka's Docker documentation runs Planka and PostgreSQL with Compose; we ran the same two images as Quadlet units in a pod. As a user planka, created like any app user in the Podman guide, create the secrets:

pw=$(openssl rand -hex 24)
printf %s "$pw" | podman secret create planka-db-password -
printf %s "postgresql://planka:$pw@localhost:5432/planka" | podman secret create planka-db-url -
openssl rand -hex 32 | tr -d '\n' | podman secret create planka-secret-key -
printf %s "$(openssl rand -base64 18)" | podman secret create planka-admin-password -
printf %s 'your-smtp-password' | podman secret create planka-smtp-password -

~/.config/containers/systemd/planka.pod:

[Pod]
PodName=planka
PublishPort=127.0.0.1:8126:1337

[Install]
WantedBy=default.target

planka-db.container:

[Container]
ContainerName=planka-db
Image=docker.io/library/postgres:17-alpine
Pod=planka.pod
Volume=planka-db:/var/lib/postgresql/data
Environment=POSTGRES_USER=planka POSTGRES_DB=planka
Secret=planka-db-password,type=env,target=POSTGRES_PASSWORD
HealthCmd=pg_isready -U planka
HealthInterval=10s
Notify=healthy
AutoUpdate=registry

[Service]
Restart=always
TimeoutStartSec=300

planka-app.container:

[Unit]
Requires=planka-db.service
After=planka-db.service

[Container]
ContainerName=planka-app
Image=ghcr.io/plankanban/planka:2.2.1
Pod=planka.pod
Volume=planka-data:/app/data
Environment=BASE_URL=https://board.example.com TRUST_PROXY=true
Environment=DEFAULT_LANGUAGE=en-US
Secret=planka-db-url,type=env,target=DATABASE_URL
Secret=planka-secret-key,type=env,target=SECRET_KEY
Environment=DEFAULT_ADMIN_EMAIL=you@example.com DEFAULT_ADMIN_NAME=Anna DEFAULT_ADMIN_USERNAME=anna
Secret=planka-admin-password,type=env,target=DEFAULT_ADMIN_PASSWORD
Environment=SMTP_HOST=smtp.example.com SMTP_PORT=587 SMTP_SECURE=false SMTP_USER=planka@example.com
Environment="SMTP_FROM=Planka <planka@example.com>"
Secret=planka-smtp-password,type=env,target=SMTP_PASSWORD

[Service]
Restart=always

Pull both images, run systemctl --user daemon-reload and systemctl --user start planka-pod; it is ready when curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:8126/ prints 200. Sign in as anna with the password from podman secret inspect --showsecret planka-admin-password. Planka keeps the admin named in DEFAULT_ADMIN_EMAIL from being edited or deleted in the app. SMTP_SECURE=false with port 587 means STARTTLS. Attachments go in the planka-data volume.

How we ran Kanboard

Kanboard's Docker documentation uses SQLite by default; the image reads DB_DRIVER and the other database settings from the environment, so we gave it PostgreSQL. As a user kanboard:

openssl rand -hex 24 | tr -d '\n' | podman secret create kanboard-db-password -
printf %s 'your-smtp-password' | podman secret create kanboard-smtp-password -

~/.config/containers/systemd/kanboard.pod:

[Pod]
PodName=kanboard
PublishPort=127.0.0.1:8128:80

[Install]
WantedBy=default.target

kanboard-db.container is the same as planka-db.container above with planka replaced by kanboard everywhere. kanboard-app.container:

[Unit]
Requires=kanboard-db.service
After=kanboard-db.service

[Container]
ContainerName=kanboard-app
Image=docker.io/kanboard/kanboard:v1.2.54
Pod=kanboard.pod
Volume=kanboard-data:/var/www/app/data
Volume=kanboard-plugins:/var/www/app/plugins
Environment=DB_DRIVER=postgres DB_HOSTNAME=127.0.0.1 DB_PORT=5432 DB_NAME=kanboard DB_USERNAME=kanboard
Secret=kanboard-db-password,type=env,target=DB_PASSWORD
Environment=TRUSTED_PROXY_HEADERS=HTTP_X_FORWARDED_FOR TRUSTED_PROXY_NETWORKS=203.0.113.10/32
Environment=MAIL_TRANSPORT=smtp MAIL_SMTP_HOSTNAME=smtp.example.com MAIL_SMTP_PORT=587 MAIL_SMTP_ENCRYPTION=tls
Environment=MAIL_SMTP_USERNAME=kanboard@example.com MAIL_FROM=kanboard@example.com
Secret=kanboard-smtp-password,type=env,target=MAIL_SMTP_PASSWORD

[Service]
Restart=always

TRUSTED_PROXY_NETWORKS is your server's own IPv4 address, 203.0.113.10 here, from which Caddy's connections reach the pod, as the Podman guide explains. Start it as above; it is ready when curl on port 8128 prints 302. Before you add it to Caddy, replace the admin password; the command asks for the new one twice:

podman exec -it kanboard-app php /var/www/app/cli user:reset-password admin

How we ran WeKan

WeKan's Compose files offer MongoDB 7 or FerretDB, which speaks MongoDB's protocol and keeps the data in SQLite, PostgreSQL or others. We used FerretDB with PostgreSQL, from docker-compose-ferretdb-v1-postgresql.yml. Instead of letting a container download FerretDB at every start, we downloaded WeKan's FerretDB build once and checked it. As a user wekan:

mkdir -p ~/ferretdb && cd ~/ferretdb
curl -fsSLO https://github.com/wekan/FerretDB/releases/download/v1.94.0/ferretdb-amd64
curl -fsSLO https://github.com/wekan/FerretDB/releases/download/v1.94.0/ferretdb-amd64.sha256sum
sha256sum -c ferretdb-amd64.sha256sum && mv ferretdb-amd64 ferretdb && chmod +x ferretdb && cd
pw=$(openssl rand -hex 24)
printf %s "$pw" | podman secret create wekan-db-password -
printf %s "postgres://wekan:$pw@127.0.0.1:5432/wekan" | podman secret create wekan-ferretdb-url -
printf %s 'smtp://wekan%40example.com:your-smtp-password@smtp.example.com:587/' | podman secret create wekan-mail-url -

~/.config/containers/systemd/wekan.pod:

[Pod]
PodName=wekan
PublishPort=127.0.0.1:8129:8080

[Install]
WantedBy=default.target

wekan-db.container is again planka-db.container with planka replaced by wekan. wekan-ferretdb.container:

[Unit]
Requires=wekan-db.service
After=wekan-db.service

[Container]
ContainerName=wekan-ferretdb
Image=docker.io/library/debian:trixie-slim
Pod=wekan.pod
Volume=%h/ferretdb:/opt/ferretdb:ro
Entrypoint=/opt/ferretdb/ferretdb
Environment=FERRETDB_HANDLER=postgresql FERRETDB_LISTEN_ADDR=127.0.0.1:27017
Environment=FERRETDB_REPL_SET_NAME=rs0 FERRETDB_TELEMETRY=disable FERRETDB_LOG_LEVEL=error
Secret=wekan-ferretdb-url,type=env,target=FERRETDB_POSTGRESQL_URL
HealthCmd=bash -c '</dev/tcp/127.0.0.1/27017'
HealthInterval=5s
Notify=healthy

[Service]
Restart=always

wekan-app.container:

[Unit]
Requires=wekan-ferretdb.service
After=wekan-ferretdb.service

[Container]
ContainerName=wekan-app
Image=ghcr.io/wekan/wekan:v12.40
Pod=wekan.pod
Volume=wekan-files:/data
Environment=ROOT_URL=https://board.example.com PORT=8080 WRITABLE_PATH=/data
Environment=MONGO_URL=mongodb://127.0.0.1:27017/wekan?directConnection=true
Environment=DEFAULT_METEOR_REACTIVITY_ORDER=polling METEOR_REACTIVITY_ORDER=polling DDP_TRANSPORT=sockjs
Environment=WITH_API=true BROWSER_POLICY_ENABLED=true CARDS_LOADING=auto BIGEVENTS_PATTERN=NONE
Environment="MAIL_FROM=WeKan <wekan@example.com>"
Secret=wekan-mail-url,type=env,target=MAIL_URL
Environment=TZ=Europe/Stockholm
AutoUpdate=registry

[Service]
Restart=always

Start it as above; it is ready when curl on port 8129 prints 200. Before you add it to Caddy, sign up your own account over an SSH tunnel (ssh -L 8129:127.0.0.1:8129 to the server, then http://localhost:8129/sign-up): the first account becomes the admin. Then switch registration off in the Admin Panel; after that, the sign-up page asked for an invitation code. To update FerretDB, download a new release the same way and restart wekan-ferretdb.

For all three, the block in Caddy's ~/Caddyfile, with the port changed per app:

board.example.com {
    reverse_proxy 127.0.0.1:8126
}

To back up, run podman exec planka-db pg_dump -U planka planka > planka-db.sql and podman volume export planka-data > planka-data.tar, with kanboard or wekan and their volumes kanboard-data and wekan-files for the others, and keep the secrets. To restore, stop the app container (and wekan-ferretdb), drop and create the database with dropdb and createdb in the database container, load the dump with psql, import the volume with podman volume import and start the containers again.

Licence and cost

We read the licence texts and pricing pages on 14 October 2026.

• Planka is made by PLANKA Software GmbH in Germany. The Community Edition is under the PLANKA Fair Use License, a "fair-code" licence that is not open source: you may use it free of charge for personal use and "internally within your own organization", but running it as a service for others, or sharing it across organisations, for commercial gain needs a commercial licence. The pricing page lists Pro Self-Hosted at 7.20 euros per user a month billed yearly, or 7.90 monthly, for at least one user, with five guests per user. Pro adds the phone layout, themes, a dashboard, calendar, timeline and map views, recurring cards, card and board templates, worker and guest roles, OpenID Connect single sign-on, PDF and HTML export and support; Planka says the upgrade from Community is one-way. Enterprise starts at 1,000 self-hosted users.
• Kanboard is open source under the MIT licence, by Frédéric Guillot and contributors. There is no paid edition and no company selling support.
• WeKan is open source under the MIT licence, maintained by Lauri Ojansivu in Finland, who says on the commercial support page that "There is no proprietary code." Paid support is 100 euros an hour or per support case, and WeKan's own cloud 50 euros a year.

For a company running boards for its own staff, all three allow it at no cost, and on your own server the boards stay in Sweden.

Trello today

What follows is from Atlassian's own pages, read on 14 October 2026, not from our tests.

Trello is cloud only. Its pricing page says: "Trello is proudly a cloud-only product." It lists:

• Free: up to 10 collaborators and 10 boards per Workspace, files up to 10 MB, 250 automation command runs a month per Workspace, unlimited Power-Ups, and the iOS and Android apps;
• Standard: 5 US dollars per user a month billed yearly, 6 monthly, with unlimited boards, files up to 250 MB, 1,000 command runs and single-board guests;
• Premium: 10 dollars billed yearly, 12.50 monthly, adding calendar, timeline, table, dashboard and map views, unlimited command runs, Workspace templates, read-only Observers and "Simple data export";
• Enterprise: 17.50 dollars per user a month billed yearly, with Atlassian Guard included. On the other plans, SAML single sign-on needs Atlassian Guard, "a separate subscription" that "starts at $4/month/user".

Trello's export documentation says "All board members can export a board to raw JSON format"; CSV export of a board needs a Premium Workspace, and exporting all boards at once needs Premium and a Workspace admin. Exports link to attachments on Trello, unless you include the raw attachments in a Workspace export. Trello is not among the products on Atlassian's data residency page, which names Jira, Jira Service Management, Jira Product Discovery, Loom and Confluence.

What you give up compared with Trello

Moving to your own server keeps the boards in Sweden and costs a fixed server price instead of a price per user. But be honest about what you leave behind:

• The Power-Up directory and integrations. Trello connects to Slack, Google Drive, Jira and hundreds of other services with a click. Here you have webhooks, APIs, Kanboard's plugins and Planka's Apprise notifications, and scripts of your own.
• Butler-style automation in Planka. Kanboard's actions and WeKan's rules cover common cases, but Planka has none.
• Polished phone apps. Trello's apps come with every plan. Here only WeKan has a phone layout for free; Planka's is in Pro, and none has an app for your own server.
• Views. Trello Premium has calendar, timeline, table, dashboard and map views. Planka keeps them for Pro, Kanboard has a list view and plugins for a calendar and Gantt charts, and WeKan has a calendar.
• A clean move. Planka and WeKan import a Trello JSON export for free, WeKan the most faithfully in our test, but attachments stay behind on trello.com.
• AI. Trello's paid plans include AI features, according to its pricing page. None of the three has any.
• Running it. Updates, backups and the server are yours, and you need a working email account for notifications.

Which one to pick

A team that wants Trello without Trello: Planka. It looks and feels the closest, updates live in under a second, emails card members out of the box and imported our Trello board well, in about 100 MB and 3% of a core at rest. Its weak points are a licence that is not open source and limits hosting for others, no automation at all, templates, exports, single sign-on and a phone layout only in paid Pro, and a Trello import that drops card members and attachments. Run it with the files in How we ran Planka, on top of the Podman guide.

A small team that wants something light that just runs: Kanboard. It is the smallest, at 20 MB, has 43 automatic actions, project duplication, CSV exports, custom roles, LDAP and a JSON-RPC API, all free under MIT. Its weak points are no Trello import, one assignee per task, a board that refreshes every 10 seconds instead of live, notifications every user must switch on, no phone layout, and an author who adds no new major features. The files are in How we ran Kanboard.

The most features for free: WeKan, with care. Rules, templates, many board roles, single sign-on with OpenID Connect, LDAP or SAML, a phone layout, exports in many formats and the most faithful Trello import, all under MIT. Its weak points are almost a whole core of processor at rest in our setup, the most memory and disk of the three, a busy interface, a release pace of several versions a day, and outgoing webhooks that locked out two of our users. The files are in How we ran WeKan.

All three together peaked under 1 GB of memory, so any of them fits on a VC-P Alloy with plenty of room for other apps, as on our test server; WeKan is the one that keeps its processors busy. If your team needs sprints, a backlog or Gantt charts rather than a board, read the Jira alternatives.