Self-hosted uptime monitoring & status pages.

Netra Uptime is a single-container Go and Svelte monitoring platform backed by PostgreSQL or embedded SQLite with thread-safe in-memory caching. Track HTTP, TCP, Ping, SSL, and domain expiry, manage incidents automatically, and route alerts to Slack, Discord, email, or webhooks.

Read Documentation API Reference GitHub Repository
$ npx netra-uptime start
Starts web UI and workers on localhost:27346 Manual Docker setup
  • api.acme.dev
    HTTP / 140ms / 99.98%
  • auth.acme.dev
    HTTP / 80ms / 100.00%
  • db-primary:5432
    TCP / 5ms / 99.99%
  • edge-sg-1
    PING / 36ms / 99.95%
  • checkout.acme.dev
    HTTP / 239ms / 99.91%
  • smtp.acme.dev:587
    TCP / 28ms / 100.00%
  • cdn.acme.dev
    HTTP / 71ms / 99.99%
  • status.acme.dev
    HTTP / 85ms / 100.00%
http://localhost:27346/dashboard
Netra Uptime dashboard overview

Quick Start & CLI

Initialize configuration and launch containers with a single command.

Docker Compose

Production topology, persistent volumes, and database backup guides.

System Architecture

Go worker pool, alert state machine, and in-memory caching internals.

REST API Reference

Interactive endpoint specifications, authentication scopes, and curl examples.

Everything reliability needs, in one binary.

Core monitoring, incident management, alerting, and public status pages compiled into a single deployment.

Explore all capabilities

Real-time monitor telemetry

Monitors documentation

Track response times, uptime ratios, and check history across all endpoints in a live WebSocket-driven dashboard. Trigger manual checks on demand.

Real-time monitor telemetry screenshot

Public status pages

Status page guide

Publish 90-day uptime bars, component groups, scheduled maintenance windows, and machine-readable JSON feeds on custom subdomains.

Public status pages screenshot

Automatic incident timelines

Incident lifecycle docs

Incidents open on breach and resolve automatically upon recovery. Assign a Person-in-Charge and record timestamped status transitions.

Automatic incident timelines screenshot

Template-first alert rules

Alert rules guide

Evaluate status codes, latency thresholds, and timeouts with consecutive breach counters to eliminate false-positive alert fatigue.

Template-first alert rules screenshot

Multi-protocol checks

HTTP/HTTPS status and latency assertions, TCP port handshakes, and unprivileged Ping reachability probes.

SSL & domain expiry

Daily background worker tracking TLS certificate chains and WHOIS/RDAP domain expiration.

Multi-channel dispatch

Deliver alerts to Slack, Discord, SMTP email, and SSRF-protected custom HTTP webhooks.

Strict RBAC & API keys

Multi-tenant organizations with Owner, Admin, and Member roles plus scoped REST API keys.

Interactive simulation

Break it on purpose. Watch Netra respond.

Trigger an outage and follow the alert state machine in real time: consecutive breach counting, automatic incident lifecycle, and multi-channel dispatch. Restore early to see false positives suppressed.

How alert evaluation works
api.acme.dev HTTP

GET /health / every 30s / threshold 3 breaches

Operational

Uptime (window)

100.00%

Avg latency

98ms

Breach counter

-20m now / 09:41:00

1 tick = 1 check (30s simulated)

Event stream

ws://localhost:27346

  1. GET /health 200 OK / 254ms

    09:41:00

  2. GET /health 200 OK / 74ms

    09:40:30

  3. GET /health 200 OK / 96ms

    09:40:00
Slack Idle
Discord Idle
Status page Idle

Engineered for predictable self-hosting.

A single Go binary serving the REST API, concurrent check workers, and compiled Svelte frontend, backed by PostgreSQL or SQLite with zero external cache dependencies.

Read system architecture
Go Worker Pool

Monitoring Engine

Deterministic tick scheduler and bounded goroutine worker pool executing HTTP, TCP, and unprivileged Ping probes concurrently.

Rule Evaluator

Alert State Machine

Separates amber timeouts from red connection failures and enforces consecutive breach counts before opening incidents.

PostgreSQL / SQLite

Data & 90-Day Rollup

Stores incidents, audit trails, and check results with automated hourly aggregation to keep 90-day queries fast.

Go MemoryCache + WS

Cache & Live Socket

In-process thread-safe read-through caching, sliding-window rate limiting, and room-isolated WebSocket broadcasting.

Alert routing & notification dispatch

Route each monitor to specific channels and assign a Person-in-Charge. Every dispatch attempt is recorded for auditability.

Channels overview
Slack

Block Kit payloads with target URL, failure reason, and incident link.

Discord

Color-coded rich embeds for incident open, degraded, and resolved states.

Email (SMTP)

HTML incident and recovery notifications over your own SMTP relay.

Custom Webhooks

Structured JSON events with strict private-network SSRF protection.

Common questions.

Answers on deployment, monitoring protocols, alert rules, data retention, and licensing.

Read full documentation Open an issue on GitHub

Run "npx netra-uptime start" (or pnpm dlx, yarn dlx, bunx) to generate a production-ready .env and docker-compose.yml with secure random credentials in ~/.netra-uptime and start the 2-service stack (postgres + netra-uptime with built-in in-memory caching). The CLI provides full lifecycle management: start, stop, status, logs, update, and credentials. You can also deploy Netra Uptime as a standalone single-binary with embedded SQLite (DB_DRIVER=sqlite) or clone the repository and run "docker compose up -d" manually.