Best Self-hosted Alternatives to Pulsetic

Gatus is a developer-oriented health monitoring dashboard and automated status page for tracking the availability and performance of services. It runs scheduled checks against endpoints and evaluates results with flexible conditions, then visualizes current status and historical uptime.

Key Features

• Monitors endpoints using HTTP, TCP, ICMP, and DNS checks
• Powerful condition system to validate status codes, response time, response body, TLS certificate expiration, and more
• Built-in status page UI with service grouping and incident/announcement-style updates
• Alerting to multiple notification providers (including chat, email, and incident management platforms)
• Exposes metrics for integration with monitoring stacks
• Low resource footprint and simple configuration

Use Cases

• Public or internal status pages for production services and dependencies
• Proactive uptime monitoring for APIs, websites, and infrastructure endpoints
• Synthetic checks for user-acceptance-style validation of critical flows

Gatus is well-suited for teams that want a lightweight but highly configurable monitoring-driven status page, with alerting and clear visibility into service health over time.

Kener is a sleek, lightweight system for hosting public status pages with built-in monitoring and incident management. It’s designed to be easy to deploy, simple to operate, and flexible to brand for your organization.

Key Features

• Public status pages for services, websites, and APIs
• Endpoint monitoring via HTTP polling and data submission via REST APIs
• Cron-based scheduling (as frequent as every minute) and monitor grouping into sections
• Incident tracking and communication, with APIs for incident workflows
• Customization options including theming (light/dark), internationalization, and embeddable widgets/iframes
• Badge generation for status and uptime reporting
• Server-side rendering for performance and SEO-friendly pages
• Docker-ready deployment with prebuilt images

Use Cases

• Publish a customer-facing status page for SaaS, APIs, and internal services
• Track outages and communicate incidents and maintenance windows
• Embed live status widgets or badges into documentation or product sites

Limitations and Considerations

• Not intended to replace full observability suites (for example, end-to-end APM platforms)

Kener is a strong fit when you want a modern, attractive status page with essential monitoring and incident tooling included. It emphasizes fast setup, a clean UI, and practical features without heavy operational overhead.

Statping-ng is a status page and uptime monitoring server for websites and applications. It performs health checks for common protocols and presents results on a public-facing status page with metrics and history.

Key Features

• Monitoring for HTTP, TCP, UDP, ICMP, and gRPC services
• Public status page with service groups, incidents/messages, and historical uptime
• Dashboard with charts, analytics, and response time tracking
• Notifications via multiple notifiers (including SMTP email and popular chat/webhook platforms)
• RESTful API and API secret for integrations
• Prometheus metrics exporter for external monitoring systems
• Customizable UI theming using Sass
• Runs as a single Go binary or via Docker and docker-compose (optional reverse proxy and TLS automation)

Use Cases

• Public status page for SaaS, APIs, and internal platform services
• Uptime monitoring for homelabs, microservices, and edge endpoints
• Exporting service health metrics to Prometheus-based observability stacks

Limitations and Considerations

• The mobile app compatibility is provided, but the app itself is maintained separately and may include in-app purchases

Statping-ng is well suited for teams that want a lightweight, easily deployable monitoring server with a clean status page, flexible notifications, and integration-friendly APIs. Its plugin and notifier approach makes it adaptable for many operational workflows.

SmokePing is an active monitoring system for measuring network latency, latency variation (jitter), and packet loss. It continuously runs probes, stores long-term time-series results, and presents interactive graphs via a web interface.

Key Features

• Measures latency, latency distribution, jitter, and packet loss over time
• RRDtool-based long-term datastore and graph generation
• Extensible probe architecture (from ICMP ping to HTTP and custom protocols)
• Configurable alarm system that triggers on defined latency patterns
• Master/slave model to run measurements from multiple source locations
• Web UI with CGI rendering and Ajax-based interactive graph navigation/zooming
• Customizable presentation via web templates and configuration

Use Cases

• Track ISP or site-to-site link quality and detect intermittent packet loss
• Compare latency to the same targets from multiple locations using distributed probes
• Alert on recurring latency spikes that impact voice, video, or critical services

SmokePing is a mature choice for long-term visibility into network performance, combining flexible probing, efficient time-series storage, and clear visualization. It fits well in NOC, homelab, and multi-site environments where understanding latency patterns matters.

CoreControl is a self-hosted dashboard that helps you organize and manage your server infrastructure from a single web UI. It combines server inventory, application listing, and availability tracking to provide a clear overview of a homelab or small infrastructure setup.

Key Features

• Central dashboard for at-a-glance infrastructure overview
• Server inventory with hardware information and quick links to management panels
• Applications list with quick access links and uptime monitoring
• Uptime history tracking and notifications
• Network visualization with generated network flowcharts
• Agent-based data collection component for monitored servers

Use Cases

• Maintain a single inventory of servers and management endpoints for a homelab
• Track uptime for self-hosted services and get notified about outages
• Document and visualize network layout for small infrastructures

Limitations and Considerations

• Some dashboard areas are marked as work in progress and may change over time
• Advanced network flowchart customization is still on the roadmap

CoreControl is a good fit if you want a lightweight, centralized view of servers and self-hosted applications with built-in uptime tracking. Its focus is on simplifying infrastructure visibility and quick access rather than replacing full enterprise monitoring suites.

Peekaping is an open-source, self-hosted uptime monitoring and status page platform built for monitoring websites, APIs, and internal services. It provides an API-first design and flexible storage backends to fit lightweight or production deployments.

Key Features

• Multiple monitor types including HTTP/HTTPS, TCP, ICMP ping, DNS, and push (webhook) heartbeats
• Infrastructure and service checks such as Docker container health, gRPC, and SNMP polling
• Database and broker monitoring (e.g., PostgreSQL, MongoDB, Redis, MQTT, RabbitMQ, Kafka)
• Alerting via many channels including SMTP email, webhooks, and popular chat/on-call tools
• Public status pages and SVG status badges for transparent uptime reporting
• Security features such as multi-factor authentication, brute-force protection, and SSL certificate expiration checks
• API-first architecture with OpenAPI/Swagger support for integrations and automation
• Pluggable data storage options: SQLite, PostgreSQL, and MongoDB

Use Cases

• Monitor public websites and APIs and notify teams immediately on outages
• Track internal infrastructure components (containers, databases, brokers) for early incident detection
• Publish customer-facing or internal status pages to reduce support load and improve transparency

Limitations and Considerations

• The project is in beta and some features and behavior may change
• Migration tooling from Uptime Kuma is not yet fully available

Peekaping is well-suited for small teams and growing environments that want ownership of monitoring data, strong extensibility, and a modern UI. Its wide monitor coverage and alert integrations make it a practical alternative to traditional uptime monitors.

Kuvasz is an open-source, self-hosted uptime and SSL monitoring service that helps teams track availability, response times, and certificate health. It provides a modern web UI, a full REST API, and integrations for metrics and alerting to fit into existing observability stacks.

Key Features

• HTTP(S) monitoring with configurable intervals, custom headers, body, status matching, and response time checks
• SSL/TLS certificate monitoring with advance expiry alerts
• Push (heartbeat/cron) monitors for scheduled jobs and non-pollable checks
• Per-monitor notification channels including email, Discord, Slack, Telegram, and PagerDuty
• Brandable public or private status pages for communicating incidents
• Full REST API for managing monitors, checks, and status pages programmatically
• Metrics exporters for Prometheus and OpenTelemetry (OTLP) for integration with existing monitoring
• YAML-based IAC support and backup/export capabilities for configuration-as-code
• Distributed deployment as a single Docker image; requires PostgreSQL as the primary data store

Use Cases

• Monitor websites, APIs, and services for uptime, latency regressions, and SSL expirations
• Publish status pages to inform customers or internal teams about incidents and maintenance
• Export metrics to Prometheus or OTLP pipelines and integrate alerts into existing incident workflows

Limitations and Considerations

• Native port, DNS, and domain-expiration monitoring are not available or are limited compared to some hosted competitors
• ICMP (ping) and some advanced network checks are not first-class features out of the box
• SMS/voice notifications require external paid providers; some integrations are planned but may be incomplete
• High-frequency checks (e.g., 5s intervals) increase resource usage; plan JVM and database capacity accordingly

Kuvasz is a focused uptime and certificate monitoring solution that integrates with observability tooling and supports configuration-as-code. It is well suited for teams that need status pages, per-monitor notifications, and Prometheus/OTLP integration while operating in self-hosted environments.

miniboard is a lightweight dashboard application written in Go that provides tabs, panels and simple uptime monitoring with notifications. Configuration can be done through the web GUI or a YAML file, and it is distributed as a Docker image or a single binary.

Key Features

• Lightweight Go backend with an HTML/Bootstrap frontend and small resource footprint
• Panels and tabs to organize hosts, services and links into customizable boards
• Built-in uptime monitoring that records status history in a local SQLite database
• Configurable notifications and alerting for monitored hosts
• Configure via web GUI or YAML file; environment variables and CLI options available
• Optional Docker socket integration to create panels from running containers
• Themes support (Bootswatch) and options for offline/local assets to avoid external requests

Use Cases

• Personal or home-lab startpage showing service status and quick links
• Small-team status board for basic uptime and availability monitoring
• Lightweight alternative to larger dashboard systems for monitoring a few hosts or services

Limitations and Considerations

• Uses SQLite for storage, which is suitable for small deployments but not for large-scale monitoring
• Authentication is basic (session cookie with bcrypt password support); no built-in OAuth/SSO providers
• By default the frontend pulls themes and fonts from the Internet; additional setup is required for fully offline/local deployments

miniboard is targeted at users who need a simple, low-maintenance dashboard and uptime monitor for small environments. It emphasizes ease of setup, local configuration and minimal dependencies while providing basic alerting and visual organization of services.

Meshping is a lightweight network monitoring service that concurrently pings multiple targets and records detailed latency histograms. It runs traceroutes, performs Path MTU discovery for each hop, and renders visual maps and heatmaps to help locate weak links and routing issues.

Key Features

• Concurrent ICMP probing of many targets with per-target latency histograms (not simple averages)
• Traceroute integration with hop-by-hop Path MTU discovery and AS information
• SVG network topology maps that highlight outage locations and routing loops
• Heatmaps and histogram visualizations for spotting multimodal latency distributions
• Prometheus-compatible /metrics endpoint for scraping and integration with existing monitoring stacks
• Dynamic target management (add/remove targets at runtime) and optional peering between Meshping instances
• Docker images and a simple web UI including a mobile-friendly layout

Use Cases

• Troubleshooting WAN and datacenter connectivity by pinpointing where latency or packet loss occurs
• Comparing latency across multiple endpoints or monitoring locations for capacity planning and performance trends
• Distributed measurements via peered Meshping instances to observe end-to-end behavior from multiple vantage points

Limitations and Considerations

• ICMP probing and traceroute functionality require privileges or container capabilities (e.g., CAP_NET_RAW) to send raw packets
• Default local storage uses SQLite, which may not scale for very large deployments or extremely high sampling rates
• Meshping focuses on measurement and visualization; it has no built-in advanced alerting engine and relies on Prometheus or external tools for alerting
• When deployed behind some proxies, specific proxy settings may be required for good UI responsiveness

Meshping is suited for network operators and engineers who need detailed, visual latency and path visibility without heavy infrastructure. It complements metric and alerting stacks by providing raw-response histograms, traceroutes, and topology visualizations for root-cause analysis.