What is the best self-hosted software?
Best self-hosted software for a developer's web stack: deploy, analytics, newsletters, comments, search, backend, monitoring and backups compared.
For a developer's web stack, the sensible defaults are Coolify to deploy things, Umami or Plausible Community Edition for analytics, listmonk for newsletters, Remark42 for comments, Meilisearch for search, PocketBase or Supabase for a backend, Uptime Kuma for monitoring and restic for backups. None of those is "the best" in a vacuum, though. Each one wins on a specific constraint (RAM, licence, the database you already run), and the right pick is the one whose failure you're willing to debug at 11pm.
Disclosure: I work on VeloCMS, a managed SaaS that can't be self-hosted, so it isn't a pick in any category below. It shows up once, in the section on when you shouldn't self-host at all.
Last verified: 2026-11-15.
I read each project's own docs, README or GitHub licence metadata on that date. I didn't benchmark anything, and I haven't installed all of these side by side, so where a number isn't on a vendor page I've left it out. Licences and requirements change, and a few of these projects ship often, so open the linked page before you commit a server to anything.
What does "best" mean for self-hosted software?
Free to download isn't free to run. Every tool here costs you a server slice, a reverse proxy with TLS, backups you've restored at least once, and a habit of reading changelogs. So I scored each category on four things: how heavy the runtime is, whether the licence lets you do what you actually plan to do, how painful upgrades are likely to be, and what happens to your data if the project stalls.
That last one deserves a sentence of its own. A self-hosted tool with a clean export and a boring storage format (a Postgres database, a SQLite file) is a smaller bet than one that stores data in a format only it understands. Keep that in mind while you read the picks, because it comes up again with PocketBase.
What is the best self-hosted deploy platform?
If you want a Heroku-shaped workflow on a box you rent, there are three serious open-source options, and they differ more in philosophy than in features.
Coolify is the one with a web dashboard. It connects to your servers over SSH and deploys applications from a Git repository, a Dockerfile, a Docker Compose file or a prebuilt image, plus databases and one-click services from maintained Compose templates. The licence is Apache-2.0 (repo), and the install docs ask for 2 CPU cores, 2 GB of RAM and 10 GB of disk, on Linux only. One warning from those same docs is worth taking seriously: if builds and Coolify share a server, a heavy build can make the box unresponsive. There's also a hosted Coolify Cloud, but it only manages the control plane. You still run your own servers.
Dokku is the minimalist. You deploy with a git push, and Dokku builds from a Dockerfile or detects your language and applies buildpacks. It's MIT-licensed (repo) and supports Ubuntu 22.04, 24.04 and 26.04 or Debian 11+, on amd64 and arm64. Memory needs are modest: 1 GB for the default Docker scheduler (or add swap), 2 GB per node if you choose the K3s scheduler.
CapRover sits in between, with a web UI and one-click apps. It wants an AMD64 or ARM64 server with a public IPv4 address, at least 1 GiB of RAM and 5 GiB of free disk, and open ports 80, 443 and 3000. Read its licence before you adopt it, though. The LICENSE file is Apache 2.0 plus an appendix that bars modifying the paid features of CapRover-as-a-service and requires modifications of the free features to be distributed as free and open-source software. For most people running their own sites that changes nothing. If you plan to fork it, it matters.
My pick: Coolify for most developers who want a dashboard, Dokku if you live in a terminal and want the smallest footprint.
What is the best self-hosted web analytics tool?
This is the category where self-hosting makes the most sense, because analytics scripts are the thing visitors (and privacy regulators) care about most.
Umami is the lightest to operate. It's MIT-licensed, needs Node.js 20.19 or newer (22 LTS recommended) and PostgreSQL 12.14 or newer, and describes itself as privacy-first analytics with no cookies. The project provides Docker images and a Compose file that runs Umami next to Postgres, so a first install is a short job. The README doesn't make scale promises, and I won't either.
Plausible Community Edition is built from the same code base as Plausible's cloud service (AGPL-3.0, per the main repository) but the self-hosted release lags. Plausible says CE is published twice a year, while the cloud ships several times a week. Funnels, user journeys, ecommerce revenue goals, SSO and the sites API are cloud-only, bot filtering is more basic, and support is community-only. The install repository lists a CPU with SSE 4.2 or NEON (ClickHouse needs it) and recommends 2 GB of RAM at least. You're running ClickHouse alongside the app, which is heavier than Umami's single Postgres.
Matomo On-Premise is the PHP option, licensed GPL v3 or later (repo). Matomo 6 needs PHP 8.1+ and MySQL 8.0+ or MariaDB 10.6+, and its own guidance for up to 100,000 page views a month is 2 CPUs, 2 GB of RAM and a 50 GB SSD. Support comes from the community forum or from paid support plans. It suits a team that already runs a LAMP stack and wants to keep it that way.
My pick: Umami if you want the least to operate, Plausible CE if you like its reports and can live with the older feature set, Matomo if PHP and MySQL are home.
What is the best self-hosted newsletter tool?
Newsletter software separates the part you can self-host (lists, templates, campaigns) from the part you can't really (getting mail into inboxes). Keep that split in mind.
listmonk is a single Go binary that runs next to a PostgreSQL database, licensed AGPL-3.0 (repo). It sends through SMTP with multi-queue rate limiting, lets you segment subscribers with SQL expressions, supports Go templating and a visual email builder, and exposes a transactional API plus scoped API tokens. For developers who want to script their list, it's the obvious starting point.
Keila is the Elixir alternative, also AGPL-3.0 (repo). It ships an official Docker image and can send through SMTP, AWS SES, Mailgun, Postmark or SendGrid. It has a form builder with double opt-in and captcha, segmentation, an API, and automatic bounce and complaint handling. There's a hosted Keila Cloud too if you'd rather not run it.
Both need a real sending provider behind them, which is where the hidden cost sits. I come back to that in the "when not to self-host" section.
My pick: listmonk if you're comfortable with Postgres and templates written by hand, Keila if you want built-in form handling and bounce processing.
What is the best self-hosted comment system?
Here I'd split the answer in two, because the best option depends on whether your readers are developers.
Remark42 is the all-rounder: MIT-licensed (repo), written in Go, and described as having no tracking of any sort. Readers can sign in with social accounts (Google, GitHub, Apple, Telegram and others, or a custom OAuth2 provider) or by email, with optional anonymous access. It imports from Disqus and WordPress, notifies admins by Telegram, Slack, email or webhook, and keeps everything in a single embedded data file, so there's no separate database to run.
Isso is the smaller, quieter choice. It's a Python server with a SQLite backend, Markdown comments and Disqus and WordPress import, under an MIT licence (repo). Its JavaScript client is a single file. Its feature list is shorter than Remark42's, which for some sites is the point.
giscus is the contrast case. It's open source (MIT, repo), has no tracking or ads, and stores every comment in GitHub Discussions. The app can be self-hosted, but your comments still live on GitHub, and readers either authorize the giscus app through GitHub or comment directly on the GitHub Discussion. For a developer blog that's a feature: zero database, zero moderation backend. For a general audience it's a wall.
My pick: Remark42 for most sites, giscus when every reader already has a GitHub account.
What is the best self-hosted site search?
Two engines dominate, and the licence story differs more than the speed.
Meilisearch installs with one curl line and starts as a single executable. Its Community Edition is MIT, free for anyone including commercial use. A separate Enterprise Edition (commercial or BSL 1.1) covers features such as sharding and S3-streaming snapshots and isn't allowed in production without a commercial agreement, according to the licensing section of the repository README. The self-hosting docs also say a master key is mandatory in production, which is an easy thing to forget in a Compose file.
Typesense is GPL-3.0 (repo) and installs through an official Docker image or DEB and RPM packages. The thing to plan for is memory: it's an in-memory datastore, and its system requirements say keyword search typically needs 2X to 3X MB of RAM, where X is the size of the fields you search, with at least 2 vCPUs. It also has a clustered mode for high availability.
My pick: Meilisearch for a typical site search on a small VPS, Typesense when you want clustering and your index comfortably fits in RAM.
What is the best self-hosted backend for forms and app data?
This category covers "I need auth, a database and an API, and I don't want to write them." It's also the one where the trade-offs are least obvious.
PocketBase is the lightest thing here: an open-source backend on an embedded SQLite database with realtime subscriptions, built-in auth, file storage and an admin dashboard at /_/. You download an executable and run ./pocketbase serve. It's MIT-licensed. Two cautions, both from PocketBase's own material. The docs state that full backward compatibility isn't guaranteed before v1.0.0 and that it's "NOT recommended for production critical applications yet." And the GitHub repository was archived by its owner on 26 October 2026, with a README note that the repo has moved. The project site now links its Git repository to the author's own domain, and when I tried it, that page was rendered by JavaScript, so I couldn't read the repository contents without a browser. Check it yourself before you rely on a download path.
Supabase is Apache-2.0 (repo) and the opposite in weight. The Docker stack runs Studio, an API gateway, Auth, PostgREST, Realtime, Storage, Postgres and more, with a 4 GB RAM minimum (8 GB+ recommended), 2 CPU cores and a 40 GB SSD. The guide says you should never run it with the default placeholder passwords and keys, and it recommends the managed platform if you're new to Linux administration, Docker or networking.
Appwrite is BSD-3-Clause (repo) and sits between the two. It needs 2 CPU cores, 4 GB of RAM and 2 GB of swap with Docker Compose v2, and provides Auth, Databases, Storage, Functions, Messaging and Sites. The docs say self-hosted instances can use the same features as Appwrite Cloud.
My pick: PocketBase for a side project where you can tolerate churn, Supabase if you want real Postgres underneath and have the RAM, Appwrite if you'd rather have one bundled platform that runs under Docker Compose.
What is the best self-hosted uptime monitor?
Uptime Kuma wins this category by default, and I don't say that lightly. It's MIT-licensed and watches HTTP(S), TCP, keyword and JSON-query checks, plus WebSocket, ping, DNS, push monitors and Docker containers, with 20-second check intervals. The README advertises 90+ notification services and multiple status pages that you can map to your own domains. Running it is one docker run command on port 3001, or Node.js 20.4+ and pm2 if you'd rather skip Docker.
The one design advice I'd add is mine, not the README's: don't host your monitor on the same server it's watching. A tool that goes down with the thing it monitors tells you nothing at the moment you need it.
What is the best self-hosted backup tool?
Two tools get recommended in nearly every thread, and they're close.
restic is a single executable under the BSD 2-Clause licence (repo) that encrypts its backups and lets you verify that they can be restored. It runs on Linux, BSD, macOS and Windows, and its docs list repository backends including local disk, SFTP, a REST server, Amazon S3, S3-compatible storage, Backblaze B2, Azure Blob Storage, Google Cloud Storage and anything rclone can reach.
BorgBackup is BSD-licensed and stores data as content-defined chunks, so identical chunks are kept once across files, machines and time. You choose compression (lz4, zstd, zlib, lzma or none), it uses authenticated AES encryption, and a repository can sit on any machine you can reach over SSH. Its page says your backup server never needs to be trusted.
My pick: restic if you want to push to object storage without running a server, Borg if your destination is an SSH box and you care about deduplication across many machines. Whichever you choose, restore a file from it this week. A backup you've never restored is a hope.
Which self-hosted CMS should you pick?
I'll keep this short on purpose, because Which self-hosted CMS is the best? compares ten of them in detail. The one-paragraph version: Ghost is MIT-licensed and built for publishing, memberships and newsletters. WordPress is GPL v2 or later and has the biggest plugin ecosystem, along with the biggest patching surface. Payload is MIT and a fullstack Next.js framework that doubles as a headless CMS. Directus uses the source-available Monospace Sustainable Core License, free for organizations under $5M in annual revenue and 50 employees, and needs a commercial licence above that if you use advanced or enterprise features.
When should you not self-host?
Be honest about three costs.
The first is ops time. Every tool above is one more thing to upgrade, and the upgrades aren't synchronized. Plausible CE tells you outright that self-hosting is "infrastructure you maintain, not software you install once." Multiply that by six or seven tools and you've got a part-time job.
The second is security patching. A public-facing service with a stale dependency is a classic way in, and Supabase's own guide warns you never to run it on the placeholder passwords and keys from .env.example. If nobody owns the patch schedule, the box rots.
The third is email. Self-hosting listmonk or Keila gets you a mailing list, not inbox placement. Google's sender guidelines require bulk senders (more than 5,000 messages a day to Gmail addresses) to set up SPF, DKIM and DMARC, support one-click unsubscribe, and keep the spam rate reported in Postmaster Tools under 0.30%. A reputable SMTP provider handles that infrastructure for you, and at that point you're paying a hosted vendor anyway.
If you'd rather rent the publishing stack than assemble it, hosted options exist: Ghost(Pro), WordPress.com and VeloCMS among them. VeloCMS is a hosted blog CMS with a newsletter, memberships and a store in one admin. Its pricing page lists Pro at $9 a month, Business at $29 and Agency at $69, with annual billing 20% cheaper. Every plan starts with a 14-day trial, a card is required unless you have a cardless trial code, and there's no free plan. Its weaknesses are plain ones: you don't own the server, you can't self-host it, it's a young product, and its plugin ecosystem is far smaller than WordPress's.
Who is each option best for?
- Coolify: developers who want a dashboard over their own servers and can accept an actively developed Apache-2.0 PaaS.
- Dokku: terminal people who want
git pushdeploys on a single small box. - CapRover: people who want a UI and one-click apps and have read the licence appendix.
- Umami: anyone who wants analytics with the fewest moving parts (Node and Postgres).
- Plausible CE: teams that like Plausible's reports and can live with twice-yearly releases and community support.
- Matomo: teams already on PHP and MySQL who want a mature self-hosted analytics suite.
- listmonk: developers who want a scriptable list manager and already run Postgres.
- Keila: people who want forms, double opt-in and bounce handling out of the box.
- Remark42: most blogs that want comments without a database.
- Isso: small sites that want the simplest possible comment server.
- giscus: developer blogs where readers already have GitHub accounts.
- Meilisearch: small-to-medium site search where MIT Community Edition is enough.
- Typesense: search that needs clustering and fits in memory.
- PocketBase: prototypes and small apps where a single executable matters more than long-term API stability.
- Supabase: teams that want Postgres, auth and storage and have 4 GB+ of RAM to spare.
- Appwrite: teams that want an all-in-one backend platform under Docker.
- Uptime Kuma: everyone, on a different server from the thing it watches.
- restic / Borg: everyone who has data. Pick by destination: object storage or SSH.
- VeloCMS: someone who has decided not to run servers and wants blog, newsletter and membership in one hosted login.
When is VeloCMS the wrong choice?
Skip it if you need to self-host for compliance, data residency or because you want a licence you can read in full. It isn't offered as self-hosted software right now. Skip it too if you depend on a specific WordPress plugin, or if you want your entire stack on a server you control. It's also still a young product, so if you need a decade of third-party tutorials, you'll find more of those for WordPress or Ghost.
FAQ
Is self-hosted software really free? The licence cost is often zero, but servers, backups, your time and sending infrastructure aren't. Plausible's own page describes CE as software you maintain, not install once.
What's the cheapest self-hosted stack that's still sensible? Dokku as the deploy layer (1 GB of RAM for its Docker scheduler), then Umami (Node plus Postgres), Remark42 (one embedded data file) and Uptime Kuma on top, with restic pushing backups to object storage. Those are the ones with the least to run, but I haven't measured the combined footprint, so leave headroom.
Can I mix tools from different categories? Yes, and most people do. Just be aware that each one has its own upgrade cycle, so keep a short list of what runs where.
Should I self-host Supabase or use the hosted version? Supabase's own guide suggests starting on the managed platform if you're new to Linux administration, Docker or networking, and it needs at least 4 GB of RAM to self-host.
Is PocketBase safe to depend on? It's MIT-licensed and small, which keeps your exit cost low. But its docs warn against production-critical use before v1.0.0, and its GitHub repository was archived in October 2026, so read its current status before you build on it.
Is there a free VeloCMS plan? No. There's a 14-day trial (card required unless you have a cardless trial code, first charge on day 15), then plans from $9 a month (pricing).
Last verified
2026-11-15. Licences and requirements come from each project's own README, docs or GitHub licence metadata read that day. VeloCMS prices are from velocms.org/pricing.
Sources
- Coolify: https://coolify.io/docs/get-started/introduction, https://coolify.io/docs/get-started/installation, https://github.com/coollabsio/coolify
- Dokku: https://dokku.com/docs/getting-started/installation/, https://github.com/dokku/dokku
- CapRover: https://caprover.com/docs/get-started.html, https://github.com/caprover/caprover/blob/master/LICENSE
- Plausible: https://plausible.io/self-hosted-web-analytics, https://github.com/plausible/community-edition, https://github.com/plausible/analytics
- Umami: https://github.com/umami-software/umami
- Matomo: https://matomo.org/faq/on-premise/matomo-requirements/, https://github.com/matomo-org/matomo
- listmonk: https://listmonk.app/, https://github.com/knadh/listmonk
- Keila: https://www.keila.io/, https://github.com/pentacent/keila
- Remark42: https://remark42.com/, https://github.com/umputun/remark42
- Isso: https://isso-comments.de/, https://github.com/isso-comments/isso
- giscus: https://giscus.app/, https://github.com/giscus/giscus
- Meilisearch: https://www.meilisearch.com/docs/learn/self_hosted/getting_started_with_self_hosted_meilisearch, https://github.com/meilisearch/meilisearch
- Typesense: https://typesense.org/docs/guide/install-typesense.html, https://typesense.org/docs/guide/system-requirements.html, https://github.com/typesense/typesense
- PocketBase: https://pocketbase.io/docs/, https://github.com/pocketbase/pocketbase
- Supabase: https://supabase.com/docs/guides/self-hosting/docker, https://github.com/supabase/supabase
- Appwrite: https://appwrite.io/docs/advanced/self-hosting, https://appwrite.io/docs/advanced/self-hosting/installation, https://github.com/appwrite/appwrite
- Uptime Kuma: https://github.com/louislam/uptime-kuma
- restic: https://restic.net/, https://restic.readthedocs.io/en/stable/030_preparing_a_new_repo.html, https://github.com/restic/restic
- BorgBackup: https://www.borgbackup.org/
- Matomo community forum: https://forum.matomo.org/
- Ghost: https://github.com/TryGhost/Ghost
- WordPress: https://wordpress.org/about/license/
- Payload: https://github.com/payloadcms/payload
- Directus: https://github.com/directus/directus
- Google bulk sender guidelines: https://support.google.com/a/answer/81126
- VeloCMS pricing: https://velocms.org/pricing
About the author
- Building VeloCMS.org , A fast multilingual CMS for blogs and online stores. I write about headless CMS, Next.js, SEO and moving off WordPress and Shopify.
Comments
Join the discussionNo comments yet. Be the first to comment.