Pagerduty

Best Self Hosted Alternatives to Pagerduty

A curated collection of the 9 best self hosted alternatives to Pagerduty.

PagerDuty is a digital operations and incident response SaaS that provides real-time alerting, on-call scheduling, incident orchestration, and automation to detect, prioritize, and resolve IT and DevOps incidents.

Alternatives List

#1
Uptime Kuma

Uptime Kuma

Self-hosted uptime monitoring for websites, APIs, and services with status pages, rich notifications, and multi-protocol checks.

Uptime Kuma screenshot

Uptime Kuma is a self-hosted uptime monitoring tool for tracking availability and latency of websites, APIs, and network services. It provides a web dashboard to manage monitors, view history, and receive notifications when checks fail.

Key Features

  • Multiple monitor types (HTTP(s), TCP port, Ping, DNS, keyword search, etc.) to fit common availability checks
  • Configurable intervals, retries, timeouts, and status history for each monitor
  • Alerting via many notification providers (e.g., email/SMTP, Telegram, Discord, Slack, Webhooks, and more)
  • Public or private status pages with custom branding and incident-style visibility for selected monitors
  • TLS/SSL certificate expiry monitoring for HTTPS endpoints
  • Multi-user support with authentication and session management
  • Docker-based deployment support and lightweight standalone operation

Use Cases

  • Monitor public websites and APIs and alert on downtime or slow responses
  • Track internal services (databases, NAS, homelab apps) via TCP/Ping and centralize alerts
  • Publish a simple external status page for customers or internal stakeholders

Limitations and Considerations

  • It is primarily an availability/health checker and does not replace full observability stacks (logs/traces/metrics)

Uptime Kuma is a practical choice for individuals and teams needing an easy-to-operate monitoring dashboard with broad notification support. It suits homelabs and small-to-medium deployments where quick setup and clear uptime history are priorities.

81kstars
7.2kforks
View Details
#2
Novu

Novu

A self-hostable notification infrastructure to build, manage, and send multi-channel product notifications with templates, provider integrations, and a unified API.

Novu screenshot

Novu is an open-source notification infrastructure platform for building and managing product notifications across multiple channels (email, SMS, push, chat). It provides a unified API and an admin UI to create notification workflows, manage templates, and route messages through many third-party providers.

Key Features

  • Multi-channel notifications (e.g., email, SMS, push, chat) from a single API
  • Template management with a web-based UI for creating and maintaining notification content
  • Provider abstraction layer to switch between delivery providers without changing application code
  • Event-triggered workflows to orchestrate notification steps and channel fallbacks
  • Subscriber/user management for targeting and routing notifications
  • Preference management concepts for controlling which notifications users receive
  • Integrations for popular messaging/notification providers (varies by channel)
  • Developer-focused SDKs and APIs for embedding notification delivery into apps

Use Cases

  • Shipping transactional notifications (sign-up, password reset, receipts) across email/SMS
  • Product alerts and lifecycle messaging with channel fallback and centralized templates
  • Building an internal notification hub to standardize delivery providers across teams

Limitations and Considerations

  • Running the full platform typically requires multiple backing services (e.g., database, cache/queue), increasing operational complexity.

Novu fits teams that want control over notification logic and templates while keeping provider integrations modular. It is especially useful when multiple apps/services need consistent notification workflows and governance from one place.

38.4kstars
4.2kforks
View Details
#3
ntfy

ntfy

Self-hostable publish/subscribe notification service with HTTP API, web UI, and mobile apps for push alerts from scripts, CI, monitoring, and automations.

ntfy screenshot

ntfy is a lightweight publish/subscribe notification service that lets you send messages to topics via simple HTTP calls and receive them on phones, desktops, or the web. It is designed for automation-friendly alerts from scripts and systems, with optional authentication and multiple delivery integrations.

Key Features

  • Publish/subscribe topics with simple HTTP API (POST/PUT) and topic URLs
  • Web app and dedicated mobile apps for receiving notifications
  • Push notifications to Android (FCM) and iOS (APNs) when configured
  • Multiple subscription methods: web UI, mobile, and programmatic streaming (e.g., SSE/WebSockets)
  • Authentication and access control options (including users/roles and topic permissions)
  • Message options such as titles, priorities, tags, click actions, attachments, and icons (client-dependent)
  • Integrations for delivering outbound notifications (e.g., email, chat/webhooks) and acting as a relay/gateway
  • Docker-friendly deployment and configuration with support for reverse proxies and TLS

Use Cases

  • Monitoring/observability alerts (uptime checks, Prometheus Alertmanager-style notifications)
  • CI/CD and cron job outcomes (build failures, backup completion)
  • Smart home and automation events (doorbell/motion, device state changes)

Limitations and Considerations

  • Some advanced push capabilities (especially iOS/Android background delivery) depend on configuring platform push services (APNs/FCM) and may vary by client/device policies.

ntfy provides a practical “curl-to-phone” workflow while still supporting richer notification features and access controls for team or multi-service use. It fits well as a general-purpose notification backbone for homelabs and production automation where you want a simple, standards-based API and multiple client options.

28.1kstars
1.1kforks
View Details
#4
Apprise

Apprise

A notification gateway that routes alerts to 60+ services via CLI, Python API, and webhooks, with a unified URL syntax for configuration.

Apprise screenshot

Apprise is a notification library and CLI that lets applications send messages to many popular notification services using a single, consistent configuration format. It acts as a “notification gateway” you can embed in Python apps, scripts, monitoring tools, and automation workflows.

Key Features

  • Large notification provider catalog (email, chat, push, SMS, incident/alerting tools, and more) with a unified configuration URL syntax
  • Multiple interfaces: Python library/API, command-line tool, and plugin-style integrations
  • Notification URL parsing/validation and service discovery to simplify configuration management
  • Attachments support for providers that allow it (files/URLs) and rich message formatting where supported
  • Tag-based targeting and grouping to route messages to specific destinations
  • Config file support for managing multiple notification endpoints and reuse across scripts

Use Cases

  • Send monitoring and uptime alerts from scripts or tools to Slack/Discord/Email/SMS
  • Add a single notification layer to automation jobs (backups, CI tasks, cron jobs)
  • Centralize alert routing for self-hosted services by mapping events to multiple destinations

Limitations and Considerations

  • Provider capabilities vary (formatting, attachments, priority) and depend on each service’s API constraints
  • Some integrations require third-party credentials/tokens and may break when upstream APIs change

Apprise is well-suited when you want one notification implementation that can be retargeted to many services without rewriting integrations. Its URL-based configuration and broad provider support make it practical for both small scripts and larger systems needing consistent alert delivery.

15.4kstars
548forks
View Details
#5
Gotify

Gotify

Gotify is a self-hosted push notification server with a web UI, Android client, and REST API for sending messages from scripts, services, and monitoring tools.

Gotify screenshot

Gotify is a lightweight push-notification server you run yourself, designed for reliably delivering messages from applications, scripts, and infrastructure tools to end-user devices. It provides a web interface for managing users and “applications” (senders), plus client apps that receive notifications.

Key Features

  • REST API to send messages to specific applications/users using tokens
  • Web UI for managing users, clients, and applications (message sources)
  • Android client for instant push notifications (with optional notification channels)
  • Web client for viewing messages and receiving live updates
  • Priority support for messages (client-side handling/visibility)
  • Plugins system (server-side) to extend functionality
  • Docker images and straightforward deployment options

Use Cases

  • Send alerts from monitoring/uptime tools and homelab services
  • Push notifications from scripts/CI jobs (backup finished, deploy done)
  • Replace third-party push services for internal apps and teams

Limitations and Considerations

  • iOS support is not first-party (primarily Android + web clients)
  • Delivery to phones depends on the platform/client capabilities (e.g., Android background restrictions)

Gotify is well-suited for self-managed notification delivery with simple primitives (apps, tokens, messages) and minimal operational overhead. It’s commonly used as a Pushover/Pushbullet-style endpoint for homelab and DevOps notifications.

14.4kstars
798forks
View Details
#6
Healthchecks

Healthchecks

Monitor cron jobs and background tasks by pinging unique URLs. Get alerts for missed runs, failures, and long runtimes via email, SMS, and popular integrations.

Healthchecks screenshot

Healthchecks is a cron job and background task monitoring service built around simple “ping” URLs. You add a check, instrument your job to call the provided endpoint, and Healthchecks tracks schedules, runtimes, and failures to alert you when something goes wrong.

Key Features

  • Ping-based monitoring for cron jobs, one-off scripts, and background workers (success, fail, and start signals)
  • Flexible scheduling (period/grace time) with detection of missed runs and late jobs
  • Status signals: success, failure, and “start” to detect long-running/hung tasks
  • Notification channels including email and multiple third-party integrations (webhooks and chat/incident tools)
  • Teams and projects with role-based access for multi-user setups
  • Maintenance periods / downtime handling and per-check pause controls
  • Check-level API and management UI for creating and maintaining checks
  • Timezone-aware reporting and history of pings/runs for troubleshooting

Use Cases

  • Alert when backups, database maintenance, or ETL pipelines don’t run on schedule
  • Track long-running batch jobs and detect hangs using “start” + timeout
  • Monitor periodic health tasks in container/Kubernetes environments via HTTP pings

Limitations and Considerations

  • Healthchecks monitors scheduled execution via pings; it is not a full infrastructure/metrics APM system.

Healthchecks is a lightweight, reliable way to get notified about missed or failed scheduled jobs without deploying a full monitoring stack. It works well for ops teams and developers who want simple instrumentation, clear run history, and flexible alert routing.

9.8kstars
939forks
View Details
#7
Cronicle

Cronicle

A web-based, distributed cron replacement for scheduling and running scripts across a fleet with logging, retries, notifications, and access controls.

Cronicle screenshot

Cronicle is a self-hosted, web-based job scheduler designed as a modern replacement for traditional cron. It provides a central UI and API to schedule, run, and monitor scripts across multiple servers, with distributed execution, logging, and operational controls.

Key Features

  • Web UI for creating schedules (cron-style and intervals), launching jobs manually, and monitoring runs
  • Distributed “worker” architecture to execute jobs across multiple servers/nodes
  • Multiple schedule types and timezone-aware scheduling
  • Per-job concurrency controls, timeouts, retries, and error handling
  • Centralized logging with per-run output capture and searchable history
  • Notifications and webhooks for job success/failure (integration-friendly)
  • Role-based access controls (users, privileges) for multi-user operations
  • REST-style API for automation and external integrations

Use Cases

  • Centralize cron jobs for a multi-server environment (backups, ETL, maintenance)
  • Run operational runbooks on demand with audit-friendly run history
  • Coordinate scheduled scripts with notifications for failures and SLA monitoring

Limitations and Considerations

  • Requires deploying and maintaining Cronicle server plus workers and its backing storage; sizing depends on job volume and log retention
  • Focused on scheduling/executing scripts rather than full DAG workflows (may not fit complex pipeline orchestration needs)

Cronicle fits teams that want a lightweight, UI-driven scheduler to replace scattered crontabs and provide visibility, controls, and integrations. Its distributed worker model makes it well-suited for reliably running recurring automation across a server fleet.

5.3kstars
464forks
View Details
#8
Statping-ng

Statping-ng

Statping-ng is an uptime monitoring and status page platform for tracking HTTP and other service checks, sending alerts, and publishing incident updates.

Statping-ng screenshot

Statping-ng is a self-hosted uptime monitoring service with a built-in public status page. It runs scheduled health checks against your services, stores results, and can notify you when incidents occur, making it suitable for small teams and homelabs.

Key Features

  • Public status page with service groups, incident posts, and historical uptime
  • Scheduled health checks (primarily HTTP/HTTPS; additional check types available depending on configuration/version)
  • Notification/alerting integrations (e.g., email and common chat/push providers)
  • Multi-user administration with roles/permissions
  • Metrics and charts for response time and uptime history
  • API for managing services/checks and status content
  • Runs in a single binary/container with support for common databases

Use Cases

  • Publish a public status page for customer-facing services and APIs
  • Monitor internal services (reverse proxies, apps, endpoints) and alert on downtime
  • Track SLA/uptime history for infrastructure changes and maintenance

Limitations and Considerations

  • Feature set and integrations can vary across releases/forks; verify supported check types and notifiers for your target version.

Statping-ng is a practical option when you want both uptime checks and a simple status page in one deployable service. It focuses on lightweight monitoring, incident communication, and straightforward alerting rather than full observability.

1.9kstars
181forks
View Details
#9
ShellHub

ShellHub

ShellHub is a self-hosted SSH access gateway for managing and auditing remote access to servers and IoT devices with RBAC, device inventory, and session visibility.

ShellHub screenshot

ShellHub is a centralized SSH access gateway and device management platform designed to control, simplify, and audit remote access to servers and IoT/edge devices. It provides a web-based control plane where devices enroll and users connect through controlled, policy-based access.

Key Features

  • Device onboarding and inventory with identification and metadata
  • SSH access brokerage (gateway) to enrolled devices without exposing them directly
  • Web interface to manage devices, users, and access policies
  • Role-based access control (RBAC) for organizing and restricting access
  • Session visibility/auditing capabilities (connection and access tracking)
  • Multi-device fleet management oriented to IoT/edge environments

Use Cases

  • Centralize SSH access to production servers with controlled entry points
  • Manage remote access to IoT/edge fleets (industrial gateways, kiosks, routers)
  • Provide auditable operator/vendor access to customer or branch devices

Limitations and Considerations

  • Feature depth and enterprise controls can vary by edition/version; verify required auditing/recording needs in the current release.

ShellHub fits teams that want a single place to enroll devices and broker SSH access with governance controls. It’s especially useful where devices are distributed, behind NAT, or otherwise difficult to access directly, and where access control and traceability matter.

1.9kstars
169forks
View Details

Why choose an open source alternative?

  • •Data ownership: Keep your data on your own servers
  • •No vendor lock-in: Freedom to switch or modify at any time
  • •Cost savings: Reduce or eliminate subscription fees
  • •Transparency: Audit the code and know exactly what's running