Checkmate

Checkmate is an open-source, self-hosted monitoring platform built for DevOps teams and system administrators who need full visibility into server uptime, hardware health, and application performance without surrendering data to a SaaS vendor. It monitors HTTP endpoints, TCP ports, ping targets, SSL certificates, Docker containers, gRPC services, WebSocket connections, and game servers from a single unified dashboard, and optionally deploys the lightweight Capture agent to stream CPU, RAM, disk, and temperature metrics from remote machines running Linux, Windows, macOS, or Raspberry Pi.

The platform supports distributed geo-checking powered by GlobalPing, letting you verify endpoint reachability from multiple continents without operating your own probe infrastructure. When a monitor changes state — going down, breaching a hardware threshold, or recovering — Checkmate automatically creates or resolves incidents and fires notifications through email, Slack, Discord, PagerDuty, Microsoft Teams, Telegram, Pushover, Twilio SMS, ntfy, webhooks, and Matrix. Public status pages with four themes let teams communicate outages to end users in real time.

Checkmate has been stress-tested with 1,000+ simultaneous active monitors and ships with Helm charts for Kubernetes, Docker Compose configurations for production and staging, and one-click deployment on PikaPods, Coolify, Elestio, and Cloudzy. The entire stack — React frontend, Node.js/Express backend, and MongoDB — can run on a single Docker host with minimal memory requirements, making it practical for home lab operators and enterprise teams alike.

The project is under active development with releases approximately every two weeks, a 10,000-star GitHub following, 129 contributors, and a welcoming community on Discord. The AGPL-3.0 license means the source is fully open, with a hosted demo available at demo.checkmate.so.

What You Get

• HTTP/HTTPS Uptime Monitoring - Checks endpoints at configurable intervals, records response times, tracks status history, and supports JSON path validation to verify API response content.
• Infrastructure Hardware Monitoring - Deploys the Capture agent on any Linux, Windows, macOS, or Raspberry Pi host to stream CPU usage, memory consumption, disk I/O, temperature, and network throughput in real time.
• Docker Container Monitoring - Tracks container health, resource utilization, and restart events without requiring changes to your existing container configurations.
• Multi-Protocol Checks - Monitors TCP ports, ping targets, gRPC services, WebSocket connections, and game servers (Minecraft, CS2, Valheim) alongside standard HTTP checks from a single interface.
• Global Geo-Checking via GlobalPing - Verifies endpoint reachability from probes across multiple continents and visualizes regional response times on an interactive MapLibre world map.
• SSL Certificate Expiry Monitoring - Alerts you days before certificates expire and displays remaining validity in the dashboard alongside other uptime metrics.
• PageSpeed Monitoring - Runs Lighthouse-based Core Web Vitals checks (LCP, FCP, CLS) and tracks performance trends over day, week, and month date ranges.
• Public Status Pages - Generates branded status dashboards in four themes to communicate service health to end users during incidents.
• Incident Management - Automatically creates and resolves incidents on monitor state changes, with a dedicated incidents view, action buttons, and detail modals for triaging issues.
• Multi-Channel Notifications - Sends alerts via email, Slack, Discord, PagerDuty, Microsoft Teams, Telegram, Pushover, Twilio SMS, ntfy, Matrix, and custom webhooks.
• Scheduled Maintenance Windows - Suppresses alerts during planned downtime windows configured per monitor, preventing false positive notifications.
• Role-Based Access Control - Supports Superadmin, Admin, Editor, and Viewer roles with team member management, password resets, and email invitations.

Common Use Cases

• SaaS platform reliability - A startup configures HTTP checks for API endpoints and database health probes, enables Slack notifications for on-call engineers, and publishes a public status page so customers can self-serve during incidents.
• Home lab and Raspberry Pi cluster management - A hobbyist deploys Checkmate and Capture agents on a cluster of Raspberry Pis running Home Assistant and Plex, receiving email alerts when CPU temperatures spike or disks fill.
• Multi-region service verification - A distributed web application team uses GlobalPing geo-checks to confirm their CDN-fronted endpoints respond correctly from Europe, Asia, and the Americas, catching regional routing failures before users report them.
• Game server hosting operations - A game hosting provider monitors dozens of Minecraft and CS2 servers for uptime, player count, and hardware resource usage, using the Capture agent to detect memory leaks before they cause crashes.
• Data-sovereignty compliance - A European financial services firm self-hosts Checkmate on-premises to avoid sending monitoring telemetry outside controlled infrastructure, satisfying internal data residency requirements while monitoring internal API gateways.
• DevOps pipeline visibility - A platform engineering team uses Docker monitoring and port checks alongside HTTP monitors to track the health of database replicas, Redis clusters, and microservice sidecars across multiple Docker hosts.

Under The Hood

Architecture

Checkmate is a well-layered monorepo with a Node.js/Express backend and a React frontend that are clearly separated. The backend follows domain-driven design: each concern — monitors, checks, incidents, notifications, status pages, maintenance windows, geo-checks — lives in its own domain folder with a typed interface, a Mongoose model, a repository implementation, and a service class. The worker subsystem uses a three-stage pipeline — producer (executes the network check), evaluator (applies the monitor status policy to determine state transitions), and reactor dispatcher (fans out to blocking and non-blocking reactors for incident creation and notification delivery) — which makes the side-effect chain independently testable and easy to extend without modifying core evaluation logic.

Tech Stack

The backend runs on Node.js with Express, MongoDB via Mongoose, and Winston for structured logging. The network service layer implements a provider pattern with dedicated classes for HTTP, Ping, Port, Docker, gRPC, WebSocket, PageSpeed, Hardware, Game, and GlobalPing protocols behind a shared interface, making protocol additions surgical rather than cross-cutting. JWT authentication, Zod-based request validation, rate limiting via express-rate-limit, and body sanitization are applied as Express middleware. The frontend is React 18 with MUI v7 for component primitives, Redux Toolkit and redux-persist for state management, SWR for data fetching with deduplication and retry, React Hook Form and Zod for forms, Recharts and MUI X Charts for time-series visualization, and MapLibre GL for the geo-check world map. The entire stack is TypeScript end-to-end.

Code Quality

The test suite is comprehensive: over 10,000 lines of unit tests cover every service and most utilities, with Jest and mongodb-memory-server providing in-process integration tests for the full database lifecycle. TypeScript is used in strict mode across the server and client, and interface-driven design means all service dependencies are injected rather than imported directly, enabling clean mocking. ESLint and Prettier are enforced via Husky pre-commit hooks. OpenAPI documentation is auto-generated from Zod schemas using zod-to-openapi, keeping API contracts in sync with runtime validation without duplication. Error handling uses a typed AppError class with service and method metadata for structured log correlation.

What Makes It Unique

The reactor dispatcher pattern stands out as a deliberate architectural choice: after each monitor evaluation, results are fanned out to an ordered list of reactors — each implementing a minimal interface — that can be blocking or fire-and-forget. This lets the incident reactor and notification reactor operate independently, fail without aborting each other, and be composed without touching the evaluation pipeline. The GlobalPing integration is another differentiator: rather than requiring self-operated probe infrastructure for distributed uptime checks, Checkmate delegates to GlobalPing’s global network and aggregates results into a continent-grouped geo-check collection stored separately from standard checks, with a dedicated MapLibre visualization. The Capture agent, a separate Go binary, extends hardware monitoring to any device that runs Go — including Raspberry Pi and ARM boards — with sub-minute polling over a lightweight HTTP protocol.

Self-Hosting

Checkmate is licensed under the GNU Affero General Public License v3.0 (AGPL-3.0). In plain terms, this means you can use it commercially, modify it, and distribute it freely, but if you run a modified version as a network service — for example, offering it as a hosted monitoring product to third parties — you must release the source code of your modifications under the same license. For teams self-hosting Checkmate internally with no intention of offering it as a service to others, the copyleft clause has no practical effect. There is no commercial license exception, enterprise tier, or closed-source add-on; what you see on GitHub is the entire codebase.

Operating Checkmate yourself requires running three components: the Node.js/Express application server, a MongoDB instance, and optionally Redis (used in some deployment configurations). Docker Compose files for production and staging environments are included in the repo, and Helm charts for Kubernetes are provided in the charts directory. Deploying the Capture agent on each server you want hardware-monitored requires running a separate Go binary on those machines. You are responsible for backups of the MongoDB database, SSL certificate renewal for your Checkmate domain, keeping the application and its dependencies updated, and ensuring sufficient compute for your monitor count — though the project documents running 323 monitors on a single Node instance with a modest memory footprint.

The project does not offer a managed hosted tier, SLA guarantees, or commercial support contracts at this time. Community support is available through a Discord server with active participation from the core team, and GitHub Discussions for less time-sensitive questions. Compared to managed alternatives like UptimeRobot, BetterUptime, or Checkly, you trade away zero-ops hosting, guaranteed uptime for the monitoring infrastructure itself, and vendor-backed SLAs in exchange for full data ownership, no per-monitor pricing, and the ability to customize or extend the platform without restriction.