A self-hosted dashboard is a web-based landing page you run on your own hardware or VPS that centralizes links, live service status, and system widgets for every app in your stack.
Choosing between Homarr and Homepage is one of the most common decisions in self-hosting today. Both tools solve the same core problem: you have a growing list of services, and you need one place to reach all of them without memorizing ports or IP addresses.
The short answer is that Homepage favors operators who want YAML-driven, version-controlled configuration, while Homarr favors those who prefer a drag-and-drop visual editor and deeper Docker control. Neither is universally better. The right choice depends almost entirely on how you prefer to manage infrastructure.
In this comparison, we cover configuration models, widget depth, deployment patterns, resource usage, and real-world scenarios so you can make a confident choice for your homelab or VPS setup.
Quick Verdict and Best Fit by User Type
Homepage and Homarr serve overlapping audiences but pull in different directions on configuration philosophy, performance, and daily interaction. Homepage runs leaner at roughly 80 MB of RAM versus Homarr’s approximate 150 MB footprint, renders quickly on mobile, and integrates cleanly with file-based workflows. Homarr delivers a richer visual editing experience and more interactive Docker control out of the box.
Who Should Choose Homepage First
Homepage is the stronger starting point if you already manage services through Docker Compose files and want your dashboard configuration to live alongside those files in version control. The YAML-based setup feels natural for operators who treat infrastructure as code.
It is also the better fit for low-power hardware. The reduced memory footprint and fast render times make it a practical choice on Raspberry Pi or small VPS deployments where every megabyte matters.
Mobile responsiveness is solid out of the box. If your household uses the dashboard from phones as often as from desktops, Homepage handles mixed screen sizes without extra configuration.
Who Should Choose Homarr First
Homarr earns its place when the person setting up the dashboard prefers a browser-based editing experience over text files. Tiles, groups, and widgets are arranged visually, which lowers the barrier for first-time self-hosters significantly.
The built-in Docker socket integration also gives Homarr an edge for users who want to start and stop containers directly from the dashboard. That level of control is not available in Homepage without external tools.
If you are comparing Homarr vs Dashy for a similarly visual experience, Homarr tends to offer more polished Docker-facing features while Dashy leans toward broader module customization.
When the Choice Matters More Than Features
The feature gap between these two tools is smaller than most comparisons suggest. What actually drives long-term satisfaction is workflow fit. If your stack is documented, Git-backed, and rebuilt occasionally, Homepage will age better. If your dashboard changes frequently and other household members need to edit it without touching config files, Homarr’s visual editor removes a real point of friction.
Homarr Vs Homepage: Core Differences That Matter
The deepest difference between these two dashboards is not widget count or visual polish; it is how each tool stores and applies your configuration. That single architectural decision shapes migration behavior, version control compatibility, rebuild speed, and day-to-day editing friction.
Configuration Model and Day-To-Day Workflow
Homepage stores everything in YAML files: services.yaml, widgets.yaml, bookmarks.yaml, and a handful of supporting files. Changes take effect by editing those files directly, either on disk or through a mounted Docker volume. The container image is pulled from ghcr.io/gethomepage/homepage and reads configuration on startup.
Homarr stores its configuration in a conf.yml file that is primarily written and updated through the browser UI. You can inspect the file directly, but the intended workflow is the visual editor. Most users never touch the raw config unless they are migrating or restoring from backup.
In daily practice, Homepage editing means opening a terminal or file manager. Homarr editing means opening a browser tab. Neither is inherently superior; each maps better to a different kind of operator.
Visual Editing Vs Configuration as Code
Homepage’s file-first model integrates cleanly with Docker Compose workflows and Git repositories. If you track your entire homelab stack in a single repository, dropping services.yaml into that repo keeps the dashboard in sync with everything else. Rebuilding after a host migration is fast because configuration is portable by design.
Homarr’s visual editor reduces setup time for new users and makes the dashboard editable by people who are not comfortable with YAML syntax. The tradeoff is that conf.yml can drift if edits are made through the UI without a corresponding backup strategy.
State Management, Portability, and Rebuilds
With Homepage, there is no meaningful application state beyond the config files themselves. Back up the volume containing those YAML files, and you can reproduce the dashboard on any host running Docker Compose in minutes.
Homarr carries slightly more state: user accounts, widget tokens, and UI preferences are stored alongside the main config. Migration requires capturing the full data volume rather than a single config directory. This is manageable with a solid backup routine, but it adds one more thing to track when rebuilding.
Setup, Deployment, and Reverse Proxy Considerations
Both dashboards deploy cleanly through Docker Compose and sit comfortably behind standard reverse proxies. The main differences appear in authentication handling and how each tool manages secrets during external access. Understanding those differences before first deployment saves meaningful time later.
Docker Compose and Portainer Deployments
Homepage’s Compose file is minimal. Mount the config directory, set the port, and the container starts. Portainer users can paste the Compose definition directly into a stack, point the bind mount at the right path, and have a working dashboard in under five minutes.
Homarr’s Compose setup is similarly straightforward. The official documentation provides a ready-to-use definition that mounts the data volume and exposes the default port. Portainer handles it identically. The main addition is setting a SECRET_ENCRYPTION_KEY environment variable, which Homarr uses to encrypt stored integration credentials. Skipping this step during initial setup can create complications when migrating later.
Reverse Proxy Setup With Nginx, Traefik, and Caddy
Both dashboards work cleanly behind Nginx Proxy Manager, Traefik, and Caddy without unusual configuration. Homepage handles base path deployments and subdomain routing without issues. Homarr’s documentation includes an explicit Caddy example with the correct Docker Compose structure, which speeds up that particular combination.
For Traefik users, both tools integrate through standard label-based routing. Neither requires special middleware for basic proxy pass behavior. SSL termination at the proxy layer works as expected for both.
One practical note: never expose either dashboard’s internal port directly to the public internet. Always route through the reverse proxy and apply access controls before opening external access.
Authentication, External Access, and Secret Handling
Homepage does not include built-in authentication. External access requires layering auth at the proxy level, through tools like Authelia, Keycloak, or Cloudflare Access. This is a deliberate design choice and not a missing feature, but it means you need to plan the auth layer before going public.
Homarr includes built-in user account management with role-based permissions. For households or small teams where different people need different access levels, this removes the need for a separate identity provider. For stricter environments, Homarr’s built-in auth can still be supplemented with proxy-level controls.
The SECRET_ENCRYPTION_KEY in Homarr should be set before adding any integration credentials. It controls how API keys and service tokens are stored on disk.
Widgets, Integrations, and Service Visibility
Widget depth is where Homepage and Homarr diverge most visibly in daily use. Both support core service integrations, but they approach the widget ecosystem differently in terms of breadth, data depth, and how Docker container information surfaces on the dashboard.
Homepage Widget Depth and Service Integrations
Homepage ships with an unusually broad set of service widgets. Direct integrations cover Jellyfin, Plex, Sonarr, Radarr, Nextcloud, Vaultwarden, Paperless-NGX, Pi-hole, AdGuard Home, Gitea, Prometheus, Proxmox, Uptime Kuma, Grafana, and many others. Each widget pulls live data from the service API rather than simply displaying a link.
The quality of individual widgets is consistently high. A Sonarr widget shows upcoming episodes in the queue. A Pi-hole widget displays current block statistics. Proxmox integration surfaces node resource usage in real time. This level of depth makes Homepage function as a lightweight status board, not just a bookmark page.
Configuration requires adding the service URL and API key to services.yaml. Syntax is well-documented and consistent across integrations.
Homarr Auto-Discovery and Docker Integration
Homarr’s standout capability is Docker auto-discovery. When given access to the Docker socket, Homarr can automatically detect running containers and surface them as tiles. Container status, port mappings, and labels can drive the dashboard layout without manual configuration for each service.
Beyond discovery, Homarr allows starting and stopping containers directly from the dashboard UI. For operators who want dashboard-level Docker management, this is a meaningful functional difference from Homepage.
Widget support in Homarr covers Arr stack apps, media servers including Jellyfin and Plex, download clients, and system resource monitoring. The breadth is competitive, though Homepage’s individual widgets tend to expose more granular API data per service.
Monitoring Key Services in a Growing Stack
For a stack that includes Home Assistant, AdGuard Home, and a mix of utility services like Vaultwarden and Paperless-NGX, Homepage’s native widget depth provides more out-of-box visibility. Each service can display meaningful live data without custom configuration beyond an API key.
Homarr’s auto-discovery reduces the manual work of registering each new service. As stacks grow, that automation becomes a practical time saver even if individual widget data depth is slightly narrower.
For status checking and health monitoring beyond what either dashboard provides natively, pairing either tool with Uptime Kuma and embedding or linking to its status page covers the gap cleanly.
Resource Usage, Scalability, and Long-Term Maintenance
Resource consumption and maintenance overhead are often underweighted in dashboard comparisons. In a stack where every container competes for memory on a single NAS or small VPS, a 70 MB difference in baseline RAM usage is genuinely relevant. So is how easily the dashboard survives host migrations and configuration changes over time.
Memory and Runtime Footprint
Homepage runs at approximately 80 MB of RAM under normal load. Homarr runs closer to 150 MB. On a machine with 8 GB or more, this difference is inconsequential. On a 2 GB Raspberry Pi or a budget VPS where many containers share the same host, it becomes a real constraint.
Homepage’s runtime is also simpler. It reads config files and renders the interface without persistent background processes managing state. That simplicity contributes to both its low memory footprint and its fast initial render.
Scaling From a Small Homelab to Mixed Environments
Homepage scales well from a single-host homelab to more complex environments. Kubernetes support is available, and the file-based configuration maps cleanly onto config maps and mounted volumes in cluster deployments. Proxmox users running multiple VMs can replicate the same config files across instances without meaningful friction.
Homarr is primarily designed for single-instance deployments. It works well in that context at almost any scale of app count, but moving it into a Kubernetes or multi-node environment requires more work. For most home lab operators this is never a practical concern, but it becomes relevant if the stack expands beyond a single physical or virtual host.
Backup Strategy, Restore Confidence, and Change Tracking
Homepage’s backup story is the simplest available: copy the config directory. Because all state lives in a small set of YAML files, restore confidence is high. You can verify a backup visually, diff changes with Git, and reproduce the full dashboard on a fresh host in minutes.
Homarr requires capturing the full data volume, which includes the database and credential store alongside the config. This is straightforward with standard Docker volume backup tooling, but it requires more intentional setup than a simple file copy. Version control is less natural because the UI-driven workflow does not produce clean diffs the way YAML edits do.
Good documentation of your Homarr configuration, including screenshots of your layout and exported API key references, goes a long way toward smooth recovery.
Practical Decision Guide for Common Self-Hosting Scenarios
Most self-hosters are not choosing between abstract features; they are choosing between tools that fit a specific stack, a specific audience, and a specific tolerance for maintenance overhead. The scenarios below map directly to the tradeoffs we have covered throughout this comparison.
Best Choice for Privacy-Focused Home Labs
For a privacy-focused homelab where services like Vaultwarden, AdGuard Home, Pi-hole, and Nextcloud are central, Homepage is the stronger match. Its widget integrations for these specific tools are well-developed and expose meaningful live data.
The YAML configuration model also fits neatly into a documented, version-controlled infrastructure where changes are tracked and reproducible. There are no user accounts or session data to protect on the dashboard itself, which simplifies the security surface. Authentication is handled at the proxy layer using whichever identity tool fits the stack, whether that is Authelia, Keycloak, or a simpler IP allowlist.
For readers exploring privacy tooling and Usenet access alongside their homelab setup, the guides at datahoarder.io cover VPN and no-logs provider selection in useful detail.
Best Choice for Media, Archive, and Utility Dashboards
A dashboard anchored around media servers, archival data tools, and high-resolution media libraries benefits from Homarr’s visual layout and Docker auto-discovery. Adding a new container, whether Jellyfin, a Paperless-NGX instance, or a Gitea server, surfaces it as a tile automatically without editing config files.
Homarr’s Arr stack integrations are polished and practical for operators running Sonarr, Radarr, and related services. The visual editor also makes it easy to organize tiles into logical groups, which matters when the dashboard needs to be readable by household members who are not managing the stack themselves.
Best Choice for Tinkerers, Families, and Shared Admin Setups
Families and shared admin environments benefit most from Homarr’s built-in user management. Different household members can have different access levels without setting up a full identity provider. The visual editor means a second admin can update the dashboard without learning YAML syntax.
For tinkerers who enjoy customizing themes, tweaking layouts, and iterating frequently, Homarr’s browser-based workflow reduces the cycle time for changes. Homepage supports custom CSS and theme configuration, but it requires editing files rather than clicking through a UI. Dashy, maintained by Lissy93 (lissy93/dashy), is also worth considering in this category if maximum customization depth matters more than widget ecosystem quality.
Bookmarks, service tiles, and basic widgets all work well in both tools. The decision in a shared environment almost always comes down to who else needs to edit the dashboard and whether they are comfortable with config files.
Frequently Asked Questions
Which self-hosted dashboard is easier to set up and maintain for a beginner?
Homarr is generally easier for beginners because configuration happens through a browser-based visual editor rather than YAML files. A new user can have a working dashboard with tiles, groups, and basic widgets without writing a single line of configuration. Homepage has a steeper initial learning curve but rewards operators who already work with Docker Compose files and documented infrastructure.
How do the available widgets and integrations compare between these dashboards?
Homepage offers a broader and more data-rich widget library, with deep integrations for services like Jellyfin, Sonarr, Radarr, Pi-hole, AdGuard Home, Proxmox, Nextcloud, Prometheus, Grafana, and Uptime Kuma. Homarr covers many of the same services and adds Docker auto-discovery and container control, but individual widgets in Homepage tend to surface more granular API data per service.
Which option performs better on low-power hardware like a Raspberry Pi?
Homepage runs at approximately 80 MB of RAM under normal load compared to Homarr’s approximately 150 MB footprint. On a Raspberry Pi or a budget VPS where memory is shared across many containers, Homepage is the more practical choice. Its simple runtime with no persistent background state also contributes to faster page loads on constrained hardware.
How do they differ in customization options such as themes, layouts, and CSS support?
Both tools support custom CSS and theme configuration, but they approach it differently. Homepage applies themes and CSS through configuration files, which integrates cleanly into a version-controlled workflow. Homarr applies visual customization through the browser editor, making layout changes faster for non-technical users. For maximum customization depth beyond what either offers, Dashy by Lissy93 is the more feature-rich alternative.
What are the key differences in authentication and access control features?
Homepage includes no built-in authentication and relies on proxy-level access controls using tools like Authelia, Keycloak, or Cloudflare Access. Homarr includes built-in user account management with role-based permissions, allowing different users to have different access levels without a separate identity provider. For households or small teams with multiple admins, Homarr’s built-in auth is a meaningful practical advantage.
Which dashboard is better for monitoring services and displaying real-time status information?
Homepage edges ahead for monitoring-focused setups because of its deep service widget library. Live data from Uptime Kuma, Grafana, Prometheus, Proxmox, and individual application APIs surfaces directly on the dashboard without additional tooling. Homarr handles status checking and health monitoring well within its supported integrations, but Homepage’s widget ecosystem covers a wider range of monitoring endpoints with more granular per-service data.