Forget the 300-App List: The Self-Hosting Starter Stack Actually Worth Running Long-Term

Ask "what should I self-host?" anywhere and you'll get pointed at one of the giant awesome-self-hosted lists — three hundred apps across forty categories. It's genuinely impressive, and it's exactly the wrong tool for a beginner. A list of everything you can run answers a question nobody actually has. The real question, the one experienced self-hosters wish they'd asked first, is narrower and much more useful:

What's still running, and still worth running, a year from now?

Because here's what the lists don't tell you: most apps people enthusiastically deploy in month one are dead by month three. Not because they broke — because nobody used them, and they quietly became maintenance debt. The skill in self-hosting isn't deploying things. It's choosing the few things that earn their keep.

The test that matters: would you miss it?

Before any app earns a permanent spot, it has to pass a simple filter: if it disappeared tomorrow, would you actually feel it? Most "cool, I'll self-host that" apps fail this. The ones that pass tend to share three traits:

• You'd use it weekly or more — it's woven into a real routine, not a novelty you opened twice.
• It replaces something you were paying for or trusting to a third party — so it earns its maintenance cost back in money or control.
• It's low-maintenance — it doesn't need babysitting, constant updates, or hand-holding to stay healthy.

That third trait is the one beginners underweight and veterans obsess over. Every app you run is a small ongoing tax: updates, backups, the occasional 2am "why is this down." A stack of fifteen half-used apps isn't a rich homelab — it's fifteen liabilities. The goal is the smallest set that delivers the most value, because every app you don't run is one you never have to maintain.

A starter stack that survives the year

Rather than a category dump, here's a small set of self-hosted apps that consistently survive the would-you-miss-it test — useful from day one, and still running a year later:

• A password manager (Vaultwarden). High daily use, replaces a paid subscription, and centralizes something you genuinely depend on. Almost everyone who self-hosts this keeps it.
• A file sync / cloud drive (Nextcloud, or Syncthing for pure sync). Replaces Dropbox/Google Drive, used constantly, and the privacy win is real. Nextcloud does more; Syncthing is lighter if you only want files to follow you around.
• A media server (Jellyfin). If you have a media library, this is among the highest-satisfaction self-hosts there is — and it removes a subscription. (More on the Plex-to-Jellyfin move in our media-server migration guide.)
• A read-it-later / bookmarks tool (Linkding, Wallabag). Tiny footprint, near-zero maintenance, used often. A great confidence-builder early on.
• A monitoring / uptime tool (Uptime Kuma). The one "boring" pick that pays for itself the first time it tells you something's down before your users do. Once you run anything you care about, you want this.

That's five. Not three hundred. You can add to it deliberately as real needs appear — but starting here means everything you run is something you'll actually use, which is the only way a homelab stays alive instead of rotting into abandoned containers.

Make maintenance a first-class decision

The reason these lists lead people astray is that they present deployment as the whole game, when deployment is the easy 10%. The 90% is keeping things running — and that cost scales with the number of apps, not their usefulness. Two practices keep the stack healthy:

• Run a regular health check. A monthly pass over updates, backups, and disk space catches the slow rot before it becomes an outage. Our monthly homelab health checklist is built for exactly this.
• Back up the data that matters. Vaultwarden and Nextcloud data, especially. An app you can redeploy in five minutes isn't the risk; the data inside it is.

Where ServerCompass fits

The friction that makes people over-deploy and then abandon is that each app is its own little setup project — Docker, reverse proxy, SSL, networking — so they either avoid the good apps or accumulate a mess of half-configured ones. ServerCompass collapses that into one-click deploys with the proxy, SSL, and networking handled, so adding (or removing) an app is a deliberate, low-cost decision rather than a weekend commitment. When deployment is cheap and clean, you're free to keep the stack small on purpose instead of small by exhaustion. Browse the self-hostable app catalog when you're ready to grow it.

The takeaway

The giant app lists answer "what's possible," but possible was never your constraint — maintenance was. The self-hosters who are still happy a year in didn't run the most apps; they ran the right few and resisted the rest. Start with a small stack of things you'd genuinely miss, treat every addition as a maintenance commitment, and let the catalog be a menu you order from deliberately — not a checklist you try to finish.