Monitoring beginner ⏱ 30 minutes

Statping-ng: Status Page and Monitoring

Beautiful status pages with monitoring. Notifications and incident management.

By Homelab Team • 2025-01-15
#statping#status-page#monitoring#incidents#docker

Introduction

In the world of homelab monitoring, finding the perfect balance between functionality, ease of use, and visual appeal can be challenging. While tools like Uptime Kuma offer extensive features and Gatus provides GitOps-friendly configuration, Statping-ng carves out its own niche as a modern, self-hosted status page and monitoring tool that combines beautiful UI with powerful monitoring capabilities.

Statping-ng is the actively maintained fork of the original Statping project, bringing fresh development, bug fixes, and new features to a proven monitoring solution. With 1,400+ GitHub stars and growing community support, it’s becoming a popular choice for homelabs and small businesses.

What makes Statping-ng special:

  • Beautiful, customizable status pages out of the box
  • Multi-protocol monitoring (HTTP, TCP, UDP, ICMP, gRPC)
  • Built-in web UI for configuration (no config files needed)
  • SQLite, PostgreSQL, or MySQL database support
  • Prometheus metrics exporter
  • Mobile-responsive design
  • Public and private status pages
  • API for automation and integration

What you’ll learn:

  • Deploy Statping-ng with Docker Compose in under 15 minutes
  • Create monitors for HTTP, TCP, ICMP, and gRPC services
  • Configure multi-channel notifications (Discord, Slack, Email, Telegram)
  • Build and customize public status pages
  • Set up incident management and maintenance windows
  • Export metrics to Prometheus for long-term storage
  • Compare Statping-ng with other monitoring solutions

Prerequisites:

  • Docker and Docker Compose installed
  • Basic understanding of Docker containers
  • 200MB+ free disk space
  • Services you want to monitor
  • Optional: Notification service accounts (Discord, Telegram)

Why Statping-ng?

The Statping Legacy

The original Statping project was beloved for its simplicity and beautiful status pages, but development slowed in 2020. The community rallied and created Statping-ng (Next Generation) to continue development with:

  • Active maintenance and bug fixes
  • Security updates
  • New features and integrations
  • Community-driven development
  • Better Docker support

Key Features

1. Monitoring Capabilities

  • HTTP/HTTPS endpoint monitoring
  • TCP port checks
  • UDP service monitoring
  • ICMP ping checks
  • gRPC health checks
  • Custom HTTP headers and authentication
  • Response time tracking
  • SSL certificate expiration monitoring

2. Status Pages

  • Beautiful, responsive design
  • Public and private pages
  • Custom branding (logo, colors, footer)
  • Service grouping
  • Incident history
  • Maintenance announcements
  • Embeddable badges

3. Notifications

  • Discord webhooks
  • Slack integration
  • Telegram bot
  • Email (SMTP)
  • Webhooks for custom integrations
  • Twilio SMS (premium)
  • Mobile push notifications

4. Data & Analytics

  • Response time charts
  • Uptime percentage tracking
  • Incident timeline
  • Performance metrics
  • Prometheus metrics export
  • SQLite, PostgreSQL, or MySQL storage

Quick Start Deployment

Basic Docker Compose Setup

Let’s deploy Statping-ng with the simplest configuration.

Create project directory:

mkdir -p ~/statping-ng
cd ~/statping-ng

Create docker-compose.yml:

version: '3.8'

services:
  statping:
    image: statping/statping-ng:latest
    container_name: statping-ng
    ports:
      - "8080:8080"
    volumes:
      - ./data:/app
    environment:
      - DB_CONN=sqlite
      - TZ=America/New_York
    restart: unless-stopped

Start Statping-ng:

docker compose up -d

Access web interface:

http://YOUR-SERVER-IP:8080

Initial setup wizard:

  1. Select language
  2. Create admin account (save credentials in password manager)
  3. Configure database (SQLite is pre-configured)
  4. Set project name and description
  5. Complete setup

Production Deployment with PostgreSQL

For production use, PostgreSQL provides better performance and reliability.

Create docker-compose.yml:

version: '3.8'

services:
  statping:
    image: statping/statping-ng:latest
    container_name: statping-ng
    ports:
      - "8080:8080"
    volumes:
      - ./data:/app
    environment:
      - DB_CONN=postgres
      - DB_HOST=postgres
      - DB_PORT=5432
      - DB_USER=statping
      - DB_PASS=secure_password
      - DB_DATABASE=statping
      - TZ=America/New_York
    depends_on:
      - postgres
    restart: unless-stopped
    networks:
      - monitoring

  postgres:
    image: postgres:15-alpine
    container_name: statping-postgres
    volumes:
      - postgres-data:/var/lib/postgresql/data
    environment:
      - POSTGRES_DB=statping
      - POSTGRES_USER=statping
      - POSTGRES_PASSWORD=secure_password
    restart: unless-stopped
    networks:
      - monitoring

volumes:
  postgres-data:

networks:
  monitoring:
    driver: bridge

Start the stack:

docker compose up -d

Verify deployment:

# Check containers are running
docker ps

# View logs
docker logs statping-ng

# Check database connection
docker logs statping-postgres

Creating Service Monitors

HTTP/HTTPS Monitoring

Create your first HTTP monitor:

  1. Click “Services” in navigation

  2. Click “Create Service”

  3. Configure basic settings:

    • Service Name: “My Website”
    • Type: HTTP
    • URL: https://example.com
    • Method: GET
    • Expected Status: 200
    • Check Interval: 60 seconds
    • Timeout: 10 seconds

  4. Advanced Options:

    • Expected Response: Leave blank or enter text that should appear
    • Headers: Add custom headers if needed
    • Follow Redirects: Enable (default)
    • Verify SSL: Enable (default)

  5. Click “Create”

HTTP with authentication:

For APIs requiring authentication:

  1. Create HTTP service
  2. In Headers section: 
    Authorization: Bearer YOUR-API-TOKEN
Content-Type: application/json
  3. Set Expected Status: 200
  4. Optional: Add Expected Response text to verify correct content

POST request monitoring:

  1. Create HTTP service
  2. Set Method: POST
  3. In Post Data field: 
    {
  "test": "value",
  "check": "health"
}
  4. Set appropriate headers: 
    Content-Type: application/json

TCP Port Monitoring

Monitor database or service ports:

  1. Click “Create Service”

  2. Configure:

    • Service Name: “PostgreSQL Database”
    • Type: TCP
    • Domain/IP: 192.168.1.100
    • Port: 5432
    • Check Interval: 300 seconds (5 minutes)
    • Timeout: 5 seconds

  3. Click “Create”

Common TCP port monitors:

  • PostgreSQL: port 5432
  • MySQL: port 3306
  • Redis: port 6379
  • MongoDB: port 27017
  • SSH: port 22
  • SMTP: port 25 or 587

ICMP Ping Monitoring

Monitor network devices:

  1. Click “Create Service”

  2. Configure:

    • Service Name: “Router”
    • Type: ICMP
    • Domain/IP: 192.168.1.1
    • Check Interval: 60 seconds
    • Timeout: 3 seconds

  3. Click “Create”

Use cases:

  • Network routers and switches
  • NAS devices
  • Servers (basic availability)
  • IoT devices

gRPC Monitoring

Monitor gRPC services:

  1. Click “Create Service”

  2. Configure:

    • Service Name: “gRPC API”
    • Type: gRPC
    • Domain/IP: api.example.com
    • Port: 50051
    • Check Interval: 120 seconds

  3. Click “Create”

Notification Configuration

Discord Notifications

Set up Discord webhook:

  1. In Statping-ng, go to “Settings” → “Notifiers”

  2. Find Discord card

  3. Click “Setup”

  4. Configure:

    • Webhook URL: Paste Discord webhook URL
    • Enabled: Toggle ON
    • On Success: Toggle if you want success notifications
    • On Failure: Toggle ON (recommended)

  5. Click “Update Notifier”

  6. Click “Test” to verify

Create Discord webhook:

  1. Open Discord server → Settings → Integrations
  2. Click “Webhooks” → “New Webhook”
  3. Name: “Statping Alerts”
  4. Select channel: status-alerts
  5. Copy webhook URL
  6. Save webhook

Slack Integration

Configure Slack notifications:

  1. Go to “Settings” → “Notifiers”

  2. Find Slack card

  3. Click “Setup”

  4. Configure:

    • Webhook URL: Paste Slack webhook URL
    • Channel: CHANNEL-NAME (optional, overrides webhook default)
    • Username: Statping Monitor (optional)
    • Enabled: Toggle ON

  5. Test and save

Create Slack webhook:

  1. Visit https://api.slack.com/apps
  2. Click “Create New App” → “From scratch”
  3. Name: “Statping Monitor”
  4. Select workspace
  5. Go to “Incoming Webhooks” → Enable
  6. Click “Add New Webhook to Workspace”
  7. Select channel and authorize
  8. Copy webhook URL

Telegram Bot Setup

Configure Telegram notifications:

  1. Go to “Settings” → “Notifiers”

  2. Find Telegram card

  3. Click “Setup”

  4. Configure:

    • API Token: Paste bot token from BotFather
    • Chat ID: Paste chat or group ID
    • Enabled: Toggle ON

  5. Test and save

Create Telegram bot:

  1. Open Telegram, search @BotFather
  2. Send /start
  3. Send /newbot
  4. Follow prompts:
    • Bot name: “Statping Monitor”
    • Username: “statping_monitor_bot” (must be unique)
  5. Save API token

Get Chat ID:

  1. Add bot to group or start private chat
  2. Send a message to the bot
  3. Visit: https://api.telegram.org/botYOUR-TOKEN/getUpdates
  4. Find "chat":{"id":12345678} in response
  5. Use this ID in Statping-ng

Email (SMTP) Notifications

Configure email alerts:

  1. Go to “Settings” → “Notifiers”

  2. Find Email card

  3. Click “Setup”

  4. Configure:

  5. Test and save

Gmail app password:

  1. Visit https://myaccount.google.com/apppasswords
  2. Generate app password
  3. Use this instead of your regular password

Webhook Notifications

Custom webhook for integrations:

  1. Go to “Settings” → “Notifiers”

  2. Find Webhook card

  3. Click “Setup”

  4. Configure:

    • Webhook URL: https://your-system.com/webhook
    • HTTP Method: POST
    • Content Type: application/json
    • Enabled: Toggle ON

  5. Test and save

Webhook payload example:

{
  "service": "Website",
  "status": "down",
  "message": "Service is offline",
  "timestamp": "2025-01-15T10:30:00Z"
}

Building Status Pages

Basic Status Page Setup

The status page is automatically created and accessible at the root URL.

Configure status page:

  1. Go to “Settings” → “Settings”

  2. Configure Basic Settings:

    • Project Name: “Homelab Status”
    • Description: “Real-time status of infrastructure services”
    • Domain: status.example.com (if using custom domain)
    • Language: English
    • Timezone: Your timezone

  3. Configure Appearance:

    • Theme: Light, Dark, or Auto
    • Logo: Upload custom logo
    • Footer: Add custom text or links

  4. Click “Save Settings”

Service Groups

Organize services into logical groups:

  1. Go to “Services”

  2. For each service, click Edit

  3. Set Group field:

    • “External Services”
    • “Internal Services”
    • “Databases”
    • “Network Infrastructure”

  4. Services are automatically grouped on status page

Public vs Private Status Page

Make status page public:

  1. Go to “Settings” → “Settings”
  2. Find Public toggle
  3. Enable for public access (no login required)
  4. Share URL: http://your-server:8080

Keep status page private:

  1. Keep Public toggle disabled
  2. Users must authenticate to view
  3. Create additional user accounts in Users section

Custom Branding

Customize appearance:

  1. Go to “Settings” → “Settings”

  2. Upload Logo (recommended size: 200x50px)

  3. Set Footer text:

    Powered by Statping-ng | Support: [email protected]

  4. Custom CSS (advanced): Go to “Settings” → “Style”

    /* Custom status page styling */
.header {
    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
}

.service-card {
    border-radius: 10px;
    box-shadow: 0 4px 6px rgba(0,0,0,0.1);
}

Status Badges

Generate embeddable badges:

  1. Go to service details page
  2. Click “Badge” button
  3. Copy badge URL or markdown

Badge formats:

# Status Badge (Markdown)
![Website Status](http://statping.example.com/api/services/1/badge.svg)

# HTML
<img src="http://statping.example.com/api/services/1/badge.svg" alt="Website Status">

Badge URL structure:

http://your-server:8080/api/services/SERVICE-ID/badge.svg

Incident Management

Creating Incidents

Manual incident creation:

  1. Go to “Messages”

  2. Click “Create Message”

  3. Configure:

    • Title: “Planned Maintenance: Database Migration”
    • Description: Detailed information about incident
    • Start Time: Select date/time
    • End Time: Select date/time (optional)
    • Notify Users: Toggle ON to send notifications

  4. Click “Create Message”

Incident appears on status page and sends notifications

Maintenance Windows

Schedule maintenance:

  1. Create incident/message as above
  2. Set Start Time to future date/time
  3. Set End Time to expected completion
  4. Notify Users: Toggle ON

During maintenance:

  • Incident banner appears on status page
  • Services show “Under Maintenance” status
  • Notifications sent when maintenance starts and ends

Incident Response Workflow

Recommended workflow:

  1. Detection: Monitor detects service down
  2. Notification: Alerts sent via Discord/Slack/Email
  3. Investigation: Admin investigates issue
  4. Communication: Create incident message on status page
  5. Resolution: Fix issue
  6. Update: Update incident with resolution details
  7. Close: Mark incident as resolved

Incident message template:

Title: Website Downtime
Description:
We are currently experiencing issues with our website.
Our team is investigating the issue.

Updates:
[10:30 AM] Issue detected, investigating
[10:45 AM] Root cause identified, implementing fix
[11:00 AM] Services restored, monitoring for stability
[11:15 AM] All systems operational

Status: Resolved

Advanced Configuration

Prometheus Metrics Export

Enable Prometheus metrics:

Statping-ng automatically exposes metrics at /metrics endpoint.

Prometheus configuration:

# prometheus.yml
scrape_configs:
  - job_name: 'statping'
    static_configs:
      - targets: ['statping:8080']
    metrics_path: '/metrics'
    scrape_interval: 30s

Available metrics:

  • statping_service_online - Service online status (0 or 1)
  • statping_service_response_time - Response time in milliseconds
  • statping_service_failures_total - Total failures count
  • statping_service_uptime_percent - Uptime percentage

API Integration

Statping-ng provides REST API for automation:

Get all services:

curl -X GET http://statping:8080/api/services   -H "Authorization: Bearer YOUR-API-TOKEN"

Create service programmatically:

curl -X POST http://statping:8080/api/services   -H "Authorization: Bearer YOUR-API-TOKEN"   -H "Content-Type: application/json"   -d '{
    "name": "API Service",
    "domain": "https://api.example.com",
    "type": "http",
    "method": "GET",
    "expected_status": 200,
    "interval": 60,
    "timeout": 10
  }'

Get API token:

  1. Go to “Settings” → “API”
  2. Generate new API token
  3. Save securely

Environment Variables

Complete environment variable reference:

environment:
  # Database Configuration
  - DB_CONN=postgres           # sqlite, postgres, mysql
  - DB_HOST=postgres
  - DB_PORT=5432
  - DB_USER=statping
  - DB_PASS=secure_password
  - DB_DATABASE=statping

  # Application Settings
  - NAME=Homelab Status        # Project name
  - DESCRIPTION=Infrastructure monitoring
  - DOMAIN=status.example.com  # Custom domain
  - PORT=8080                  # Internal port
  - TZ=America/New_York        # Timezone

  # Admin Account (initial setup)
  - ADMIN_USER=admin
  - ADMIN_PASSWORD=secure_password
  - [email protected]

  # Optional Settings
  - DISABLE_LOGS=false         # Disable HTTP logs
  - USE_ASSETS=false           # Use local assets
  - SAMPLE_DATA=false          # Create sample services

SSL Certificate Monitoring

Enable SSL expiration alerts:

  1. Create HTTP service with HTTPS URL
  2. Edit service
  3. Find Verify SSL option
  4. Enable verification
  5. Statping-ng automatically monitors certificate expiration

Alert threshold:

  • Warning: 30 days before expiration
  • Critical: 7 days before expiration

Multiple Check Locations

For geo-distributed monitoring, deploy multiple Statping-ng instances:

# docker-compose.yml - Location 1 (US East)
services:
  statping-us-east:
    image: statping/statping-ng:latest
    environment:
      - LOCATION=US-East
# docker-compose.yml - Location 2 (EU West)
services:
  statping-eu-west:
    image: statping/statping-ng:latest
    environment:
      - LOCATION=EU-West

Aggregate results using Prometheus and Grafana

Production Configuration Example

Complete production-ready setup:

version: '3.8'

services:
  statping:
    image: statping/statping-ng:latest
    container_name: statping-ng
    ports:
      - "8080:8080"
    volumes:
      - ./data:/app
      - ./logs:/var/log/statping
    environment:
      # Database
      - DB_CONN=postgres
      - DB_HOST=postgres
      - DB_PORT=5432
      - DB_USER=statping
      - DB_PASS=${DB_PASSWORD}
      - DB_DATABASE=statping

      # Application
      - NAME=Homelab Infrastructure Status
      - DESCRIPTION=Real-time monitoring of all services
      - DOMAIN=status.homelab.local
      - TZ=America/New_York

      # Performance
      - DISABLE_LOGS=true
      - USE_ASSETS=true

    depends_on:
      - postgres
    restart: unless-stopped
    networks:
      - monitoring
    healthcheck:
      test: ["CMD", "wget", "--quiet", "--tries=1", "--spider", "http://localhost:8080/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

  postgres:
    image: postgres:15-alpine
    container_name: statping-postgres
    volumes:
      - postgres-data:/var/lib/postgresql/data
      - ./backups:/backups
    environment:
      - POSTGRES_DB=statping
      - POSTGRES_USER=statping
      - POSTGRES_PASSWORD=${DB_PASSWORD}
      - PGDATA=/var/lib/postgresql/data/pgdata
    restart: unless-stopped
    networks:
      - monitoring
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U statping"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  postgres-data:

networks:
  monitoring:
    driver: bridge

Create .env file:

DB_PASSWORD=your_secure_password_here

Troubleshooting

Issue 1: Services Showing as Down

Diagnosis:

# Check Statping-ng logs
docker logs statping-ng

# Test endpoint manually
curl -I https://example.com

# Check network connectivity from container
docker exec statping-ng ping example.com

# Verify DNS resolution
docker exec statping-ng nslookup example.com

Common causes:

  • Firewall blocking outbound connections
  • DNS resolution issues
  • Service actually down
  • Timeout too short for slow services

Solutions:

  1. Increase timeout for slow services
  2. Verify firewall allows outbound traffic
  3. Check service is actually accessible
  4. Use IP address instead of hostname to rule out DNS issues

Issue 2: Notifications Not Sending

Diagnosis:

# Check Statping-ng logs for notification errors
docker logs statping-ng | grep -i notif

# Test webhook manually
curl -X POST https://discord.com/api/webhooks/YOUR-WEBHOOK   -H "Content-Type: application/json"   -d '{"content":"Test notification"}'

# Verify notifier is enabled
# Check in Web UI: Settings → Notifiers

Solutions:

  1. Verify webhook URL is correct and not revoked
  2. Check notifier is enabled in UI
  3. Test notification using “Test” button in UI
  4. Check firewall allows outbound HTTPS (port 443)

Issue 3: Database Connection Errors

Diagnosis:

# Check PostgreSQL logs
docker logs statping-postgres

# Verify database is running
docker ps | grep postgres

# Check database connection from Statping container
docker exec statping-ng pg_isready -h postgres -p 5432

Solutions:

  1. Verify database credentials in docker-compose.yml
  2. Ensure postgres container starts before statping
  3. Check database container has enough resources
  4. Verify network connectivity between containers

Issue 4: High Memory Usage

Symptoms: Container using excessive RAM

Solutions:

# Add resource limits to docker-compose.yml
services:
  statping:
    mem_limit: 512m
    memswap_limit: 512m

Optimize database:

# For PostgreSQL
docker exec statping-postgres vacuumdb -U statping -d statping -f -z

# For SQLite (stop container first)
docker stop statping-ng
sqlite3 ./data/statping.db "VACUUM;"
docker start statping-ng

Issue 5: Status Page Not Loading

Diagnosis:

# Check if port is accessible
curl http://localhost:8080

# Check container logs for errors
docker logs statping-ng --tail 50

# Verify container is running
docker ps | grep statping

Solutions:

  1. Check port 8080 is not used by another service
  2. Verify firewall allows traffic on port 8080
  3. Check browser console for JavaScript errors
  4. Try accessing from localhost first, then remote

Comparison: Statping-ng vs Alternatives

Statping-ng vs Uptime Kuma

FeatureStatping-ngUptime Kuma
ConfigurationWeb UIWeb UI
Setup ComplexityLowVery Low
Database OptionsSQLite, PostgreSQL, MySQLSQLite, PostgreSQL (beta)
Protocol SupportHTTP, TCP, UDP, ICMP, gRPCHTTP, TCP, Ping, DNS, Docker, Push
Status PageBuilt-in, customizableBuilt-in, feature-rich
Notifications10+ providers95+ providers
APIYes, REST APIYes, extensive
Prometheus ExportYes, built-inVia API scraping
Resource Usage80-150MB RAM100-200MB RAM
Incident ManagementManual messagesAutomatic tracking
2FA SupportNoYes

Statping-ng vs Gatus

FeatureStatping-ngGatus
ConfigurationWeb UIYAML files
GitOps FriendlyNoYes
Status PageYesYes
Database RequiredYesNo (optional)
Ease of UseVery EasyModerate
Version ControlNoYes
APIYesYes
Resource Usage80-150MB RAM15-30MB RAM

Use Case Recommendations

Choose Statping-ng if:

  • You want beautiful status pages with minimal setup
  • You prefer web UI configuration over config files
  • You need Prometheus metrics export
  • You want REST API for automation
  • You’re comfortable with database setup
  • You need incident announcement system

Choose Uptime Kuma if:

  • You need maximum notification providers (95+)
  • You want push-based monitoring (Dead Man’s Switch)
  • You need Docker container monitoring
  • You want built-in 2FA
  • You prefer SQLite for simplicity

Choose Gatus if:

  • You prefer infrastructure as code (GitOps)
  • You want minimal resource usage
  • You’re managing multiple environments
  • You want version-controlled configuration
  • You don’t need database persistence

Security Considerations

Secure Your Installation

1. Use strong passwords:

# Generate secure password
openssl rand -base64 32

2. Enable HTTPS with reverse proxy:

Nginx configuration:

server {
    server_name status.example.com;

    location / {
        proxy_pass http://localhost:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    listen 443 ssl http2;
    ssl_certificate /etc/letsencrypt/live/status.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/status.example.com/privkey.pem;
}

3. Limit public access:

For private status pages, use IP whitelisting:

location / {
    allow 192.168.1.0/24;  # Local network
    allow 10.0.0.0/8;      # VPN range
    deny all;

    proxy_pass http://localhost:8080;
}

4. Regular backups:

#!/bin/bash
# backup-statping.sh

BACKUP_DIR="/backups/statping"
DATE=$(date +%Y%m%d-%H%M%S)

# Backup PostgreSQL database
docker exec statping-postgres pg_dump -U statping statping >   "$BACKUP_DIR/statping-db-$DATE.sql"

# Backup application data
tar czf "$BACKUP_DIR/statping-data-$DATE.tar.gz" ~/statping-ng/data

# Keep last 30 days of backups
find "$BACKUP_DIR" -name "statping-*" -mtime +30 -delete

echo "Backup completed: $DATE"

Maintenance and Updates

Update Statping-ng

Update to latest version:

cd ~/statping-ng

# Pull latest image
docker compose pull

# Restart with new image
docker compose down
docker compose up -d

# Verify update
docker logs statping-ng

Database Maintenance

PostgreSQL maintenance:

# Vacuum database (reclaim space)
docker exec statping-postgres vacuumdb -U statping -d statping -f -z

# Analyze tables (update statistics)
docker exec statping-postgres psql -U statping -d statping -c "ANALYZE;"

# Check database size
docker exec statping-postgres psql -U statping -d statping -c   "SELECT pg_size_pretty(pg_database_size('statping'));"

SQLite maintenance:

# Stop container
docker stop statping-ng

# Vacuum database
sqlite3 ./data/statping.db "VACUUM;"

# Check integrity
sqlite3 ./data/statping.db "PRAGMA integrity_check;"

# Restart container
docker start statping-ng

Regular Maintenance Tasks

Weekly:

  • Review service status and incident history
  • Check disk usage
  • Verify notifications are working

Monthly:

  • Update Docker images
  • Backup database
  • Review and clean old incidents
  • Check for security updates

Quarterly:

  • Review all monitors for relevance
  • Optimize database
  • Test disaster recovery from backup
  • Review notification channels

Conclusion

Statping-ng provides a perfect balance between ease of use and powerful monitoring capabilities. Its beautiful status pages, comprehensive monitoring options, and straightforward configuration make it an excellent choice for homelabs and small businesses.

Key takeaways:

  • Web UI configuration requires no coding
  • Beautiful, customizable status pages out of the box
  • Multi-protocol monitoring covers HTTP, TCP, ICMP, gRPC
  • Built-in Prometheus metrics for long-term storage
  • REST API enables automation and integration
  • SQLite or PostgreSQL for flexibility

Your deployment timeline:

Week 1:

  1. Deploy Statping-ng with Docker Compose
  2. Create monitors for critical services
  3. Configure Discord or Telegram notifications
  4. Customize status page branding

Week 2: 5. Add comprehensive monitors for all services 6. Set up email notifications 7. Create user accounts for team members 8. Configure reverse proxy with HTTPS

Week 3: 9. Integrate with Prometheus for metrics 10. Set up automated backups 11. Create incident response workflow 12. Document procedures for team

Resources:

Whether you’re monitoring a personal homelab or business infrastructure, Statping-ng delivers reliable monitoring with beautiful status pages that keep everyone informed.

Happy monitoring!