Self-hosted homelab dashboards, honestly reviewed. No marketing fluff, just what you get when you run it on your own server.

TL;DR

What it is: MIT-licensed, self-hosted dashboard for your homelab — a single page that organizes all your self-hosted services, status indicators, and live widgets in one place [1][2].
Who it’s for: Homelab enthusiasts and self-hosting founders who want a visually rich, highly customizable portal to all their services, without memorizing IP addresses and port numbers [1][5].
Cost: $0 for the software. A $5–10/mo VPS is enough, though Dashy is heavier on resources than most dashboard alternatives [3].
Key strength: The deepest feature set in the self-hosted dashboard category — 50+ built-in widgets, 10+ languages, dozens of themes, SSO support, cloud backup, multiple view modes, and a working UI editor without touching YAML [2][4].
Key weakness: Resource-hungry. The XDA Developers review explicitly warns it needs a Raspberry Pi with at least 8GB RAM to avoid slowing down other services [3]. For a lean homelab, this matters.

What is Dashy

Dashy is a self-hosted, open-source homepage for your homelab. The pitch is simple: instead of having 12 browser bookmarks pointing to 192.168.1.100:3001, 192.168.1.100:8096, and so on, you get one URL that shows all your services in a grid with icons, descriptions, and live health indicators.

It was built by Alicia Sykes (@Lissy93) who describes it as “a self-hostable personal dashboard built for you” [README]. The project has grown into something considerably larger than a simple links page: at 24,251 GitHub stars and 15.1 million Docker pulls, it’s become the default recommendation in r/selfhosted threads whenever someone asks “what dashboard should I use?” [website].

What separates Dashy from the dozens of simpler homepage tools is three things. First, the widget system — 50+ pre-built integrations with self-hosted services (Grafana, Portainer, Pi-hole, etc.) that pull live data directly into your dashboard without writing a single line of code [2][1]. Second, real-time status indicators — a small dot next to each service that turns red if it goes down, with response time visible on hover [2][5]. Third, the UI editor — you can configure the entire dashboard through a browser interface, and changes are written back to the config file automatically [2][4]. You don’t have to edit YAML to get started.

The project is maintained by a community of 200+ contributors [website], with the primary author still active. It runs entirely on your infrastructure — there’s no call-home, no analytics, no vendor lock-in.

Why people choose it over Homer, Heimdall, and Homepage

The honest answer from reviewers is that Dashy wins on visual richness and features, and loses on resource efficiency.

Versus Homer. The Linux Journal comparison [2] is the clearest head-to-head. Homer is simpler, lighter, and entirely YAML-driven — no UI editor. If you want a no-frills bookmark list that starts in under 100MB of RAM, Homer is the answer. If you want widgets, status indicators, theme switching, and SSO, you need Dashy. The tradeoff is real: Homer is “meant to be used anywhere” including on minimal hardware, while Dashy is the “resources-heavy, flashy UI” option [3]. Neither is objectively better — it depends whether you want a tool or a dashboard experience.

Versus Homepage (gethomepage.dev). Not covered in these specific articles, but frequently cited in the same community threads. Homepage is newer, also heavily featured, and generally considered leaner. For users making the decision today, Homepage is a serious competitor. Dashy’s advantage is maturity — more community configs, more theme polish, a larger icon library.

Versus Heimdall. Heimdall is the older, PHP-based option that many homelab veterans started on. Dashy surpassed it on features several years ago and is now the default recommendation for new setups.

On the resource question. The XDA Developers piece [3] puts this plainly: Dashy “consumes a significant amount of CPU and memory resources” and is “best suited for the Raspberry Pi which has at least 8GB of RAM.” If you’re running a 2GB or 4GB Pi with multiple services, Dashy can crowd out the things it’s supposed to monitor. In that scenario, Homer or Homepage will serve you better. On a proper VPS with 2–4GB dedicated, this isn’t a problem.

The configuration learning curve. One noted.lol reviewer wrote: “At first I was very overwhelmed when it came to customizing it to how I wanted it. But once I got the hang of the editor, it was all downhill from there” [4]. The XDA review adds a practical warning: “When working with the YAML config files, follow the correct indentation. Otherwise, every single formatting error can break the dashboard” [3]. The UI editor largely sidesteps this, but advanced configs (custom widgets, complex layouts) still require editing YAML by hand.

Features

Based on the README, website, and first-hand reviews:

Core dashboard:

Multiple pages with separate sections and layouts [README]
Customizable grid: layout options, item sizes, visible/hidden components [2][website]
Custom header, footer, nav-bar links, title, and background image [2][5]
Full CSS variable-based theming with a color palette editor [1][website]
Dozens of built-in themes, with real-time preview [1][3]
Font-Awesome, Material Design Icons, emoji, auto-fetched favicons, and homelab icon packs [1][2]

Status and monitoring:

Real-time HTTP status checks for every app/link [1][2][README]
Visual dot indicator (up/down) with response time on hover [2][5]
Widgets with live data from 50+ self-hosted services [2][website]
Iframe widget for embedding any dashboard or service directly [4]

Navigation:

Instant search by name, domain, or tags — just start typing [2][5]
Customizable keyboard shortcuts for frequently used apps [2][5]
Web search via any search engine from the search bar [2][website]
Arrow key and tab navigation through results [5]

Views:

Default home view [website]
Minimal view — fast-loading browser startpage [2][3]
Workspace view — use multiple apps simultaneously without leaving the dashboard [2][website]
App launch options: new tab, same tab, pop-up modal, clipboard, workspace [2][website]

Authentication and access:

Built-in multi-user auth with configurable per-user privileges [2][website]
Keycloak integration [website]
SSO support for other providers [README][website]

Data and backup:

Optional end-to-end encrypted cloud backup and restore [2][5][website]
Config sync between multiple Dashy instances [2][website]
Config entirely in a single YAML file [4][5]
UI editor that writes changes back to disk in real time [4][website]

Internationalization:

10+ human-translated languages (English, German, French, Dutch, Slovenian, and more) [README][website]
Automatic language detection from browser settings [website]

Deployment:

Docker, Docker Compose, bare metal, and one-click cloud deployment [README][4]
PWA for basic offline access [README]
Small bundle size, fully responsive [README][5]

Pricing: SaaS vs self-hosted math

Dashy has no SaaS tier and no commercial license. It’s MIT, free to run, and there’s no paid upgrade. The “pricing” question for Dashy is really about infrastructure cost and what you’re replacing.

What you’re typically replacing: A manual browser bookmark folder, or a tool like Organizr, or simply typing IP:port from memory every time you need a service. None of those have a direct monthly cost, which means the ROI calculation for Dashy is about time saved and operational convenience rather than money.

Infrastructure cost:

Self-hosted on existing homelab hardware: $0/mo marginal cost
Dedicated VPS (if running only Dashy): $5–10/mo on Hetzner, Contabo, or DigitalOcean
Raspberry Pi: hardware cost already sunk; power draw is the only variable

Minimum requirements: The noted.lol guide shows it running on a standard Docker host with a compose file [4]. The XDA Developers article [3] warns that on a Raspberry Pi, you want at least 8GB RAM — on a proper amd64 VPS, 1–2GB is workable.

There’s no subscription, no per-feature pricing, no “pro plan” wall you’ll hit six months in. This is the rare self-hosted tool that genuinely costs nothing beyond the server it runs on.

Deployment reality check

The standard install path is Docker Compose, which takes under 10 minutes on a server that already runs Docker [4][README]. The noted.lol review walks through the full process: create a config directory, create my-local-conf.yml, create docker-compose.yml, run docker-compose up -d [4]. That’s it.

What you actually need:

A Linux server or Raspberry Pi running Docker
A domain name and reverse proxy (Caddy or nginx) if you want HTTPS and a clean URL
The base YAML config file before first launch — Dashy won’t start without one [4]

What can go sideways:

YAML indentation errors. The XDA review flags this explicitly: “every single formatting error can break the dashboard” [3]. The UI editor reduces this risk, but if you’re hand-editing conf.yml, one misplaced space breaks everything. YAML validators help.
Resource contention on low-RAM devices. On a Raspberry Pi 4 with 4GB RAM running Pi-hole, Plex, and a few other services, Dashy’s memory footprint will compete with your actual workloads [3]. The UI is rich — that richness has a cost at runtime.
First-time config overwhelm. One reviewer put it well: “I was very overwhelmed when it came to customizing it” at first [4]. The UI editor helps, but the full feature surface of Dashy is large. Plan for 1–2 hours to get a dashboard you’re actually happy with, not 10 minutes.
Initial config required before container starts. Unlike some tools that boot with sensible defaults and let you configure after, Dashy needs a conf.yml present at launch [4]. The documentation provides example configs that get you past this quickly.

Realistic time estimate for a technical user: 20–40 minutes to a working instance. For someone new to Docker: 2–3 hours including reverse proxy setup. The documentation at dashy.to/docs is thorough [5].

Pros and Cons

Pros

MIT license, no commercial strings. Fork it, embed it, ship it in your own product — no usage restrictions, no commercial licensing agreement [README][5].
Largest feature set in the category. Status indicators, 50+ widgets, multi-user auth, SSO, cloud backup, multi-page support, workspace view, multiple launch methods — nothing else packs this much into a homepage [2][1].
UI editor that actually works. You can build a full dashboard without touching YAML. Changes are written to disk and backed up [4][website].
24,251 GitHub stars and 15.1M Docker pulls — the community has validated this is the mainstream choice, which means community configs, icon packs, and troubleshooting answers are plentiful [website].
End-to-end encrypted cloud backup. Optional, free, and gets your config off-site without exposing its contents [2][5][website].
PWA support — install it as a lightweight browser app on your phone or tablet [README][5].
Active maintenance. V3.1.12 shipped recently [website], 200+ contributors [website], and the original author remains involved.
Theming is genuinely good. Dozens of built-in themes with a color palette editor, real-time preview, and full CSS variable override support [1][3].

Cons

Resource-heavy for its category. This is the main trade-off. A dashboard should be the lightest thing on your server, not the heaviest. On constrained hardware (Raspberry Pi 4 with 4GB RAM), Dashy can crowd out the services it’s displaying [3].
YAML config errors kill the app. One bad indentation and the container won’t start [3]. The UI editor helps, but any manual config editing requires care. Homer and Homepage fail more gracefully.
Overwhelming surface area. The feature count is also a learning curve. New users report spending an entire day just customizing [4]. If you want to set it up in 15 minutes and move on, simpler tools will serve you better.
No built-in metrics or alerting. Status indicators show up/down, not trending history. For actual monitoring, you still need Grafana, Uptime Kuma, or similar — Dashy just displays their outputs via widgets [2].
SSO is supported but setup is non-trivial. Keycloak integration works, but configuring it requires Keycloak itself to be running and configured, which is a separate afternoon [website].
No REST API for external config management. You configure Dashy through the UI or by editing its YAML file. There’s no programmatic API for injecting service entries from external scripts or provisioning tools.

Who should use this / who shouldn’t

Use Dashy if:

You run 5+ self-hosted services and are tired of managing bookmarks or memorizing ports.
You want a visually polished dashboard with live status and widget data, not just a link list.
You have a server with at least 2GB RAM not shared with many other demanding services.
You value a deep feature set over minimal resource footprint.
You want SSO support and multi-user access with privilege controls.

Skip it (use Homer) if:

You’re on a resource-constrained device (Raspberry Pi 3B+, 2GB Pi 4) and every megabyte counts.
You want a dead-simple bookmark page with no JavaScript weight.
You’re comfortable writing YAML by hand and prefer a minimal, transparent tool.

Skip it (use Homepage) if:

You want a modern, actively developed alternative with a lighter resource footprint.
You’re starting fresh and don’t have an existing Dashy config to migrate.
You want built-in Docker container status monitoring as a first-class feature.

Skip it (use Heimdall) if:

You’re already running a PHP stack and don’t want another Docker container.
Your homelab is mostly a link list and you don’t need widgets or status checks.

Alternatives worth considering

From the README’s alternatives list and community comparisons:

Homer — the lightweight competitor. Pure YAML config, no UI editor, no widgets, but boots in seconds and uses almost no RAM [2]. The right answer for minimal setups.
Homepage (gethomepage.dev) — the current challenger to Dashy’s crown. Newer, actively developed, strong Docker integration, generally leaner than Dashy. Frequently recommended alongside Dashy in r/selfhosted.
Heimdall — the PHP-based predecessor. Simpler, older, fewer features. Most homelab veterans have graduated past it.
Organizr — more focused on media server organization. Good if your homelab is primarily Plex/Jellyfin/Sonarr.
Homarr — another modern option with a drag-and-drop editor. Closer to Homepage than Dashy in design philosophy.
Flame — minimal, bookmark-focused, tiny footprint. Worth considering if Dashy’s resource use is a dealbreaker.

For a non-technical founder or homelab enthusiast with a capable server, the realistic shortlist is Dashy vs Homepage. Pick Dashy if you want the richest feature set, an established community, and don’t mind the resource footprint. Pick Homepage if you want something leaner with strong Docker integration that’s actively catching up on features.

Bottom line

Dashy is the most fully-featured self-hosted dashboard available, and that’s both its strength and its honest trade-off. If you want status indicators, 50+ widgets, multi-user auth, SSO, cloud backup, themes, and a UI editor that doesn’t require touching YAML, nothing else in the category comes close. The 24,251 GitHub stars and 15.1M Docker pulls aren’t an accident — this is what most homelab enthusiasts end up on once their service count grows past a handful.

The catch is that Dashy is not a lightweight tool. On a constrained device, it will compete with the services it’s displaying. And the feature depth that makes it powerful also makes first-time configuration a multi-hour project rather than a quick setup. If you’re running a capable server and want to invest the time upfront for a dashboard you’ll actually enjoy using every day, Dashy delivers. If you need something that runs in 128MB and starts in 30 seconds, look at Homer or Homepage instead.

For non-technical founders building out a homelab to reduce SaaS spend, Dashy is the right answer as long as you have the hardware headroom — and if the Docker setup is the blocker, that’s exactly the kind of one-time deployment upready.dev handles for clients.

Sources

Umair, Medium — “Transform Your Homelab into a Command Center with Dashy” (Dec 12, 2025). https://medium.com/@u.mair/transform-your-homelab-into-a-command-center-with-dashy-6e331304a6c7
Brandon Hopkins, Linux Journal — “Self-Hosted Static Homepages: Dashy Vs. Homer” (Apr 26, 2022). https://www.linuxjournal.com/content/self-hosted-static-homepages-dashy-vs-homer
Samir Makwana, XDA Developers — “5 must-have dashboards for self-hosted apps on a headless Raspberry Pi” (Apr 17, 2025). https://www.xda-developers.com/must-have-dashboards-headless-raspberry-pi/
noted.lol — “Dashy - The Self Hosted Personal Dashboard”. https://noted.lol/dashy/
Alicia Sykes — “Dashy - A Self-Hosted Home Lab Dashboard” (May 5, 2021). https://notes.aliciasykes.com/25291/dashy-a-self-hosted-home-lab-dashboard

Primary sources:

GitHub repository and README: https://github.com/lissy93/dashy (24,251 stars, MIT license, 200+ contributors)
Official website: https://dashy.to
Documentation: https://dashy.to/docs