An honest look at the MIT-licensed per-user homepage builder for self-hosters who manage services for more than just themselves.

TL;DR

What it is: MIT-licensed self-hosted dashboard that serves a different homepage to each user based on their group memberships — the only tool in this category that’s genuinely designed for multi-tenant self-hosted setups from the start [1].
Who it’s for: Homelabbers and small-org sysadmins who run services for a household, a team, or a small business and are tired of either sharing one cluttered bookmark page or managing separate instances per person.
Cost: $0 software, ~$5–10/mo VPS, free API keys from OpenWeatherMap and Unsplash for the weather and background features [1].
Key strength: Per-user dashboards defined by the admin — users see only what their groups permit. No other single-container dashboard tool handles this cleanly.
Key weakness: 110 GitHub stars puts it firmly in niche territory. The auth setup requires a functioning reverse proxy with forward auth (Authelia or equivalent) which is a non-trivial prerequisite. No SaaS fallback, no hosted demo beyond a single-user local trial [1].

What is Hubleys

Hubleys is a self-hosted dashboard — the kind of start page that shows links to your self-hosted services, a search bar, weather, and a clock. The GitHub description calls it “Brave New Dashboard,” which is doing a lot of work for what is actually a well-scoped tool with a clear purpose: separate dashboards per user, all content defined by the admin [1].

That last part is the product. Most homepage tools (Homarr, Homepage, Heimdall) give you one dashboard. You configure it, you use it. If you want your partner, kids, or coworkers to have access to the same self-hosted Plex/Jellyfin/Nextcloud setup but with different tiles — maybe they shouldn’t see the router admin, the SSH gateway, or the homelab monitoring — you’re stuck duct-taping user accounts or running parallel instances. Hubleys solves this by reading group membership from your identity provider (via forward auth headers) and showing each user the tiles their groups are allowed to see [1].

The architecture is intentionally simple: Hubleys doesn’t handle authentication itself. It sits behind a reverse proxy (typically Caddy or nginx) that forwards three headers — Remote-User, Remote-Groups, Remote-Name — populated by an auth provider like Authelia. Hubleys reads these and renders the appropriate dashboard. No user database to manage, no separate login page [1].

The project has 110 GitHub stars and is maintained by a single developer (knrdl) under the MIT license. It’s a small project. That’s not a dismissal — it’s a calibration point for what you’re getting: focused, functional, not backed by a company, not going to add enterprise features on a roadmap.

Why people choose it

Independent third-party reviews of Hubleys are essentially nonexistent — the project’s niche size and GitHub star count reflect that it spreads via word-of-mouth in self-hosted communities (r/selfhosted, r/homelab) rather than through tech press coverage. This review is based on the README, the default configuration, and the gap it fills against the existing dashboard landscape.

The reason people land on Hubleys is almost always the same: they’re running a homelab or small team setup, they’ve tried Homarr or Homepage, and they hit the wall where everyone shares one dashboard or you’re maintaining three separate instances. The README opens with exactly this: “So you run a bunch of self-hosted services for multiple users but are tired of handing out links?” [1]

That specificity is what separates it. Organizr tried to solve this with a tab-based approach that became increasingly complex. Heimdall is single-user by design. Homepage (gethomepage.dev) has a powerful widget system but no per-user permission model. Hubleys does one thing differently and does it cleanly.

Features

Dashboard engine:

Link tiles organized into folders, per-user visibility controlled by admin config [1]
Search engines with autocomplete [1]
Upcoming calendar events widget [1]
Admin-broadcast messages visible to specific users or groups [1]
Customizable backgrounds: Unsplash (free API key required), uploaded wallpapers, or a local wallpaper collection from a mounted folder [1]
Current weather and multi-day forecast (OpenWeatherMap free API key required) [1]
Clock, stopwatch, and timer widgets [1]

Access control model:

Forward auth via HTTP headers (Remote-User, Remote-Groups, Remote-Name, Remote-Email) — compatible with Authelia’s trusted header SSO [1]
All dashboard content is admin-defined in a central config.yml — users cannot add or modify tiles, only adjust their personal appearance settings [1]
SINGLE_USER_MODE=1 environment variable bypasses auth for local demos or single-person setups [1]
Admin designation via ADMINS env var (per-user or per-group) [1]

Deployment model:

Single Docker container, ghcr.io/knrdl/hubleys-dashboard [1]
Persistent data lives in /data (config, logos, wallpapers, per-user settings) — structure auto-generates on first run [1]
Memory limit in the example docker-compose: 100MB — meaningfully lightweight [1]
Config changes take effect after restart or via the Admin → Reload panel [1]
Environment variables for path overrides allow config.yml to live in a separate git-tracked location [1]

What’s notably absent:

No built-in service health checks (unlike Homarr or Homepage with their widget integrations)
No Docker socket integration for auto-discovering containers
No built-in authentication — you must have a working auth provider setup before Hubleys is useful in multi-user mode
REST API is listed as a feature in the canonical features, but documentation on it is sparse in the README [1]

Pricing: SaaS vs self-hosted math

Hubleys is software-only. There is no cloud version, no managed tier, no paid license. The pricing question here is what it costs you to run it versus alternatives.

Self-hosted Hubleys:

Software: $0 (MIT license) [1]
Compute: fits in the free tier of Oracle Cloud, or ~$4–6/mo on a shared VPS (it runs in 100MB RAM, so it shares infrastructure with everything else you’re hosting) [1]
API keys: OpenWeatherMap free tier (60 calls/minute, more than sufficient), Unsplash free tier (50 requests/hour) — both $0 [1]
Auth provider: if you don’t already have Authelia running, that’s an additional setup dependency (also free, also self-hosted)

What you’d be replacing: There’s no direct SaaS equivalent of “admin-controlled per-user dashboards for self-hosted services.” The closest analogues are:

Managed intranet tools (Confluence, Notion for teams, Guru): $8–15/user/month just for a link directory with access controls. Overkill and wrong category.
Netdata/Grafana dashboards: serve a different purpose (monitoring), but some teams overload them as service directories. Complex to lock down by user.
Just a shared bookmark folder: $0, but everyone sees everything and nobody maintains it.

For a 5-person household or small team, the delta between “bookmarks everyone ignores” and “an admin-managed dashboard per person” is either Hubleys ($0 + your time) or nothing, because no SaaS product is designed for this.

Deployment reality check

Getting Hubleys running in single-user demo mode takes two minutes:

docker run -it --rm -e SINGLE_USER_MODE=1 -e ORIGIN=http://localhost:3000 -p 127.0.0.1:3000:3000 ghcr.io/knrdl/hubleys-dashboard:edge

Getting it running in production multi-user mode is a different story. The actual prerequisites:

Required:

A working reverse proxy (Caddy or nginx) with HTTPS
An identity provider that supports forward auth header injection — Authelia is the documented example, and it’s itself a multi-service setup with its own config, Redis, and optionally LDAP [1]
A domain name (Hubleys sets ORIGIN from the env, which must match your actual URL)
A Linux host with Docker

File permissions gotcha: the README includes a note to run chown -R 1000:1000 ./data on the host before first run to fix folder permission issues — the kind of detail that trips up Docker newcomers [1].

Config workflow: All dashboard content (which services users see, folder structure, tile labels, icons) lives in a single config.yml. The default example is in the repository. You edit YAML, restart or use the admin reload, done. There’s no GUI editor for tile configuration — that’s a deliberate design choice that makes the config trackable in git but means any tile addition requires a YAML edit and reload [1].

Realistic time estimates:

You already run Authelia + Caddy: 30–45 minutes to add Hubleys as another protected service and configure initial tiles.
You’re starting from scratch (new VPS, no auth stack): half a day minimum, most of which is Authelia setup, not Hubleys.
You’ve never run a reverse proxy: budget a full weekend and expect troubleshooting.

The README documents the Authelia integration but doesn’t walk through the Authelia setup itself — that’s on you. The project links to the Authelia trusted header SSO documentation as a reference [1].

Pros and Cons

Pros

Per-user dashboards are the real differentiator. No other single-container homepage tool in this category ties tile visibility to auth provider group membership out of the box [1].
Genuinely lightweight. 100MB RAM ceiling in the example config — this is a small, focused container that won’t compete for resources with your actual services [1].
MIT license. No usage restrictions, no “fair-code” caveats, no commercial license required if you embed this in something you run for clients [1].
Admin-controlled content. Users can’t accidentally delete or rearrange the tiles the admin configured. Personal settings (theme, background) are separate from the service directory [1].
Forward auth is the right architecture. Hubleys doesn’t try to be an auth provider. It trusts headers from your existing stack, which means your session management, MFA, and user directory stay in one place [1].
Custom logos + wallpapers. You can drop images into /data/logos/ and reference them in config, or mount a wallpaper folder for a local background collection [1].

Cons

Auth provider is a hard prerequisite. In multi-user mode, Hubleys is completely dependent on a functioning reverse proxy + forward auth setup. If you don’t already have one, the setup cost is Authelia, not Hubleys [1].
No service health checks. Homarr and Homepage can ping your services and show status indicators. Hubleys is a static link directory — it won’t tell you if Jellyfin is down.
No Docker auto-discovery. You manually define every service in config.yml. Tools like Homarr or Traefik-aware dashboards can detect containers automatically.
110 GitHub stars. This is a one-developer project without a company behind it. It’s functional and well-maintained from what the README shows, but “what happens if the maintainer stops” is a real question for anything you put in front of users.
No built-in search across your services — only web search engines with autocomplete are supported; there’s no Sonarr/Radarr/Jellyfin-aware search widget.
YAML-only config for tiles. Every tile, folder, and permission change requires editing config.yml and reloading. No GUI config editor.
Weather and backgrounds need external API keys — two free API registrations (OpenWeatherMap + Unsplash) are needed for full functionality, which adds setup steps [1].

Who should use this / who shouldn’t

Use Hubleys if:

You manage a self-hosted stack for multiple people (household, small team, friend group) and want them to each see a relevant, curated dashboard instead of a shared wall of links.
You already have Authelia or a similar forward auth setup running — adding Hubleys is low effort.
You want a clean, admin-controlled link page where users can’t modify the service directory.
Lightweight resource usage matters (shared VPS, low-RAM homelab hardware).

Skip it (use Homarr or Homepage instead) if:

You’re the only user of your homelab and don’t need per-user access control.
You want service status indicators and health checks baked in.
You want Docker socket integration to auto-discover containers.
You’re not already running a forward auth provider and don’t want to set one up.

Skip it (use Organizr instead) if:

You want a tab-based dashboard that bundles multiple service UIs into one page.
Your users need to access service interfaces directly within the dashboard frame, not just navigate to them.

Skip it entirely if:

You’re a non-technical user who needs someone else to deploy things — this requires Linux, Docker, and reverse proxy knowledge, or someone with those skills.
You don’t control a server and are looking for a hosted solution. There isn’t one.

Alternatives worth considering

Homepage (gethomepage.dev) — the most feature-rich self-hosted dashboard, 20K+ stars, extensive widget library with service health checks, Docker auto-discovery. Single dashboard, no per-user access control. Better choice for solo users or small teams sharing one view.
Homarr — polished UI, drag-and-drop, service integrations (Sonarr, Radarr, etc.), Docker socket awareness. Single dashboard focused. More features than Hubleys, but no multi-user access model.
Heimdall — the classic from LinuxServer.io. Stable, minimal, no per-user control, long-tail of enhanced app tiles with API integration. Better documented, larger community.
Dasherr — minimal, weather, bookmarks. Single user.
Flame — bookmarks + search, minimal, Docker labels support. Single dashboard.
Organizr — multi-tab, can proxy service UIs into iframes, has user authentication and group-based tab visibility. More complex to set up but the closest alternative if you want tab-based multi-user access control.

For the specific use case Hubleys targets — admin-controlled per-user dashboards via forward auth — Organizr is the only real alternative, and it trades simplicity for more features.

Bottom line

Hubleys earns its place by solving a specific problem that the larger, flashier dashboard projects ignore: multiple users, one admin, different views. If you’re a single user, there’s nothing here that Homarr or Homepage don’t do better. But if you’ve ever explained to a family member why their dashboard shows a link to your Proxmox node they can’t use anyway, or wanted to give coworkers a curated view of shared tools without exposing your entire infrastructure — this is the tool. It’s small, it’s MIT, it runs in 100MB of RAM, and the architecture is correct: let your auth provider do auth, let Hubleys do display. The price of entry is a working Authelia setup, which is either something you already have or a meaningful investment to acquire.