Website Monitoring Script That Became a $1,000/Month SaaS (Step-by-Step)

The Tiny Script I Built to Monitor Websites… That Turned Into a $1,000/Month Service

I didn’t set out to build a product.

I just wanted to avoid one thing:

An angry client message.

“Hey… our pricing page is broken. Customers have been complaining.”

The worst part?

I had checked the site… just two days earlier.

That’s when it clicked:

Manual checks don’t work.
Problems don’t wait for you to notice them.

And in that moment, I stopped thinking like a developer…

…and started thinking like someone who needed constant awareness.

The Real Cost Isn’t Fixing Bugs… It’s Finding Them Late

Fixing the issue took 10 minutes.

But discovering it?

That took two days.

And that’s the hidden cost most people ignore:

The damage isn’t in the bug… it’s in the delay.

So I asked a simple question:

“What if I knew instantly when something changed?”

Version 1: A Barebones Script

No dashboard. No alerts. No fancy UI.

Just a simple fetch:

const axios = require("axios");

const targetPageUrl = "https://example.com";

async function getPageContent() {
  const response = await axios.get(targetPageUrl);
  return response.data;
}

getPageContent().then(() => {
  console.log("Page content retrieved");
}); 

That’s it.

Not useful yet but it was the foundation.

Adding Memory: Turning It Into a Real Tool

Fetching data alone is pointless.

You need comparison.

So I added snapshot storage:

const fs = require("fs");

function storeLatestSnapshot(pageHtml) {
  fs.writeFileSync("previous_snapshot.html", pageHtml);
}

function readPreviousSnapshot() {
  if (fs.existsSync("previous_snapshot.html")) {
    return fs.readFileSync("previous_snapshot.html", "utf-8");
  }
  return null;
}

function detectContentChange(previousHtml, currentHtml) {
  return previousHtml !== currentHtml;
}

Now the script could:

• Remember previous state

• Compare new content

• Detect changes
  

Now it had purpose.

Alerts: Where It Becomes Valuable

Detection alone isn’t enough.

Notification is everything.

So I added email alerts:

const nodemailer = require("nodemailer");

async function sendChangeNotification() {
  const emailClient = nodemailer.createTransport({
    service: "gmail",
    auth: {
      user: "your@email.com",
      pass: "your-password",
    },
  });

  await emailClient.sendMail({
    from: "your@email.com",
    to: "client@email.com",
    subject: "🚨 Website Change Detected",
    text: "A change was detected on your website. Please review immediately.",
  });

  console.log("Alert email sent");
}

Now the system:

1. Fetches content

2. Compares with previous version

3. Detects changes

4. Sends alerts
   

That’s not a script anymore.

That’s a system.

Automation: Making It Reliable

Manual execution defeats the purpose.

So I automated it:

const cron = require("node-cron");

cron.schedule("*/30 * * * *", async () => {
  console.log("Checking website for updates...");

  const previousSnapshot = readPreviousSnapshot();
  const latestSnapshot = await getPageContent();

  if (previousSnapshot && detectContentChange(previousSnapshot, latestSnapshot)) {
    await sendChangeNotification();
  }

  storeLatestSnapshot(latestSnapshot);
});

Now it runs:

• Every 30 minutes

• Automatically

• Without human involvement
  

That’s where it becomes dependable.

Scaling It Across Clients

Once it worked for one site…

Scaling was obvious:

const monitoredSites = [
  { clientName: "ClientA", pageUrl: "https://site-a.com" },
  { clientName: "ClientB", pageUrl: "https://site-b.com" },
];

async function monitorAllWebsites() {
  for (const site of monitoredSites) {
    const pageHtml = await axios.get(site.pageUrl).then(res => res.data);

    // Reuse comparison + alert logic
    console.log(`Checked ${site.clientName}`);
  }
}

Now it’s:

• One system

• Multiple clients

• Recurring value
  

That’s when I realized:

This isn’t a script… it’s a service.

The Pricing Shift That Changed Everything

At first, I didn’t charge.

Then I realized what this actually does:

• Prevents revenue loss

• Detects issues instantly

• Reduces business risk
  

So I priced it at:

$50–$150 per site/month

And suddenly:

• 10 sites = $1,000+/month

• Same code

• Almost zero maintenance
  

What This Really Became

• Script → Fetch data

• Tool → Detect changes

• System → Send alerts

• Service → Prevent losses
  

And businesses don’t pay for code.

They pay for:

Peace of mind.

The Big Lesson

I used to think:

“I need bigger ideas.”

Now I think:

“I need better awareness systems.”

Because anything that needs:

• Monitoring

• Checking

• Watching

Can become:

👉 A recurring revenue service

The Framework I’d Use Again

If I started over, I’d look for:

• “Check this regularly” tasks

• Monitoring gaps

• Time-sensitive problems

• Change detection needs
  

Then build:

1. Fetch data

2. Store state

3. Detect changes

4. Send alerts

5. Charge monthly
   

Simple.

Repeatable.

Profitable.

The One Idea That Changed Everything

If something matters… you shouldn’t be the one watching it.

Because humans:

• Forget

• Delay

• Miss things

Systems don’t.