A lightweight self-hosted homepage dashboard with uptime monitoring, honestly reviewed. Based on the GitHub repository and README — no independent third-party reviews were found for this tool.

TL;DR

What it is: A lightweight self-hosted homepage dashboard written in Go. Shows bookmarks organized by tabs and panels, with built-in HTTP uptime monitoring for your services [README].
Who it’s for: Self-hosters who want a fast, low-resource dashboard to organize links to their homelab services, with basic uptime checks and no JavaScript framework overhead [README].
Cost: $0 (MIT license). Runs comfortably on a $5–6/mo VPS or alongside other containers on existing hardware [README].
Key strength: Extremely lightweight Go binary, local-network-capable mode (no internet dependency), and a straightforward config you can write as YAML or click through in a GUI [README].
Key weakness: Last release was December 2023, 235 GitHub stars, 12 forks — this is a one-developer project with limited community traction and no active development signals. Feature set is basic compared to alternatives like Homarr or Homepage [README].

What is miniboard

miniboard is a self-hosted bookmark dashboard with tabs, uptime monitoring, and notifications. It’s written in Go, stores uptime history in SQLite, and can be configured either through a web GUI or a board.yaml file [README].

The pitch is simple: you have a dozen self-hosted services running on your home server or VPS, and you want a single browser tab that shows you where everything lives and whether it’s up or down. miniboard does that. It doesn’t try to replace your monitoring stack or become a full observability platform — it’s a glorified bookmark page with HTTP health checks and a color-coded status indicator.

The project lives at https://github.com/aceberg/miniboard and is authored by a single developer (aceberg). As of this review it has 235 GitHub stars, 12 forks, 88 commits, and 15 releases. The most recent release is v1.2.2, published December 24, 2023 — over a year before this review [GitHub].

That last point matters. miniboard works, but it’s not receiving new features. If you need something that will evolve alongside your homelab, keep reading.

Why people choose it

No independent third-party reviews were found for miniboard. The analysis below is based on the GitHub repository, README, and general knowledge of the self-hosted dashboard category.

The pattern in this category is consistent: people find the major alternatives either too heavy or too complex for simple use cases. Dashy is a full Vue.js app that takes significant RAM and setup time. Homarr is feature-rich but assumes you’re deep in a specific Docker-oriented homelab workflow. Homepage (gethomepage.dev) is excellent but requires YAML for everything including service integrations.

miniboard’s appeal is the Go binary angle. The container image is small, startup is instant, and memory footprint is measured in single-digit megabytes rather than the hundreds of MB that Node.js-based dashboards consume. For someone running a Raspberry Pi or a small VPS where resources matter, that’s not a minor point.

The dual config system — GUI for people who hate editing YAML, YAML for people who want to version-control their configuration — is a genuine usability win. Most alternatives in this space are either code-first or click-first, not both.

The Docker socket integration is worth noting: if you mount /var/run/docker.sock, miniboard can read your running containers and pre-populate a panel from them, which saves manual entry for typical Docker homelabs [README].

The Bootswatch theme system gives about 20+ free Bootstrap themes without any additional dependencies. The local network mode (described in its own section below) means you can run the whole setup completely air-gapped [README].

Features

Based on the README:

Dashboard and navigation:

Tab-based organization with multiple panels per tab [README]
GUI-based panel and tab creation — no YAML required to start [README]
Bookmark buttons with configurable width and custom icons [README]
Bootstrap themes via Bootswatch (20+ options, applied by theme name) [README]
Light/dark background mode with configurable colors [README]

Uptime monitoring:

HTTP health checks for listed hosts [README]
Color-coded status: configurable online color (default #89ff89) and offline color (default #ff3232) [README]
SQLite-backed uptime history, auto-trimmed after configurable days (default 30) [README]
Configurable web refresh interval (default 60 seconds) [README]

Configuration:

Full YAML config file support with commented example in the repo [README]
Environment variable configuration for Docker deployments [README]
Session-Cookie authentication with bcrypt password hashing (optional, off by default) [README]
Configurable session expiration (default 7 days) [README]

Deployment options:

Docker single-container run [README]
Docker Compose [README]
Binary installation (no Docker required) [README]
Local network mode via companion node-bootstrap container (serves themes, icons, fonts offline) [README]
Docker socket integration for auto-populating panels from running containers [README]

What it doesn’t have:

Multi-user support — one set of credentials for the whole instance
Service-aware integrations (no Sonarr stats, Plex playback count, etc.)
Widget/applet system
Mobile-optimized layout
Search functionality
Metrics or graphs beyond uptime yes/no

Pricing: self-hosted math

miniboard is purely a self-hosted tool with no cloud offering. There is no SaaS tier to compare against.

The hosting cost is whatever you already pay for the machine running your other containers. If you’re adding miniboard to an existing homelab or VPS, the marginal cost is effectively $0 — the Go binary uses negligible CPU and single-digit MB of RAM at idle.

If you’re starting from scratch specifically to run miniboard, a $5–6/mo Hetzner or Contabo VPS is sufficient. But at that point, the honest answer is that you’re not running miniboard for the economics — you’re running it because you want a self-hosted bookmark page.

The relevant cost comparison isn’t miniboard-vs-something, it’s: is it worth your time to set this up versus using a browser bookmark folder? The answer is yes if you want uptime monitoring alongside your links, multiple people (household, team) accessing the same dashboard, or a visual starting page that’s more organized than your browser’s new tab page.

Deployment reality check

What you need:

Docker and docker-compose, or a Go toolchain to build the binary
A Linux machine with basically any amount of RAM — the container image is small [README]
A domain/subdomain + reverse proxy (Caddy or nginx) if you want it accessible outside localhost
No external database: SQLite is bundled [README]
No Redis, no PostgreSQL, no separate cache — single process, single file

Setup time: This is one of the simpler self-hosted tools you’ll encounter. The quick start is a single docker run command [README]. Docker Compose setup adds two minutes. For a technical user, you’re at a working dashboard in under 15 minutes. For someone following a guide for the first time, budget 30–60 minutes including reverse proxy and domain setup.

The node-bootstrap caveat: By default, miniboard loads Bootstrap themes, icons, and fonts from the internet (CDNs). If you’re running an air-gapped network or want zero external dependencies, you need to also run the companion aceberg/node-bootstrap container and pass its address via the -n flag [README]. This isn’t documented as prominently as it should be — you won’t discover you need it until you notice CSS failing to load on a restricted network.

Authentication: Auth is disabled by default. If you’re exposing miniboard to the internet (e.g., on a public VPS), you need to explicitly enable it via AUTH=true and configure a bcrypt password. The README links to a separate doc on bcrypt password generation [README]. It’s a two-step setup, not automatic — forgetting this step on a public deployment is a real risk.

Development status: The last commit was in late 2023. There are 88 total commits in the project’s history. No issues are linked from the README, and the repository shows one watcher (presumably the author). This means bugs you encounter are unlikely to be fixed quickly, and new features won’t appear. If you need an actively maintained dashboard with a community, this isn’t it.

Pros and cons

Pros

Genuinely lightweight. Go binary + SQLite means minimal RAM and CPU. Doesn’t compete for resources with the services it’s monitoring [README].
MIT license. No usage restrictions, no commercial licensing games, no “fair-code” ambiguity [GitHub].
Dual config system. GUI for quick setup, YAML for version-controlled infrastructure-as-code. Most dashboards force one or the other [README].
Local network mode. Run completely offline — no CDN dependencies once you set up the companion node-bootstrap container [README].
Docker socket auto-discovery. Mount the socket and miniboard can read your running containers to pre-populate a panel — saves manual bookmarking [README].
Simple auth. Session-Cookie + bcrypt is not fancy, but it’s solid and built-in [README].
15 releases suggest the author actually shipped and iterated, even if slowly [GitHub].

Cons

Last release December 2023. Development appears stalled. If you hit a bug, you’re on your own or submitting a PR [GitHub].
235 stars, 12 forks, 1 watcher. Tiny community. No active forum, no Reddit presence, no Discord. Troubleshooting means reading the README and the source code [GitHub].
No service widgets. Can’t show Sonarr download queue, Plex now-playing, Home Assistant sensors, Pi-hole stats. Just links + uptime [README].
No search. Dozens of bookmarks across multiple panels means scrolling, not typing [README].
Auth is off by default. A forgettable gotcha for anyone exposing this publicly [README].
External CDN dependency by default. Themes and icons load from the internet unless you set up the companion container [README].
Single-user authentication. One username, one password — no per-user login, no roles, no guest mode [README].
Bootstrap aesthetic. The themes are functional but dated. Bootswatch themes look like 2015-era web apps. If you care about how your homelab homepage looks, alternatives like Homepage or Homarr have more modern UIs.

Who should use this / who shouldn’t

Use miniboard if:

You want the lightest possible dashboard that doesn’t noticeably add to your server’s load.
You need local/air-gapped operation with zero internet dependencies once set up.
You prefer YAML config you can commit to git, but also want a GUI fallback for quick edits.
You’re building a homelab on a Raspberry Pi or a very small VPS where RAM is genuinely constrained.
Your needs are “show me my bookmarks + are my services up” — nothing more.

Skip it (pick Homepage / gethomepage.dev instead) if:

You want service integrations — Sonarr, Radarr, Plex, Pi-hole stats, etc.
You want an actively maintained project with a large community and regular updates.
You want a more modern-looking UI.

Skip it (pick Homarr instead) if:

You want a more polished UX with drag-and-drop, widgets, and Docker integration that goes deeper than auto-discovery.
You want something your non-technical partner or family members can use without confusion.

Skip it (pick Dashy instead) if:

You want maximum configurability — custom CSS, advanced YAML schema, search, dozens of widget types.
You’re willing to pay the RAM cost for a Vue.js app in exchange for more features.

Skip it (keep browser bookmarks) if:

You have fewer than 10 services to track and no need for uptime monitoring. The setup overhead isn’t worth it.

Alternatives worth considering

Based on the self-hosted dashboard category:

Homepage (gethomepage.dev) — The current community favorite. 20K+ GitHub stars, actively maintained, service widget integrations for dozens of apps, YAML-configured. More setup required but dramatically more capable. https://github.com/gethomepage/homepage
Homarr — React-based, drag-and-drop layout, Docker integration, service widgets, active development. More resource-hungry than miniboard but much more featured. https://github.com/ajnart/homarr
Dashy — Vue.js, highly customizable via YAML, search, custom CSS, large feature set. Larger memory footprint. https://github.com/Lissy93/dashy
Homer — Static YAML-only dashboard, zero JavaScript framework, extremely fast. No uptime monitoring, no GUI. https://github.com/bastienwirtz/homer
Flame — Minimalist, bookmark + search focus, Docker auto-discovery. Less active development. https://github.com/pawelmalak/flame
Organizr — PHP-based, multi-user, PLEX-adjacent homelab focus. Significantly more complex to deploy. https://github.com/causefx/Organizr

For most self-hosters evaluating miniboard, the realistic decision is miniboard vs Homer vs Homepage: pick miniboard if you want the GUI + uptime monitoring combo without committing to a heavier stack; pick Homer if you’re YAML-only and don’t need uptime checks; pick Homepage if you want service widget integrations and an active community.

Bottom line

miniboard is a niche tool for a specific kind of self-hoster: someone who wants a fast, no-frills Go binary that shows bookmarks organized by tabs with basic HTTP uptime monitoring, runs on almost nothing, and can work completely offline. It does that job without complaint. The YAML-or-GUI config system is genuinely useful, the MIT license is clean, and the Docker socket auto-discovery saves real time.

The honest caveat is that this looks like an abandoned project. Last release was December 2023, 235 stars, 88 total commits, one watcher. If you deploy it today it will probably keep working — Go binaries compiled against SQLite don’t break — but don’t expect feature additions or bug fixes. The self-hosted dashboard space has moved on to more polished options like Homepage and Homarr, both of which have larger communities and active development. For a new homelab setup in 2026, those are the stronger recommendations. miniboard earns a look only if resource constraints are tight or you specifically want offline-capable operation with zero external dependencies.

Sources

All factual claims in this article are sourced from the project’s own GitHub repository and README. No independent third-party reviews of miniboard were found; the scraping pipeline returned unrelated ChatGPT content for citations [1]–[3], which were discarded.

Primary sources:

GitHub repository and README — https://github.com/aceberg/miniboard (235 stars, MIT license, single developer, last release December 24, 2023)
Docker Hub — https://hub.docker.com/r/aceberg/miniboard