How to Set Up On-Call Alerting with Vigilmon (Without PagerDuty Pricing)

How to Set Up On-Call Alerting with Vigilmon

On-call alerting is the link between a monitoring tool detecting a problem and a human being woken up to fix it. PagerDuty, OpsGenie, and VictorOps are the traditional on-call platforms — but they cost $20-40 per user per month, which is prohibitive for small teams and indie developers. This guide shows you how to set up effective on-call alerting with Vigilmon for a fraction of the cost.

What On-Call Alerting Actually Requires

At its core, on-call alerting needs:

1. Detection: Something checks your service and notices a failure
2. Escalation: The right person is paged immediately
3. Acknowledgment: Someone confirms they have seen the alert
4. Resolution: The problem is fixed and the incident is closed

For small teams (1-5 engineers), steps 1 and 2 are the most important. PagerDuty's complexity (schedules, escalation policies, runbooks) is overkill until you have a 24/7 on-call rotation.

Setting Up On-Call Alerting with Vigilmon

Step 1: Create Your Monitors

1. Sign up at vigilmon.online (free)
2. Add monitors for your critical endpoints:
   • Main application URL
   • Health check endpoint
   • Critical APIs
   • SSL certificate expiry

Step 2: Configure Email Alerts

For individuals or small teams, email alerts are often enough:

• Add your personal email for immediate alerts
• Add your team email list ([e-mail])
• Set alert threshold: 1 failure for critical services, 2 failures for less critical

Vigilmon sends the first alert immediately when a monitor fails, and a recovery alert when it comes back up.

Step 3: Add Slack Alerts for Team Visibility

# In Vigilmon:
1. Settings > Alert Channels > Add Slack
2. Create a Slack webhook in your workspace:
   - Slack > Apps > Incoming Webhooks > Add
   - Select #incidents or #alerts channel
3. Paste webhook URL into Vigilmon
4. Test the webhook

Now when your site goes down, Slack immediately notifies your team in a dedicated channel.

Step 4: Webhook Integration for Custom On-Call Tools

Vigilmon supports outbound webhooks. Use this to integrate with:

Twilio (SMS alerts):

# Simple webhook receiver that sends SMS
from flask import Flask, request
from twilio.rest import Client

app = Flask(__name__)
client = Client(TWILIO_SID, TWILIO_TOKEN)

@app.route('/webhook/vigilmon', methods=['POST'])
def vigilmon_webhook():
    data = request.json
    if data.get('status') == 'down':
        message = f"ALERT: {data['monitor_name']} is DOWN. URL: {data['url']}"
        client.messages.create(
            body=message,
            from_='[phone]',  # Your Twilio number
            to='+0987654321'      # On-call phone
        )
    return 'ok'

if __name__ == '__main__':
    app.run(port=5000)

Discord alerts:

import requests

DISCORD_WEBHOOK = 'https://discord.com/api/webhooks/YOUR_WEBHOOK'

@app.route('/webhook/vigilmon', methods=['POST'])
def vigilmon_discord_webhook():
    data = request.json
    if data.get('status') == 'down':
        requests.post(DISCORD_WEBHOOK, json={
            'content': f'@here ALERT: {data["monitor_name"]} is DOWN!',
            'username': 'Vigilmon'
        })
    return 'ok'

PagerDuty Events API (if you already have PagerDuty):

import requests

@app.route('/webhook/vigilmon', methods=['POST'])
def to_pagerduty():
    data = request.json
    if data.get('status') == 'down':
        requests.post('https://events.pagerduty.com/v2/enqueue', json={
            'routing_key': PD_ROUTING_KEY,
            'event_action': 'trigger',
            'payload': {
                'summary': f'{data["monitor_name"]} is down',
                'severity': 'critical',
                'source': 'vigilmon'
            }
        })
    return 'ok'

Step 5: Mobile Push Notifications (Budget Option)

For personal on-call without Twilio costs, use Ntfy or Pushover:

Ntfy (free, open-source):

# Self-host or use ntfy.sh
curl -d "ALERT: Production is down!" ntfy.sh/your-personal-topic

In Vigilmon, set up a webhook that POSTs to your ntfy endpoint. The ntfy mobile app receives the push notification instantly.

Pushover ($5 one-time): Similar approach with Pushover's webhook API.

Step 6: Escalation Logic (Simple Version)

For simple teams, escalation = "if Slack alert is not acknowledged in 5 minutes, send SMS":

import time
import threading

ACKNOWLEDGED = {}

@app.route('/webhook/vigilmon', methods=['POST'])
def handle_alert():
    data = request.json
    monitor_id = data['monitor_id']

    if data['status'] == 'down':
        # Post to Slack immediately
        post_to_slack(data)

        # Start escalation timer
        def escalate():
            time.sleep(300)  # 5 minutes
            if monitor_id not in ACKNOWLEDGED:
                send_sms(f"ESCALATION: {data['monitor_name']} still down")

        thread = threading.Thread(target=escalate)
        thread.daemon = True
        thread.start()

    return 'ok'

@app.route('/ack/<monitor_id>')
def acknowledge(monitor_id):
    ACKNOWLEDGED[monitor_id] = True
    return 'acknowledged'

On-Call Scheduling (Simple Round-Robin)

For teams with weekly on-call rotations, a simple spreadsheet + scheduled alert channel changes works:

# Change Slack @mention based on who is on call this week
from datetime import datetime

ONCAll_SCHEDULE = {
    0: '@alice',  # Week 1 (Jan week 1)
    1: '@bob',
    2: '@charlie',
    # ...
}

def current_oncall():
    week_number = datetime.now().isocalendar()[1]
    return ONCALL_SCHEDULE[week_number % len(ONCALL_SCHEDULE)]

Cost Comparison

Tool	Cost for 3-person team
PagerDuty	$60-120/month
OpsGenie	$57/month
VictorOps	$54/month
Vigilmon + Slack + Ntfy	~$0/month
Vigilmon + Twilio SMS	~$5-15/month

When to Upgrade to PagerDuty

You should consider PagerDuty or OpsGenie when:

• You have 10+ engineers on a 24/7 on-call rotation
• You need sophisticated escalation policies with multiple tiers
• You need automatic on-call schedule management with swap requests
• You have SLA requirements that need audit-grade incident tracking

For teams of 1-5 engineers, Vigilmon + Slack + simple webhooks covers 90% of on-call needs at 5% of the cost.

Summary

Effective on-call alerting for small teams does not require PagerDuty. Vigilmon handles detection and initial notification. Slack handles team visibility. Simple webhooks handle escalation and SMS.

Set up on-call alerting free with Vigilmon.