Monitoring & Analytics 1 service 512 MiB RAM 2 GB disk

Uptime Kuma

The beloved self-hosted uptime monitor - unlimited checks, 100+ notification providers, status pages - for $5/month.

One-click deploy, from $5/mo on a Miget plan.

Uptime Kuma is one of the most loved projects in self-hosting, and for a reason: it does one job - is my stuff up? - with a beautiful UI, sub-minute checks, and alerting to practically everything (Slack, Telegram, Discord, email, webhooks, PagerDuty, 100+ providers). Public status pages included.

This template runs v2 (the slim image: no embedded Chromium or MariaDB) with SQLite on a small volume - one 512 MiB container that comfortably watches everything you run. Monitors, history, and settings persist across redeploys; the first-boot wizard creates your admin account.

Hosted monitoring meters by monitor count - 10 here, 50 there, each tier a new invoice line. Kuma monitors as much as you like for the price of the container it runs in.

#what you get

  • HTTP(S), TCP, ping, DNS, keyword, JSON-query and certificate checks
  • Alerts to 100+ providers: Slack, Telegram, Discord, webhooks, SMTP, …
  • Public status pages with custom domains and incident banners
  • Sub-minute intervals, response-time charts, cert-expiry warnings
  • Slim v2 image + SQLite: ~512 MiB does the whole job
  • Swap to the full image for Chromium "real browser" monitors

#topology

ServiceRolePublic
uptime-kumamonitor + UI + status pages (:5000, websockets)yes

#miget sizing

// this stack needs

512 MiB RAM · 2 GB disk · 1 service

The slim image with SQLite is genuinely light - 512 MiB covers hundreds of monitors. Chromium-based browser checks need the full louislam/uptime-kuma:2 image and at least 1 GiB.

Hobby - recommended fit

$5/mo

1 vCPU · 512 MiB · 10 GiB disk

Headroom for your own apps: 1 GiB at $7/mo

Professional - production

$22/mo

1 vCPU · 2 GiB · 10 GiB disk

Dedicated resources, production SLOs - plan details

One Miget plan is a fixed pool of compute - the whole stack (managed databases included) deploys inside it, and anything left over runs your other apps. No per-service or per-seat math.

#vs. the managed service

What the hosted equivalents charge, against the flat Miget plan this stack fits on. Prices as of June 2026, sources linked.

ServicePlanMonthlyWhat you get
Uptime Kuma on Miget 512 MiB plan$5this whole stack, flat - no usage meters, and room left for your own apps
UptimeRobotSolo~$810 monitors at 60s intervals; more monitors = higher tiers
Better StackUptime (usage)~$25per 50-monitor bundle on top of the 10-monitor free tier; incident management seats $34/mo extra
PingdomSynthetics entry~$1010 uptime checks, 1 transaction check, 50 SMS alerts (annual billing)

Hosted plans meter by monitor count; Uptime Kuma monitors as much as you like for the price of the container it runs in.

#vs. other PaaS

Estimated monthly cost of running this exact stack (512 MiB RAM, 2 GB disk, 1 container) elsewhere, from published June 2026 rates.

PlatformEst. monthlyNotes
Miget $5 flat compose stacks first-class: one deploy, dedicated vCPU, managed Postgres/Valkey, volumes and TLS all included in the plan
Heroku ~$25 no volumes; nothing between 1 GB ($50) and 2.5 GB ($250) dynos - 2 GB containers cost far more than shown
DO App Platform ~$11 no persistent volumes - stateful containers need managed DBs/Spaces (base $5 Spaces included here)
Render ~$8 per-service instances (0.5 GB $7, 2 GB $25) - every container is its own paid service
Railway ~$5 usage-based ($10/GB RAM-mo); vCPU billed separately at $20/vCPU-mo on top
Fly.io ~$3 cheapest sticker price - but burstable shared CPUs (1/16 core; dedicated vCPUs cost ~2-3×), no compose deploys (one app per container, manual wiring), managed DBs billed extra

Estimates assume RAM fully allocated at published on-demand rates - and sticker price isn't the whole comparison: the cheaper rows buy burstable shared CPUs, per-service wiring instead of a compose deploy, and managed databases billed separately. Heroku and DO App Platform have no persistent volumes at all - stateful stacks like this one need workarounds there.

#deploy it

On Miget

  1. Create a Compose Stack in app.miget.com pointing at the templates repository
  2. Set the stack path to uptime-kuma
  3. No required variables - deploy as-is
  4. Deploy. Miget layers compose.miget.yaml (RAM, privacy, volumes, managed services) automatically

Locally first?

Every template is portable, vanilla Docker Compose - the Miget overrides are ignored locally:

git clone https://github.com/deployable-sh/stacks
cd miget-compose-templates/uptime-kuma
docker compose up -d

Same files, same behavior. The template README covers connection strings and scaling notes.

#faq

How does this compare to UptimeRobot or Better Stack pricing?

UptimeRobot Solo is $8/month for 10 monitors; Better Stack adds $25/month per 50 monitors. Uptime Kuma on the $5/month plan has no monitor count at all - and the status pages, multi-location-style checks, and SMS-grade alerting (via your providers) come with it.

Can Uptime Kuma monitor my other apps in the same project?

Yes, two ways: over their public domains (the real user-facing check), or privately by service name (http://my-api:5000/health) for internal services that have no public ingress - something hosted monitors physically cannot do.

What is different in Uptime Kuma v2?

v2 is the current stable line (2.x since early 2026): a first-boot setup wizard, optional MariaDB backend, better performance at high monitor counts. This template uses the slim image with SQLite, which is the right default for almost everyone.

Does it work behind the platform ingress?

Yes - the UI runs over websockets, which the ingress passes through, and the app gets its own domain (Kuma does not support subpath hosting, so a dedicated domain is exactly the right shape). Turn on "Trust Proxy" in Settings for correct client IPs.

Ship Uptime Kuma today

One compose stack, 512 MiB of RAM, from $5/month flat, and it runs on your laptop with the same files.