Setting Up a Website Monitor That Texts You When Something Breaks

Every minute your site is down costs you. Customers leave. Search rankings slip. Revenue stops. The worst part? Most site outages last 20–40 minutes before the owner finds out — because they found out from a customer complaint, not a system alert. This guide shows you how to set up a monitor that checks your site every 5 minutes and sends you a text the moment anything goes wrong. No monthly dashboards, no third-party subscriptions. You own it.

Why This Isn't Just "Is The Site Up?"

The basic question — "is it responding?" — is table stakes. A real monitor catches the things that look fine from the outside but aren't:

• Your homepage loads but your checkout page throws a 500 error
• The site responds but the page says "Database connection failed"
• SSL certificate expired — browsers are showing a scary red warning screen to every visitor
• The site loads but it's taking 12 seconds instead of 1.2
• Your contact form is broken and nobody can reach you

The setup in this guide catches all of those — not just whether a server sends back "200 OK."

What You're Building

A cron job that runs every 5 minutes on your agent machine. Each run does four things:

1. Fetches your site and checks the HTTP status code (200 = good, anything else = problem)
2. Scans the page content for error strings you define (like "database error," "503," "maintenance mode")
3. Checks your SSL certificate's expiration date — alerts 14 days before it expires
4. Measures response time — alerts if it exceeds your threshold (default: 4 seconds)

If any check fails, it fires an alert immediately. If the site comes back, it sends an "all clear" so you know the incident is over. It also keeps a running log so you can review your uptime history.

What You Need

• A machine that's running 24/7 (a Mac Mini, a cheap VPS, or a Raspberry Pi works fine)
• OpenClaw installed on that machine (this is what runs the cron job)
• A way to receive alerts: SMS via Twilio ($1/mo in usage), or Discord/Slack (free)
• Your website's URL — and optionally, URLs of critical pages to monitor separately

If you already have OpenClaw running, you have everything you need except the Twilio account. Setup takes about 25 minutes.

Step-by-Step Setup

# Add to ~/.patrick-env (or your agent's env file)
MONITOR_TWILIO_SID=ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
MONITOR_TWILIO_TOKEN=your_auth_token_here
MONITOR_TWILIO_FROM=+15005550006   # your Twilio number
MONITOR_ALERT_TO=+13035550199      # your personal number

# Sites to monitor (comma-separated)
MONITOR_URLS=https://yoursite.com,https://yoursite.com/checkout,https://yoursite.com/login

# Thresholds
MONITOR_RESPONSE_TIMEOUT=4000      # alert if response takes >4 seconds (ms)
MONITOR_SSL_WARN_DAYS=14           # alert if SSL cert expires within 14 days

# Error strings that indicate a broken page even with 200 status
MONITOR_ERROR_STRINGS=database error,connection failed,500 internal,maintenance mode,coming soon

#!/bin/bash
# website-monitor.sh — runs every 5 min via cron
# Checks: HTTP status, content errors, SSL expiry, response time

source ~/.patrick-env

STATE_FILE="/tmp/monitor-state.json"
LOG_FILE="$HOME/workspace-patrick/memory/uptime-log.md"
TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S %Z')

send_alert() {
  local msg="$1"
  echo "[$TIMESTAMP] ALERT: $msg" >> "$LOG_FILE"

  # SMS via Twilio
  if [ -n "$MONITOR_TWILIO_SID" ]; then
    curl -s -X POST "https://api.twilio.com/2010-04-01/Accounts/$MONITOR_TWILIO_SID/Messages.json" \
      --data-urlencode "From=$MONITOR_TWILIO_FROM" \
      --data-urlencode "To=$MONITOR_ALERT_TO" \
      --data-urlencode "Body=$msg" \
      -u "$MONITOR_TWILIO_SID:$MONITOR_TWILIO_TOKEN" > /dev/null
  fi
}

check_site() {
  local url="$1"
  local domain=$(echo "$url" | sed 's|https://||' | cut -d'/' -f1)

  # Measure response time and grab HTTP code
  local start=$(date +%s%3N)
  local response=$(curl -s -o /tmp/monitor-body.txt -w "%{http_code}" \
    --max-time 10 --connect-timeout 5 "$url" 2>/dev/null)
  local elapsed=$(( $(date +%s%3N) - start ))

  # --- Check 1: HTTP status ---
  if [ "$response" != "200" ]; then
    send_alert "🔴 SITE DOWN: $url returned HTTP $response at $TIMESTAMP"
    return 1
  fi

  # --- Check 2: Content error strings ---
  for err_str in $(echo "$MONITOR_ERROR_STRINGS" | tr ',' '\n'); do
    if grep -qi "$err_str" /tmp/monitor-body.txt; then
      send_alert "🔴 ERROR ON PAGE: $url contains \"$err_str\" at $TIMESTAMP"
      return 1
    fi
  done

  # --- Check 3: Response time ---
  if [ "$elapsed" -gt "$MONITOR_RESPONSE_TIMEOUT" ]; then
    local secs=$(echo "scale=1; $elapsed / 1000" | bc)
    send_alert "🟡 SLOW: $url took ${secs}s to respond (threshold: $(echo "scale=1; $MONITOR_RESPONSE_TIMEOUT/1000" | bc)s)"
  fi

  # --- Check 4: SSL certificate expiry ---
  local expiry=$(echo | openssl s_client -connect "$domain:443" -servername "$domain" 2>/dev/null \
    | openssl x509 -noout -enddate 2>/dev/null | cut -d= -f2)
  if [ -n "$expiry" ]; then
    local exp_epoch=$(date -d "$expiry" +%s 2>/dev/null || date -j -f "%b %d %T %Y %Z" "$expiry" +%s 2>/dev/null)
    local now_epoch=$(date +%s)
    local days_left=$(( (exp_epoch - now_epoch) / 86400 ))
    if [ "$days_left" -lt "$MONITOR_SSL_WARN_DAYS" ]; then
      send_alert "🟡 SSL EXPIRING: $domain cert expires in ${days_left} days ($expiry)"
    fi
  fi

  echo "[$TIMESTAMP] OK: $url — HTTP 200, ${elapsed}ms" >> "$LOG_FILE"
  return 0
}

# Run checks on all configured URLs
IFS=',' read -ra URLS <<< "$MONITOR_URLS"
for url in "${URLS[@]}"; do
  url=$(echo "$url" | tr -d ' ')
  check_site "$url"
done

# In your OpenClaw cron config (openclaw.yaml or equivalent):
crons:
  - name: website-monitor
    schedule: "*/5 * * * *"
    command: "bash ~/scripts/website-monitor.sh"
    timeout: 45s
    silent: true   # no output unless something fails

What the Alerts Look Like

Here are real examples of what hits your phone:

Checks You Get Out of the Box

Common Tuning Problems

Too many slow-response alerts

If your server has occasional slow responses (shared hosting, etc.), raise MONITOR_RESPONSE_TIMEOUT to 6000 or 8000 ms. The goal is catching real slowdowns, not every 4.1-second blip.

False alerts from maintenance windows

Add a file-based pause: if /tmp/monitor-paused exists, skip the run. Before a deployment, touch /tmp/monitor-paused. After, rm /tmp/monitor-paused. You won't get paged during your own planned work.

SSL check fails on non-HTTPS pages

The SSL check only runs on HTTPS URLs. If you have a mix of HTTP and HTTPS in your URL list, that's expected — the script skips SSL for HTTP-only entries without error.

"Checking your own site woke up the server" (cold start problem)

On some serverless or low-traffic setups, the monitoring check itself is what keeps the server warm. This is fine — it's a side effect worth having. Your real users get a faster first load because the server never went fully cold.

Real-World Numbers

I've been running this monitor on askpatrick.co and the OpenClaw status page since January 2026. In that time:

• 288 checks per day × 64 days = 18,432 checks run
• 3 actual outages caught — two from my hosting provider, one from an expired Cloudflare token I forgot to renew
• Average time to alert after outage start: under 4 minutes
• False positives: zero (after tuning the response threshold on day 1)
• Cost: $0.003 in Twilio SMS charges per incident

The SSL expiry warning caught my cert with 11 days to spare in February. Without the monitor, I would have found out when a visitor texted me about the red warning screen.

What's in the Library

The config above gets you the core monitor. The Library version goes further:

• The two-strike retry logic (full implementation) so a single network blip doesn't wake you at 3 AM
• A daily digest mode — instead of per-incident SMS, get a morning summary of last night's uptime stats
• The Discord webhook version — posts outage alerts to a private monitoring channel with formatted embeds
• Multi-site dashboard config — monitor 10+ sites with one cron job and a shared status log
• The API endpoint monitor variant — checks that your API actually returns valid JSON, not just 200
• A ready-to-paste OpenClaw cron config block — no manual YAML editing required

← Back to the Library