I Replaced a $29/Month Uptime Monitor With 50 Lines of Python

#devops #sre #monitoring #python

You Are Paying $29/Month to Watch a Dashboard

Most small teams run paid uptime monitoring for a handful of endpoints. That's $350/year to send an HTTP request every 60 seconds and check whether the response says 200.

You can do that in 50 lines of Python. Here is the whole thing — no dependencies beyond the standard library.

The 50-Line Uptime Checker

import json, smtplib, urllib.request, datetime

ENDPOINTS = [
    "https://yoursite.com",
    "https://api.yoursite.com/health",
]
STATE_FILE = "uptime_state.json"
ALERT_EMAIL = "you@yourcompany.com"

def check(url):
    try:
        start = datetime.datetime.now()
        req = urllib.request.Request(url, headers={"User-Agent": "uptime-bot/1.0"})
        resp = urllib.request.urlopen(req, timeout=10)
        ms = (datetime.datetime.now() - start).total_seconds() * 1000
        return resp.status == 200, ms
    except Exception as e:
        return False, str(e)

def load_state():
    try:
        return json.load(open(STATE_FILE))
    except FileNotFoundError:
        return {}

def save_state(state):
    json.dump(state, open(STATE_FILE, "w"))

def alert(url, detail):
    smtplib.SMTP("smtp.yourprovider.com", 587)
    # wire your SMTP creds here
    print(f"ALERT: {url} DOWN — {detail}")

def main():
    state = load_state()
    for url in ENDPOINTS:
        ok, detail = check(url)
        prev = state.get(url, {}).get("ok", True)
        if not ok and prev:
            alert(url, detail)          # just went down
        state[url] = {"ok": ok, "at": datetime.datetime.now().isoformat()}
        print(("UP  " if ok else "DOWN"), url, detail)
    save_state(state)

if __name__ == "__main__":
    main()

Run it from cron every minute. That's the entire product you were paying for.

What a Real Monitor Adds (Be Honest About It)

The SaaS tools earn their money on three things a bare script doesn't have:

Escalation policy — page person A, wait 5 minutes, page person B.
Status pages — a public trust surface for your customers.
Alert deduplication — one incident, not 400 emails.

But notice: all three are logic, not infrastructure. And logic is exactly what you can own. Start with the script above, then layer escalation on top of it. Every line you own is a line you control during the incident that matters.

The Part Nobody Tells You: Monitoring Is the Easy 20%

Uptime is 20% of running operations. The other 80% is what happens after the alert fires:

Who runs the incident? (You need an on-call drill, not a hero.)
What's the first 30 minutes look like? (A checklist beats improvisation.)
How do you write the incident report the client will actually read?

That post-alert 80% is where small teams drown — and where the difference between a 20-minute blip and a lost customer lives.

If You Want the 80% Solved Too

I packaged the operational side — the incident checklist, the on-call drill schedule, the post-mortem templates — into the Ops Starter Kit:

🛠️ Ops Starter Kit (checklists, drills, templates): https://hive80lab.gumroad.com/l/ops-starter-kit
⚙️ Automation Starter Pack (scripts that run the boring 80% for you): https://hive80lab.gumroad.com/l/automation-starter-pack

Use code LAUNCH50 for 50% off at checkout.

The uptime script above is free and always will be. The 80% is what we sell — because that's the part that takes years to learn the hard way.

What does your current monitoring stack cost per year? Put it in the comments — I'll tell you which parts are worth keeping.

DEV Community