Gatus is a self-hosted, developer-focused status page and monitoring tool designed to proactively detect service failures before users are impacted. Unlike traditional metric-based monitors that rely on incoming traffic, Gatus actively probes endpoints using HTTP, ICMP, TCP, DNS, and other protocols to verify service health. It was created to solve the gap where tools like Prometheus or CloudWatch fail to detect outages when no client traffic is present—such as a load balancer failure or an unresponsive API. This makes it ideal for DevOps teams and infrastructure engineers who need to ensure critical services remain available without waiting for user reports.
Built in Go, Gatus offers a lightweight, low-resource footprint with a clean web dashboard and support for real-time alerting across 30+ platforms including Slack, PagerDuty, Discord, and email. Its configuration is YAML-based and human-readable, enabling quick setup for monitoring everything from web APIs to DNS records and TLS certificate expirations. The tool is designed for self-hosting via Docker, Helm, or direct binary installation and includes features like badges, API access, and dynamic configuration reloading.
What You Get
- Multi-protocol health checks - Monitor endpoints via HTTP, HTTPS, ICMP, TCP, DNS, SSH, STARTTLS, TLS, WebSocket, gRPC, and SCTP with customizable conditions like status code, response time, response body content, certificate expiration, and IP address.
- Advanced condition evaluation - Use expressions like “[STATUS] == 200” or “[BODY].status == UP” to define precise health criteria, including JSON path evaluation and response time thresholds.
- Multi-channel alerting - Send alerts to Slack, PagerDuty, Discord, Teams (Workflow), Twilio, Email, Mattermost, Google Chat, Opsgenie, Ntfy, Signal, and 20+ other platforms with full configuration examples.
- Interactive dashboard & badges - View real-time status with dark mode support and generate embeddable uptime/response time badges for READMEs or internal wikis using URLs like /api/v1/endpoints/{name}/uptimes/7d/badge.svg.
- Dynamic configuration & reloading - Modify your config.yml without restarting the service; changes are reloaded automatically or via API endpoint.
- API and metrics exposure - Expose monitoring data via a RESTful API for programmatic access, with support for custom labels in Prometheus-style metrics.
- Self-hosted and lightweight - Runs as a single binary or Docker container with minimal resource usage, ideal for Kubernetes, VMs, or edge environments.
- TLS and authentication support - Secure your dashboard with Basic Auth or OIDC integration, and enable TLS encryption for secure access.
Common Use Cases
- Building a reliable SaaS status page - A DevOps team monitors 50+ microservices across AWS and GCP using HTTP health checks and TCP port scans, sending alerts to Slack channels when any endpoint fails, ensuring SLAs are met without user complaints.
- Monitoring critical infrastructure before users notice - An engineer configures Gatus to ping their load balancer’s health endpoint every 60 seconds; when the endpoint returns 503, an alert is sent to PagerDuty before customers report downtime.
- Automated UAT for APIs - A QA team uses Gatus to validate that a new API deployment returns the correct JSON structure and response time under 200ms, using conditions on [BODY].data and [RESPONSE_TIME] to pass/fail automated tests.
- DevOps teams managing hybrid cloud environments - Teams monitor DNS records, TLS expiration dates, and TCP connectivity across on-prem servers and cloud instances using a single unified dashboard, reducing tool sprawl.
- Problem → Solution flow: No alerts during load balancer outage → Gatus detects failure via active probe - Traditional monitoring misses outages when traffic drops; Gatus proactively checks endpoints and triggers alerts via SMS (Twilio) or email, enabling faster incident response.
- Team/workflow scenario: Remote engineers maintaining public-facing APIs - A distributed team uses Gatus to monitor 10+ customer-facing endpoints with badges embedded in their internal docs, and receives Slack alerts when a third-party dependency goes down.
Under The Hood
Gatus is a Go-based monitoring and status page solution that enables users to track endpoint availability and generate real-time status pages with flexible alerting mechanisms. It emphasizes configuration-driven design and extensibility, supporting a wide range of monitoring and notification providers.
Architecture
Gatus follows a layered architecture with well-defined modules for configuration, endpoints, alerts, and storage, enabling clear separation of concerns.
- The application uses a strategy pattern for alerting providers and a factory pattern for configuration loading, promoting flexibility and modularity
- Configuration-driven design allows dynamic extension of monitoring and alerting capabilities without code changes
- Dependency injection and validation patterns ensure robust interaction between components and maintain data integrity
- Core monitoring logic is separated from external integrations, supporting scalable and maintainable architecture
Tech Stack
Built with Go as the primary backend language and Vue.js for the frontend, Gatus leverages modern web and backend technologies.
- The backend is powered by Go with extensive use of standard library features and third-party modules for configuration, HTTP handling, and storage
- The frontend is built with Vue.js, utilizing component-based architecture for a responsive user interface
- Docker and Makefile are used for containerization and build automation, while Go’s built-in testing framework ensures code reliability
- Integration with various alerting providers and external services is handled through dedicated modules and plugins
Code Quality
Gatus demonstrates solid code quality with consistent Go idioms and a well-structured modular approach.
- The project uses Go’s built-in testing framework with comprehensive coverage across core modules and configuration handling
- Error handling is implemented consistently, with clear validation patterns ensuring data integrity across components
- Code style and naming conventions are mostly consistent, supporting maintainability and readability for developers
- Extensive use of interfaces and dependency injection contributes to a clean, extensible codebase with minimal duplication
What Makes It Unique
Gatus stands out through its modular architecture and extensive support for diverse alerting providers and configuration options.
- The system abstracts monitoring and alerting into configurable, pluggable modules that support a wide variety of providers and notification channels
- It enables real-time status page generation with minimal configuration overhead, making it highly accessible for teams
- The combination of backend and frontend technologies creates a full-stack solution with a clean API and extensible design
- Its configuration-driven approach allows for rapid deployment and customization without requiring code modifications