Stop Paying for Monitoring: The Self-Hosted Stack for Indie SaaS Founders

I'm going to say the quiet part loud: most indie SaaS founders are wildly overpaying for monitoring.

I was too. Then I stopped.

Here's what I was running before I built my own stack:

• Datadog: ~$15/host/month (that's the "cheap" tier)
• PagerDuty: $21/user/month
• Baremetrics: $129/month to see my own Stripe data

That's $165+ every single month before I made a single dollar. For a solo founder? That's obscene.

The Real Cost Problem

The monitoring industry is built for teams. Datadog's pricing assumes you have 10+ engineers who need dashboards, alerts, runbooks, and incident management workflows. PagerDuty's on-call rotation features are genuinely useless if you're the only person getting paged.

For indie hackers and small SaaS shops, we don't need enterprise observability. We need:

1. Know when the app is down
2. Know when something weird is happening with billing
3. Know the basic health metrics without a PhD in PromQL

The Self-Hosted Stack

Here's what I run now, total cost: $0 (beyond VPS that I already pay for).

Uptime Kuma — replaces StatusPage, Uptime Robot, etc. Runs on your VPS, beautiful UI, Telegram/Slack/email alerts. 5 minute setup. Free.

Netdata — replaces Datadog for host metrics. Lightweight, real-time, runs on the same VPS. The free tier covers everything a solo founder needs.

BillingWatch — this one I built myself because nothing else did what I needed. It's a self-hosted Stripe anomaly detector that watches for: sudden revenue drops, subscription spikes, unusual refund patterns, card decline surges. Runs as a lightweight Python daemon, connects to your Stripe webhook, alerts you on Slack or email when something looks off.

The gap I kept hitting was: Stripe sends you raw webhook data, but it doesn't tell you when something trends in a bad direction. BillingWatch does pattern analysis over your event stream and fires alerts based on configurable thresholds.

Real Numbers

Before: $165/month in monitoring tools
After: $0/month

Time to set up the full stack: about 3 hours (most of that was Netdata configuration)

What I gave up: fancy dashboards nobody looks at, on-call rotation features for a team of one, and Baremetrics charts I could build in 20 lines of Python.

What I kept: knowing when things break, knowing when billing looks weird, peace of mind.

The BillingWatch Setup

Since this one isn't as well-known as Uptime Kuma, here's the quick version:

git clone https://github.com/rmbell09-lang/billingwatch
cd billingwatch
pip install -r requirements.txt
cp .env.example .env
# Add your Stripe webhook secret and Slack webhook URL
python main.py

You configure thresholds in config.yaml:

alerts:
  revenue_drop_percent: 30  # alert if MRR drops 30% in 24h
  refund_spike_count: 5     # alert if 5+ refunds in 1 hour
  churn_rate_daily: 0.05    # alert if daily churn exceeds 5%

Point your Stripe dashboard at the BillingWatch webhook endpoint and you're done. It runs headlessly, stores nothing sensitive, and fires to your Slack channel when thresholds are crossed.

The Broader Point

The SaaS monitoring market optimizes for ACV, not indie founders. Every tool is priced assuming a sales conversation and a multi-seat contract.

Building your own stack with open-source tools isn't a compromise — for our use case, it's genuinely better. Simpler, faster to configure, no vendor lock-in, and you actually understand what it's doing.

If you're paying $100+/month to monitor a one-person SaaS, stop. The open-source alternatives are legitimately good now.

---

BillingWatch is open source on GitHub: https://github.com/rmbell09-lang/billingwatch — give it a star if this was useful.

Questions about the setup? Drop them in the comments.