June 26, 2026

Observability for a side project: 80% of the value for $0/month

How I instrument side projects without paying Datadog $70/month. Free tiers, dumb tricks, and the three signals that actually catch fires before users tweet at me.

KEY TAKEAWAYS

↳Three signals catch 80% of side-project fires: uptime, error rate, and a single business metric like signups or paid conversions.
↳Sentry, Axiom, Better Stack, and Cloudflare Analytics free tiers cover most solo apps without a credit card.
↳Log structured JSON from day one. Grep is fine until it isn't, and switching later is cheap if the shape is right.
↳Alert on user-visible symptoms, not CPU graphs. A Discord webhook beats a $0 PagerDuty trial you'll never configure.

My rule for side projects: if I can’t see it break, I shouldn’t ship it. But I’m also not paying Datadog $70 a month to watch a Next.js app that makes $40 in MRR. So over the last two years of shipping small things (Photo AI Studio, Interior AI Designs, a couple of agent demos) I’ve settled on a stack that costs $0 and catches the stuff that actually matters.

This is that stack. And the parts I deliberately skip.

The three signals that matter

Google’s SRE book lists four golden signals: latency, traffic, errors, saturation. For a side project that’s overkill. I track three things:

Is the site up (synthetic check from outside my infra)
Are requests erroring (server-side exceptions + 5xx rate)
Is the one business metric moving (signups, checkouts, agent conversations finished)

That’s it. If those three are green I sleep fine. CPU, memory, p99 latency on a single endpoint, I don’t care until a user complains or the error rate spikes. You can always add more later. You can’t get back the weekend you spent configuring Grafana for an app with 12 daily actives.

Uptime: Better Stack free tier

Better Stack (formerly Better Uptime) gives you 10 monitors on the free plan, 3-minute check intervals, and a status page. I point one monitor at the marketing site, one at /api/health, and one at whatever critical third-party flow exists (usually a Stripe webhook test endpoint or a FAL inference endpoint).

The health endpoint is dumb on purpose:

// app/api/health/route.ts
export async function GET() {
  try {
    await db.execute('select 1');
    return Response.json({ ok: true, ts: Date.now() });
  } catch (e) {
    return Response.json({ ok: false, error: String(e) }, { status: 503 });
  }
}

No fancy dependency tree, no checking every downstream. If the DB is down, I want to know. Everything else I’ll find out from Sentry. Alerts go to a Discord webhook in a #alerts channel that’s muted on my phone except between 8am and 11pm. Self-care, sort of.

Errors: Sentry free tier

Sentry gives you 5,000 errors per month free. For a side project with a few hundred users that’s plenty. If you blow past it, either you have a bug storm (good, you needed to know) or you have real traffic (congrats, now you can afford the $26 plan).

The install is two lines in a Next.js or SvelteKit app. The part most people skip is tagging. Without tags, Sentry is a wall of stack traces. With tags, it’s a search engine for your problems:

import * as Sentry from '@sentry/nextjs';

Sentry.setUser({ id: userId });
Sentry.setTag('plan', user.plan);
Sentry.setTag('feature', 'image-generation');
Sentry.setContext('job', { model: 'flux-pro', seed });

Now when something breaks I can filter to “free plan users on image-generation” in three clicks and see if it’s one user with a weird input or everyone. That distinction has saved me probably 20 hours of debugging across projects.

One knob worth turning: tracesSampleRate: 0.1. The free tier’s transaction quota is small. Sample 10% of traces, keep 100% of errors. You’ll still catch the slow endpoints, you just won’t burn quota on every healthcheck.

Logs: Axiom or just Cloudflare

This is the place people overspend. You don’t need Datadog Logs at $0.10/GB ingested. You need to be able to grep the last 7 days when something weird happens.

Two options I rotate between:

Axiom gives you 500GB/month ingest free. That’s absurd for a side project. Their Vercel and Cloudflare integrations are one-click. You get a queryable log store with APL (their SQL-ish language) and you can build a basic dashboard. I use it when the project has actual users.

Cloudflare Workers Logs / Logpush is what I use when the project is on Workers anyway. Free tier includes the dashboard tail and a week of logs in the new Workers Observability feature. Zero new accounts to manage.

The one habit that matters more than the tool: log structured JSON, always.

function log(event: string, data: Record<string, unknown>) {
  console.log(JSON.stringify({ event, ts: Date.now(), ...data }));
}

log('checkout.completed', { userId, amount, plan, sessionId });
log('agent.tool_call', { toolName, durationMs, success });

Grep works on this. Axiom parses it for free. Future-you trying to figure out why Tuesday’s revenue dropped will thank present-you.

The one business metric

This is the part most engineers skip and it’s the most important one. Pick the single number that tells you the app is working as a business. For Photo AI Studio it’s paid generations per day. For an agent we ship at EdsDev it’s usually conversations marked resolved without human handoff. For a SaaS, it’s trial signups.

Plot that one number somewhere you’ll actually look. I use a private page on the marketing site that hits the DB directly and renders a sparkline. No tool, no integration, 40 lines of code:

const rows = await db.execute(`
  select date_trunc('day', created_at) as day, count(*) as n
  from generations where paid = true
  and created_at > now() - interval '30 days'
  group by 1 order by 1
`);

When this line goes flat for two days in a row, something is wrong even if Sentry is quiet and Better Stack is green. That’s a class of bug instrumentation catches that pure error monitoring misses entirely. The checkout silently routing to the wrong price ID. The signup flow 200-ing but not actually creating users. The agent answering but answering wrong.

What I deliberately skip

No APM. No distributed tracing. No RUM. No custom Grafana. No on-call rotation (it’s me, my rotation is “am I awake”).

When a side project crosses about 1,000 DAU or $1k MRR, I revisit. Usually I add OpenTelemetry traces to one or two endpoints that have gotten weird, and that’s it. The Cloudflare + Sentry + Better Stack + one SQL dashboard combo has carried apps through five-figure user counts without getting in the way.

The trap is treating observability like a status symbol. A real engineer uses Datadog, right? Sure, at work, where someone else pays. On your side project, the goal is to know within 5 minutes if it’s broken and within an hour why. $0/month does that fine.

If you’re building something and want a sanity check on the stack before you ship, come say hi.

FREQUENTLY ASKED

Common questions

▸When does the free tier stop being enough?

Sentry's 5k errors/month is the usual first ceiling. If you're hitting it from real users (not a bug storm) you probably have enough traffic that $26/month for the Team plan is fine. Better Stack's 3-minute checks become a problem if you need sub-minute detection, which most side projects don't. Axiom's 500GB free tier is hard to exceed without doing something wrong, like logging full request bodies. Fix that before upgrading.

▸Why not just use Vercel Analytics or the built-in Next.js telemetry?

Vercel Analytics is fine for traffic but it doesn't catch server errors, doesn't let you query logs, and doesn't alert. It's a piece of the picture, not the whole thing. I use it alongside Sentry on Vercel-hosted projects. The built-in Next.js telemetry is for the framework's own usage data, not yours.

▸Do I really need a status page for a side project?

No, but Better Stack gives you one for free as part of the monitor setup, so you might as well. It's useful in exactly one scenario: a user emails you saying the site is broken and you can link them to the status page instead of debugging blind. For agent products with business users, it also signals you take uptime seriously.

▸What about cost monitoring for AI APIs?

Separate problem, same approach. Log every API call with model name, token counts, and cost estimate as structured JSON. Sum it daily in your one business metric dashboard. OpenAI and Anthropic both have usage dashboards but they lag and don't break down by feature. Your own log-based tracking will catch a runaway loop hours before their dashboard does.

▸Discord webhooks for alerts, really?

Yes. It's free, it's on my phone, and I can mute it at night. PagerDuty's free tier exists but the setup overhead isn't worth it for a project that doesn't have an SLA. The actual win is filtering: only page on uptime failures and error-rate spikes, not every individual Sentry event. Otherwise you train yourself to ignore the channel.

SOURCES

[1]
Google SRE Book: Monitoring Distributed Systemssre.google
[2]
Sentry pricing and free tiersentry.io
[3]
Better Stack uptime monitoring pricingbetterstack.com
[4]
Axiom pricingaxiom.co
[5]
Cloudflare Workers Observabilitydevelopers.cloudflare.com

5/25/2026