Beyond Uptime: The Complete Monitoring Stack for SaaS Builders

Your uptime monitor says green.

Your server is responding. CPU is normal. No errors in the logs.

But signups stopped 4 hours ago. Nobody noticed.

That's the gap most monitoring stacks have and it's the gap that costs the most.

This is the monitoring stack we run at NotiLens, built for SaaS teams who don't have a dedicated DevOps engineer watching dashboards all day.

The problem with uptime-only monitoring

Traditional monitoring answers one question: is the server on?

What it doesn't answer:

Are users actually signing up?
Are payments completing — not just initiating?
Are cron jobs processing records — not just running?
Are AI agents producing output — not just executing?

These are business-layer failures. Infrastructure monitoring completely misses them.

Here's how to cover both layers.

Layer 1: Revenue monitoring

Stripe webhooks

Stripe webhook failures are the silent killer most SaaS builders don't monitor. Your endpoint can return 200s while silently failing to process events — subscriptions go stale, payment failures go unhandled, refunds queue up.

NotiLens monitors Stripe from two angles simultaneously.

Signal 1 — Stripe sends directly to NotiLens:
Configure a NotiLens webhook endpoint in your Stripe dashboard alongside your existing endpoint. NotiLens receives the raw event.

Signal 2 — Your backend confirms processing:

app.post('/webhooks/stripe', async (req, res) => {
  const event = stripe.webhooks.constructEvent(
    req.body,
    req.headers['stripe-signature'],
    process.env.STRIPE_WEBHOOK_SECRET
  );

  // Your existing processing logic
  await handleStripeEvent(event);

  // Confirm to NotiLens that processing completed
  await notilens.track("stripe.webhook.processed", {
    type: event.type,
    customerId: event.data.object.customer
  });

  res.json({ received: true });
});

What ML detects:

Stripe sent the webhook ✓ but your backend never confirmed processing ✗ → broken flow alert
Both signals arrived but volume dropped below normal baseline → silence alert
Sudden spike in webhook volume → anomaly alert

The gap between Signal 1 and Signal 2 is where most payment failures hide.

→ Stripe webhook monitoring
→ Stripe payment failure alerts

Shopify orders

Configure Shopify to send webhook events directly to NotiLens:

Go to your Shopify Admin → Settings → Notifications
Scroll to Webhooks → click Create webhook
Select event: Order creation and Order payment
Paste your NotiLens Shopify webhook URL
Set format to JSON → Save NotiLens watches incoming order volume against your baseline. If orders go abnormally quiet for your time of day — silence alert fires. No manual threshold needed.

→ Shopify order monitoring
→ Shopify silent order drop alerts

Layer 2: Silence monitoring

This is the most important layer — and the one nobody talks about.

Silence monitoring answers: is anything actually happening?

Your server can be perfectly healthy while:

No new users have signed up in 6 hours
No new orders have come in since midnight
A background job ran but processed zero records
An API is responding but returning empty results

None of these trigger a server alert. All of them are serious.

// Track every signup
await notilens.track("user.signup.completed", {
  userId: user.id,
  plan: user.plan
});

// Track every activated user
await notilens.track("user.activated", {
  userId: user.id
});

NotiLens learns your baseline — how many signups per hour is normal at 2am on a Tuesday — and alerts you when it drops significantly below that. No manual threshold needed.

You can also detect broken flows — user.signup.completed fired but user.activated never followed within 30 minutes:

Layer 3: Infrastructure basics

Keep this minimal. What you actually need:

Server up/down — server downtime alerts
Server silence — server silence monitoring for when your server stops reporting entirely
API error rate spikes — API error rate monitoring

What you probably don't need yet: APM dashboards, distributed tracing, custom metrics pipelines.

Layer 4: Cron jobs and scheduled tasks

The problem isn't when a cron job crashes. It's when it runs successfully but does nothing.

Exit code 0. Zero records processed. No alert.

Fix: heartbeat monitoring. Your job sends a ping on successful completion. If the ping doesn't arrive in the expected window — alert fires.

// At the end of your cron job
const result = await processBillingRecords();

await notilens.track("billing.sync.job", {
  recordsProcessed: result.count,
  duration: result.durationMs
});

NotiLens ML detects two anomalies beyond just "did it run?":

recordsProcessed consistently 0 — job ran but did nothing
durationMs spikes above normal baseline — job is taking significantly longer than usual, often the first sign of a database or dependency issue before it becomes an outage

→ Cron job failure monitoring

Three jobs to instrument first:

Billing sync
Email delivery
Data cleanup / reporting

Layer 5: Developer activity

Use the official NotiLens GitHub Action — no curl needed:

# .github/workflows/deploy.yml
name: Deploy

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Deploy to production
        run: ./deploy.sh

      - name: Notify deploy success
        if: success()
        uses: notilens/notify-action@v1
        with:
          token:    ${{ secrets.NOTILENS_TOKEN }}
          secret:   ${{ secrets.NOTILENS_SECRET }}
          event:    task.completed
          message:  "Deployed to production — ${{ github.ref_name }}"
          tags:     deploy,production
          open_url: https://myapp.com

      - name: Notify deploy failure
        if: failure()
        uses: notilens/notify-action@v1
        with:
          token:   ${{ secrets.NOTILENS_TOKEN }}
          secret:  ${{ secrets.NOTILENS_SECRET }}
          event:   task.failed
          message: "Production deployment failed — ${{github.ref_name }}"

The action automatically includes repo, branch, commit, actor, and a direct link to the workflow run — no extra config needed.

→ GitHub CI/CD alerts

Know immediately when a deployment breaks. Don't find out because something stopped working in production.

Layer 6: AI agents and automations

AI agents fail in ways traditional monitoring completely misses:

Silent no-output — runs, completes, exits 0, produces nothing.
Infinite loops — keeps retrying the same step, token costs climb silently.
Stuck tool calls — waiting for a response that never comes.

// Track agent lifecycle
await nl.start('Agent run started', { task: 'report-agent' });

// Track token usage — ML detects anomalous spikes (loops)
await nl.metric({ tokens: response.usage.total_tokens }, { task: 'report-agent' });

// On completion
await nl.complete('Agent completed', { task: 'report-agent' });

// On loop/timeout detection
await nl.timeout('Agent exceeded expected duration', { task: 'report-agent' });

NotiLens detects when token usage spikes above your normal baseline — catches infinite loops before your API bill does.

→ AI agent monitoring

For no-code automation platforms:
→ Zapier workflow failure alerts
→ n8n automation monitoring
→ Make.com automation monitoring

The setup order

Don't try to instrument everything at once.

Week 1 — Revenue first:

Stripe webhook tracking
Payment failure alerts
Shopify order silence (if applicable)

Week 2 — Business health:

Signup silence alert
Server up/down
One critical cron job heartbeat

Week 3 — Operations:

API error rate
GitHub CI/CD failures
Second cron job

Week 4+ — AI and automation:

Agent monitoring
Zapier/n8n/Make workflow monitoring

Start with what touches revenue. Work outward from there.

The full SDK install

npm install @notilens/notilens

import { NotiLens } from '@notilens/notilens';

const nl = NotiLens.init('my-app', { token: 'YOUR_TOKEN', secret: 'YOUR_SECRET' });


// Track a business event
await nl.track('event.name', 'Event description', { meta: { ...metadata } });

// Task lifecycle
await nl.start('Job started', { task: 'job-name' });
await nl.complete('Job done', { task: 'job-name' });
await nl.fail('Job failed', { task: 'job-name' });

// Metrics
await nl.metric({ records: 1500, durationMs: 3200 }, { task: 'job-name' });

Full docs at notilens.com/doc

SDK support

NotiLens has official SDKs for most stacks — no HTTP wiring needed:

# Node.js
npm install @notilens/notilens

# Python
pip install notilens

# PHP
composer require notilens/notilens

# Go
go get github.com/notilens/sdk-go

# Rust
cargo add notilens

# Ruby
gem install notilens

Java and Kotlin available via Maven and Gradle. Shell/CLI also supported — useful for bash scripts and cron jobs with no code changes needed.

Full SDK docs at notilens.com/doc/sdk

The honest truth

You can't watch everything. Nobody on your team can.

But you can instrument the things that matter — revenue, user activity, scheduled jobs, agents — and let a system watch them for you.

The goal isn't a dashboard someone checks every morning. The goal is confidence that if something goes quiet or breaks, the right person finds out before your users do.

That's the only monitoring that matters at this stage.

NotiLens covers everything in this stack — silence detection, webhook monitoring, cron heartbeats, AI agent oversight, and automation monitoring. 7-day free trial, no credit card required.

We're giving eligible founders, small teams, and startups 3 months free in exchange for honest feedback — reach out directly if that's interesting.

推荐订阅源

DEV Community