Deploy Planka — Self-Hosted Kanban & Trello Alternative

Deploy and Host Planka on Railway

Planka is the open-source Trello alternative — a fast, real-time Kanban board for project management, with boards, lists, cards, labels, due dates, checklists, attachments, and live collaboration, all self-hosted so your team's data stays yours. It does one thing exceptionally well: clean, responsive visual task boards without the subscription or per-seat fees. This template deploys Planka with PostgreSQL and a persistent volume pre-wired, with the secret key and admin account configured, so your team is planning work in minutes.

What This Template Deploys

Both connect over Railway's private network. A persistent volume at /app/data holds file attachments and images, and Postgres holds all board data — so nothing is lost on redeploy.

About Hosting

Planka is lightweight and simple, but three specifics decide whether it starts cleanly and behaves on redeploys — all handled here.

SECRET_KEY must be a long random value or Planka won't start. Planka signs sessions with SECRET_KEY, and if it's missing or too short the container exits immediately with a secret-key error. It needs at least 32 characters (64-hex from openssl rand -hex 64 is standard). This template generates a strong key, so it boots on the first try — and you should keep it stable, since changing it invalidates active sessions.

The admin account re-applies on every boot — know this before you change it. Planka creates its admin from the DEFAULT_ADMIN_* variables, and it re-applies them on every restart. So if you change the admin password in the UI, it's overwritten on the next redeploy. The clean pattern: log in with the seeded credentials, and to permanently change them, update the environment variables (or remove them after first boot and manage the account in the UI). This template sets sensible defaults you can change in your Railway variables.

Attachments and board data persist separately. Card attachments, avatars, and background images live on the volume at /app/data, while boards, cards, and comments live in PostgreSQL. Both persist across redeploys, so your work is safe — the volume grows with uploads, so monitor it if your team attaches large files often.

BASE_URL and TRUST_PROXY matter behind Railway. BASE_URL must be your Railway public domain so links and real-time connections resolve, and TRUST_PROXY=true tells Planka it's behind Railway's edge proxy, which matters for correct client addresses and secure cookies.

SSO-ready and real-time. Planka supports OpenID Connect, so you can wire it to Google, Azure AD, Okta, Authentik, or Keycloak with the OIDC_* variables. Its real-time sync runs over WebSockets, which Railway supports out of the box, so board changes appear live for everyone.

Typical cost: ~$5/month on Railway — Planka is remarkably light (~80 MB idle), handling 20–50 concurrent users on a small instance. It's MIT-licensed and free, with no per-seat fees.

How It Compares

Trello is polished but bills per user and holds your data. Jira is powerful but heavy — more than most teams need. Wekan is another self-hosted Kanban option but heavier. Planka's edge is doing Kanban cleanly and fast in a tiny footprint — the Trello experience self-hosted at flat cost, with your data on infrastructure you own. If you need Gantt charts or sprint reporting, a heavier tool fits; for visual task boards, Planka is ideal.

Deploy in Under 5 Minutes

1. Click Deploy on Railway — Planka and PostgreSQL build and wire together (~3 minutes)
2. Confirm SECRET_KEY is set and DATABASE_URL references your Postgres service
3. Generate a domain and set BASE_URL to it, with TRUST_PROXY=true
4. Open your Railway domain and log in with the DEFAULT_ADMIN_* credentials
5. Create your first project and board, and invite your team

To change admin credentials permanently, update the DEFAULT_ADMIN_* variables rather than only the UI.

Common Use Cases

• Team task boards — visual Kanban for tracking work across a team, self-hosted and private
• Project management — organize projects into boards with lists, cards, labels, and due dates
• Trello replacement — the same board experience without per-user fees or vendor lock-in
• Personal productivity — a fast, private board for your own tasks and planning
• Agile-lite workflows — lightweight card-based tracking without the weight of full project tools

Configuration

Set a long SECRET_KEY and keep it stable. Planka won't start without a sufficiently long key, and changing it invalidates sessions. This template generates one for you.

Admin credentials re-apply on every boot. DEFAULT_ADMIN_* are re-applied on each restart, so UI password changes get overwritten — change the environment variables to update admin credentials permanently.

Dependencies for Planka Hosting

• Railway account — ~$5/month for the app and Postgres
• PostgreSQL (included and wired in this template)
• A persistent volume at /app/data for attachments and images (included)
• Optional: an OIDC provider (Google, Azure AD, Okta, Authentik, Keycloak) for SSO

Deployment Dependencies

• Planka GitHub Repository
• Planka Documentation
• Planka Docker Image
• Railway Private Networking

Implementation Details

The template runs the official ghcr.io/plankanban/planka image on port 1337 alongside a Railway PostgreSQL service, connected over the private network with only Planka exposed. Planka is a React and Node.js application that requires SECRET_KEY (at least 32 characters) to sign sessions, and the container exits immediately if it's missing — the template generates a strong key that must remain stable across redeploys.

The admin account is created from DEFAULT_ADMIN_EMAIL, DEFAULT_ADMIN_PASSWORD, DEFAULT_ADMIN_USERNAME, and DEFAULT_ADMIN_NAME, which Planka re-applies on every boot; consequently, admin credential changes should be made through the environment variables rather than only the UI, since UI changes are overwritten on the next restart. BASE_URL is set to the Railway domain and TRUST_PROXY=true so Planka correctly handles being behind Railway's edge proxy for real-time WebSocket connections and secure cookies.

File attachments, avatars, and background images persist on the volume mounted at /app/data, while all board and card data persists in PostgreSQL — both survive redeploys, and both should be backed up. Planka supports OpenID Connect via OIDC_* variables for SSO with standard identity providers.

Frequently Asked Questions

Why does the container exit immediately? Almost always a missing or too-short SECRET_KEY — Planka needs at least 32 characters to sign sessions and won't start without one. This template generates a strong key, so it boots correctly.

Why did my admin password reset after a redeploy? Planka re-applies the DEFAULT_ADMIN_* variables on every boot, overwriting UI changes. To change admin credentials permanently, update those environment variables in Railway.

Do my boards and attachments persist? Yes. Boards, cards, and comments live in PostgreSQL, and attachments and images on the /app/data volume — both survive redeploys. Back up both to preserve everything.

Can I use SSO? Yes. Planka supports OpenID Connect, so you can connect Google, Azure AD, Okta, Authentik, or Keycloak with the OIDC_* variables.

Does real-time collaboration work on Railway? Yes — Planka's live sync runs over WebSockets, which Railway supports, so board changes appear instantly for everyone with TRUST_PROXY=true and the correct BASE_URL.

How many users can it handle? Planka is very light (~80 MB idle), comfortably handling 20–50 concurrent users on a small Railway instance. Increase RAM for larger teams; Postgres is the main scaling factor.

Why Deploy Planka on Railway?

Railway is a singular platform to deploy your infrastructure stack. Railway will host your infrastructure so you don't have to deal with configuration, while allowing you to vertically and horizontally scale it.

By deploying Planka on Railway you get a fast, self-hosted Kanban board with the essentials handled — PostgreSQL wired, a persistent volume for attachments, a valid secret key so it starts, and the proxy and admin settings correct. Real-time project management, Trello-style, on infrastructure you own.