DEV Community: Ayo

How to Add API Monitoring to an Express App in 5 Minutes (2026)

Ayo — Sat, 23 May 2026 09:48:27 +0000

Step 2: Install the SDK

One command:

npm install pingoni

That's the entire install. No native dependencies, no agent to configure, no separate config file.

Step 3: Add the middleware

Two lines change in your app.js. Require the package at the top, then mount the middleware before your routes:

const express = require("express");
const pingoni = require("pingoni");
const app = express();

app.use(express.json());
app.use(pingoni(process.env.PINGONI_API_KEY));   // ← add this

app.get("/", (req, res) => {
  res.json({ status: "ok" });
});

// ... rest of your routes

That's it. Every request to your app will now be captured: method, path, status code, response time, timestamp. Mounting the middleware before your routes means it wraps everything — including the static and JSON parsing middleware.

Step 4: Add the error handler

Errors need a separate handler because of how Express's error-handling pipeline works. Express error middleware must be the last middleware mounted — after all your routes.

// ... all your routes go here ...

app.use(pingoni.errorHandler(process.env.PINGONI_API_KEY));  // ← add at the bottom
app.listen(PORT, () => console.log(`Listening on ${PORT}`));

This catches any error that bubbles up from your routes — including uncaught exceptions, errors passed to next(err), and async errors in handlers that use modern Express patterns. Stack traces, the request that caused the error, and the error message are all captured automatically.

The complete instrumented app

Here's what your app looks like fully instrumented. Two added lines total:

const express = require("express");
const pingoni = require("pingoni");
const app = express();

app.use(express.json());
app.use(pingoni(process.env.PINGONI_API_KEY));

app.get("/", (req, res) => {
  res.json({ status: "ok" });
});

app.get("/users/:id", (req, res) => {
  res.json({ id: req.params.id, name: "Sample User" });
});

app.post("/orders", (req, res) => {
  res.status(201).json({ orderId: "ord_abc123" });
});

app.use(pingoni.errorHandler(process.env.PINGONI_API_KEY));

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => console.log(`Listening on ${PORT}`));

Five minutes of work. Production-ready monitoring.

Step 5: Test it locally

Start the app and hit a few endpoints:

node app.js

# In another terminal:
curl http://localhost:3000/
curl http://localhost:3000/users/42
curl -X POST http://localhost:3000/orders -H "Content-Type: application/json" -d '{}'

Open your Pingoni dashboard within 30 seconds and you should see the requests appearing — method, path, status code, response time. To confirm the error handler works, add a route that throws:

app.get("/break", (req, res) => {
  throw new Error("intentional test error");
});

Hit it once, then check your dashboard — the error should show up with the full stack trace and the request that triggered it.

Step 6: Deploy

If you're already deployed to Railway, Vercel, Render, Fly, or anywhere else: add PINGONI_API_KEY to your environment variables in that platform's settings, redeploy, and you're done.

If you haven't deployed yet, this is exactly the right time. Monitoring on day one of production beats monitoring set up after the first incident.

What you actually see in the dashboard

Once events are flowing, the dashboard gives you:

Live request feed: most recent requests with their timing and status
Endpoint breakdown: requests per endpoint, broken down by status code (so you can see "POST /orders is throwing 5% errors")
Latency per endpoint: p50, p95, p99 for each route
Error feed: every exception with stack trace, the URL that caused it, and request metadata
Traffic over time: request volume so you can see traffic patterns

You're now in the small minority of small-team Express apps that actually have production visibility.

Going further

The setup above gives you the essentials. A few things worth knowing for later:

Custom tags. You can attach metadata to a request (user ID, feature flag, A/B variant) for filtering in the dashboard. This becomes useful once you have meaningful traffic and want to slice by dimension.

Email alerts. Pingoni sends email alerts on high error rates. Configure thresholds in your dashboard settings. Webhook delivery (Slack, PagerDuty, etc.) is on the near-term roadmap.

Frontend monitoring. This post is about API monitoring. If you also want to capture frontend errors (JS exceptions in the browser, slow page loads, etc.), pair this with a frontend tool like Sentry. The two solve different problems.

Honest alternatives

In the interest of giving you the full picture: Pingoni isn't the only option for monitoring an Express app. A few others worth knowing about:

Sentry — best in class for error monitoring specifically, less focused on request/latency tracking. Pair well together.
New Relic — full APM with a generous free tier (100GB/month). More setup, but more features if you're growing.
Better Stack — strong for uptime monitoring + log management with a clean UI.
Self-hosted SigNoz — open source, OpenTelemetry-based. More work to operate, no vendor lock-in.

Pick the one that matches your stack and team size. The worst monitoring stack is the one you keep meaning to set up but haven't.

Wrapping up

Adding monitoring to an Express app shouldn't be a project. Two lines of code, one npm install, one environment variable. If you're shipping Node APIs in 2026 without basic request and error tracking, you're flying blind for no good reason — the tools have caught up to small teams.

If you want to try Pingoni specifically, the free tier covers 10,000 requests/month and the setup is exactly what's in this post. If something else on the list fits better, use that. Just ship something.

Introducing LLM Cost Tracking in Pingoni: See Your OpenAI Spend Per User in 5 Minutes

Ayo — Tue, 19 May 2026 20:24:30 +0000

A few days ago I published a blog post about being a solo dev competing in the API monitoring space, and in it I mentioned LLM API cost tracking was the next feature on Pingoni's roadmap. That post is still up — and I want to update it with this news instead of letting it sit there as a promise.

As of today, LLM cost tracking is shipped in Pingoni. It works alongside your existing API monitoring. Same SDK, same dashboard, same five-minute setup. And — at least for now — LLM event tracking is unlimited and free for everyone, on both the Free and Pro tier.

This is what it does, why it exists, and how you can have it running in your Node app before lunch.

The problem this solves

If you've shipped an AI feature in the last year, you probably know the email. The one from OpenAI that says "Your usage this month: $4,287" when you expected $200. Or the one from a customer who built an integration on your platform and is now somehow generating thousands of dollars in LLM costs you can't attribute to anyone.

Most teams ship AI features with zero visibility into spend until the bill arrives. Not because they don't care — but because the tools for this are either expensive enterprise platforms (Datadog LLM Observability), narrowly-focused proxy tools (Helicone), or open-source projects that require you to operate infrastructure (Langfuse self-hosted).

None of those are the right shape for a solo dev or small team that just wants to know:

How much did our LLM features cost this week?
Which user is racking up the highest bill?
Which feature should we optimize first?
Are we approaching a budget threshold?

Now you can see all of that in the same dashboard where you already look at your API errors and latency.

How it works — 5-minute integration

If you already use Pingoni for API monitoring, you have the SDK installed. Add one function call after your OpenAI request:

const pingoni = require("pingoni");
const OpenAI = require("openai");

const openai = new OpenAI();

const response = await openai.chat.completions.create({
  model: "gpt-4.1",
  messages: [{ role: "user", content: userQuestion }],
});

// New: track the cost
pingoni.trackLLM({
  provider: "openai",
  model: "gpt-4.1",
  usage: response.usage,
  userId: req.user.id,            // optional but recommended
  feature: "document-summary",    // optional, for attribution
});

That's it. The SDK is fire-and-forget — it doesn't block your response or crash your app if our API is down. Costs are calculated server-side based on the current pricing of each model, so you don't have to maintain a pricing table.

If you're not using Pingoni yet, the full install is:

npm install pingoni

Then in your Express app:

const pingoni = require("pingoni");
app.use(pingoni(process.env.PINGONI_API_KEY));  // request monitoring
// ... your routes ...
app.use(pingoni.errorHandler(process.env.PINGONI_API_KEY));  // error capture

What you see in the dashboard

The LLM Costs tab gives you four views:

Total spend over time. A line chart showing daily cost across the period you select. Useful for catching spikes the moment they happen.

Breakdown by model. Which models are responsible for what share of your spend. Often the answer is surprising — a small number of GPT-4.1 calls usually dwarfs a large number of GPT-4.1-nano calls.

Top users by cost. If you're passing userId, you see exactly which of your users are most expensive. This is the most-loved feature in early testing because it tells you instantly whether a single power user (or an abuse case) is responsible for a cost spike.

Top features by cost. If you're passing feature, you see which AI features in your product cost the most. Useful when deciding what to optimize, gate, or charge for.

What's currently supported

I'm being explicit about this so there are no surprises:

Works today: OpenAI APIs only. All chat completions, reasoning models (o3, o4-mini), vision/multimodal calls, and function/tool use. 16 OpenAI models are seeded in the pricing table — from gpt-4.1-nano up through gpt-5.4, o3, and the rest of the current lineup.

Coming next: Anthropic / Claude support. Different response shape, needs a small adapter — should land within a few weeks.

Not on the immediate roadmap: Embeddings (different pricing model), image generation (priced per image), audio/Whisper/TTS (priced per minute). If you call trackLLM with these, the event will be stored but the cost will read as $0. Working on better handling for the unsupported cases.

Pricing: free for everyone, for now

I want to be straightforward about this part because the easiest mistake to make at launch is over-architecting pricing for a feature nobody has used yet.

Right now, LLM event tracking is unlimited on both the Free tier and the Pro tier. There is no per-event cap, no per-month limit, and no upgrade gate for using it. Send as many events as you want.

The only existing usage limit on Pingoni is the 10,000 API request logs per month on the Free tier — and that's for your regular HTTP request monitoring, not for LLM events. Those are tracked separately.

If LLM usage gets abused — someone tries to send a million events per second from a botnet, or whatever creative thing eventually happens — I'll add tier limits then. But I'm not going to invent a limit I don't need to enforce, and I'm not going to put a counter on a feature on its first day in the wild.

Pro at $9/month still makes sense for teams sending more than 10,000 API requests/month. LLM tracking just happens to be included at every tier.

Why this is different from Helicone / Langfuse / etc.

I keep getting asked some version of this, so let me address it directly. The honest answer:

Helicone is a proxy-based tool focused exclusively on LLM observability. If LLM costs are your only problem and you don't mind routing through a proxy, Helicone is excellent.

Langfuse is a full open-source LLM engineering platform — traces, evals, prompt management, cost. If you want the most comprehensive LLM-specific tool and don't mind running infrastructure (or paying for their cloud), Langfuse is the right call.

Pingoni is API monitoring first, with LLM cost tracking as a unified feature on top. If you already need monitoring for your Node API (request tracking, error capture, latency) AND you want LLM cost visibility, Pingoni gives you both in one dashboard, one SDK, one bill.

Pick the tool that matches your shape. There's no single right answer.

What's next

Two things on the immediate roadmap:

Claude / Anthropic support — same trackLLM() API, different model strings. Targeting within 3-4 weeks.

Budget alerts — email and webhook alerts when spend exceeds a threshold per day, per user, or per feature. Targeting within 4-6 weeks.

Both will be available on free and Pro tiers when they ship.

Get started

If you want to try LLM cost tracking on your own OpenAI usage right now:

Sign up for Pingoni (free)
Install the SDK: npm install pingoni
Add pingoni.trackLLM() after your OpenAI calls
Open the LLM Costs tab in your dashboard

You'll see costs flowing within seconds.

If you're already a Pingoni user, just update to the latest SDK version and the trackLLM() function will be available.

Pingoni is built by Ayo, a solo dev in Edmonton building lightweight API monitoring for small teams.

Datadog Alternatives for Small Teams (2026): An Honest Comparison from a Solo Dev

Ayo — Mon, 11 May 2026 04:06:59 +0000

Datadog is the most popular observability platform in the world. It's also the source of more Twitter horror stories than any other piece of B2B software. Search "Datadog bill" and you'll find threads about teams getting invoiced 5x what they budgeted, indie devs being charged more than their AWS bill, and at least one $65M annual contract that made the rounds during a Coinbase earnings call.

If you're a small team — anywhere from 1 to 30 engineers — Datadog is probably overkill. Not because it's bad. Because it's built for companies with platform teams whose entire job is taming the observability stack. You don't have that. You have a product to ship.

I'm writing this from a slightly biased seat: I'm building Pingoni, an API monitoring tool that's one of the alternatives I'm about to compare. I'll be upfront about where Pingoni fits and where it doesn't. The point of this post isn't to sell you Pingoni — it's to help you pick the right tool for your situation, because the worst outcome for everyone is you signing up for the wrong thing, hating it, and going back to Datadog out of frustration.

Let's get into it.

Why small teams actually leave Datadog

Before we talk alternatives, it's worth being precise about why you're looking. The four reasons I hear most:

1. The bill scales faster than your infrastructure. Datadog's base infrastructure plan is $15 per host per month on annual billing, $18 month-to-month. That sounds reasonable until you add APM ($31/host), log ingestion ($0.10/GB) and indexing ($1.27 per million events), custom metrics, RUM, and synthetic checks. A 10-host setup with the typical bundle lands around $2,000-$3,000/month. For a team that hasn't hit revenue yet, that's existential.

2. Per-container billing on Kubernetes nukes your budget. If your agent is deployed per container instead of per node — which is the default in many setups — every container counts as a host. A modest K8s cluster can 10x your bill overnight.

3. The setup is a project, not a task. Datadog has 850+ integrations, and configuring even a fraction of them properly takes a week. Dashboards have to be built. Agents have to be deployed. Tags have to be standardized. You're not going to get value out of Datadog in an afternoon.

4. You don't have servers. If you're running on Vercel, Netlify, Cloudflare Workers, or serverless on AWS, Datadog's agent-based model doesn't fit your stack. You can't install the agent on a Vercel edge function.

If any of those describe you, you're in the right place. Now let's look at what to actually pick.

What "right-sized" means for a small team

Before tools, the framework. For 90% of small teams, you only need three things from monitoring:

Know when something breaks (uptime + error alerting)
Understand why it broke (logs + maybe traces)
See trends over time (latency, error rate, traffic)

That's it. You don't need session replay, AI-driven root cause analysis on 47 microservices, or compliance-grade audit logs — yet. When you grow into needing those, you'll know, and you can migrate. Picking the simplest tool that solves today's problem is almost always the right move.

With that lens, here are the eight alternatives worth your evaluation in 2026.

The 8 best Datadog alternatives for small teams

1. Sentry — for error monitoring above all else

If your primary pain is "things break in production and I don't know until users tell me," Sentry is the answer. It's not a Datadog replacement in the full observability sense — it's narrowly focused on error tracking and performance monitoring, and it does that one job exceptionally well. Stack traces, error grouping, release tracking, and session replay are all best-in-class.

Pricing: Free tier covers 5,000 errors/month. Team plan starts at $26/month.
Setup time: 10-15 minutes (one SDK install, one DSN key).
Where it breaks: Sentry isn't great at uptime monitoring or log management. You'll likely pair it with something else.
Pick if: Error visibility is your #1 problem and you're a frontend-heavy team.

2. Better Stack — for uptime + logs + status pages in one place

Better Stack (formerly Better Uptime + Logtail) is the cleanest "Datadog Lite" for teams that mainly need uptime checks, log management, and a customer-facing status page. The UI is genuinely beautiful, which sounds shallow but matters when you're staring at it during an incident.

Pricing: Free tier with 10 monitors. Paid plans start at $24/month.
Setup time: ~15 minutes.
Where it breaks: APM and distributed tracing aren't really there. If you need request-level performance data across services, you'll want something else.
Pick if: You need uptime + logs + status pages and you want it to look good.

3. New Relic — the closest full-platform free tier

New Relic shifted to user-based pricing a few years ago and now offers 100GB/month of data ingestion free, with 1 free full-platform user. For a single founder or a 2-3 person team, this is genuinely impressive — you get APM, logs, infrastructure, and RUM at $0/month if you stay under 100GB.

Pricing: Free up to 100GB/month and 1 full user. Additional users $49/month each. Data overage at $0.30/GB.
Setup time: 30-60 minutes (full instrumentation).
Where it breaks: Past 100GB or 2 users, costs ramp up quickly. UI is dense and feels enterprise.
Pick if: You're a solo dev or tiny team and you want the closest thing to Datadog's feature set for free.

4. SigNoz — the open-source full-stack option

SigNoz is the closest open-source equivalent to Datadog APM. Built on OpenTelemetry and ClickHouse, it gives you traces, metrics, and logs in one tool. You can self-host it on a $20/month VPS or use their cloud.

Pricing: Free self-hosted. Cloud starts at $199/month.
Setup time: 30 minutes for Docker Compose, 1-2 hours for a production Kubernetes deployment.
Where it breaks: Self-hosting means you're now operating an observability tool, which is its own job. Plan for ~1 day/month of maintenance.
Pick if: You want full APM with zero vendor lock-in and you're comfortable running infrastructure.

5. Grafana Cloud (with Prometheus + Loki + Tempo) — for the DIY purists

Grafana Cloud's free tier is generous: 10K metrics, 50GB logs, 50GB traces, 14-day retention. The Grafana ecosystem is the de facto open-source observability stack, and most engineers will recognize the UI immediately.

Pricing: Free tier is genuinely usable. Pro starts at $19/month with metered usage on top.
Setup time: 1-2 hours if you're new to Prometheus; faster if you already are.
Where it breaks: Configuring four tools (Prometheus + Loki + Tempo + Grafana) is more cognitive load than a single integrated platform.
Pick if: You have or will have DevOps capacity, want maximum flexibility, and value not being locked in.

6. Middleware — the AI-native challenger

Middleware is positioning itself as Datadog with AI built in: unified APM, infrastructure, logs, and RUM with AI-assisted root cause analysis. Pricing is more transparent than Datadog and they have a real free tier.

Pricing: Free tier available. Pro at $30/host/month.
Setup time: 30-60 minutes.
Where it breaks: Per-host pricing means you'll still hit cost scaling issues — just later and at a lower slope than Datadog. Newer company, smaller community.
Pick if: You want a Datadog-like unified platform at half the price and you're not ready for open source.

7. Pingoni — for solo devs and small teams who just want API monitoring

This is the tool I'm building, so take what follows with the appropriate skepticism. Pingoni is API monitoring stripped to its essentials: drop in an npm SDK with 5 lines of code, see your endpoints' performance, error rates, and response times in a dashboard, get alerted when something goes wrong. There are no agents, no YAML, no Kubernetes operators. If you're running an Express, Next.js, or Node API on Vercel, Railway, or any platform-as-a-service, it works in 5 minutes.

LLM API cost tracking shipped last week — see your spend per user, per feature, per model in the same dashboard. Setup guide: https://dev.to/silentishim/introducing-llm-cost-tracking-in-pingoni-see-your-openai-spend-per-user-in-5-minutes-43ch

Pricing: Free tier, Pro at $9/month, unlimited projects.
Setup time: 5 minutes (npm install, drop in middleware).
Where it breaks: Pingoni is not full-stack observability. No infrastructure monitoring, no frontend RUM, no distributed tracing across microservices. If your stack is 12 services in 4 languages on Kubernetes, this is the wrong tool.
Pick if: You're a solo dev or small team running a Node API on a PaaS and you want monitoring that takes 5 minutes to set up and costs less than your domain renewal.

Try Pingoni →

8. Nurbak Watch — direct alternative to Pingoni

In the interest of honesty: Nurbak Watch occupies almost the same niche as Pingoni — API monitoring for Next.js and Node devs, fast setup, low cost. They've been live longer and have more content out. If you're shopping seriously, evaluate both and pick the one whose UX you prefer. Healthy competition is good for you, and I'm not going to pretend they don't exist.

Pricing: Free during beta.
Setup time: ~5 minutes.
Pick if: Same use case as Pingoni; you should try both and pick the one that fits your taste.

Quick comparison table

Tool	Best for	Pricing start	Setup time	Free tier?
Sentry	Error tracking	$26/mo	15 min	Yes
Better Stack	Uptime + logs + status	$24/mo	15 min	Yes
New Relic	Full-platform on the cheap	Free up to 100GB	60 min	Yes
SigNoz	Self-hosted APM	Free / $199/mo	30+ min	Yes
Grafana Cloud	DIY observability stack	Free / $19/mo	1-2 hr	Yes
Middleware	Unified platform with AI	Free / $30/host	30-60 min	Yes
Pingoni	API monitoring for Node (LLM tracking coming)	Free / $9/mo	5 min	Yes
Nurbak Watch	API monitoring for Next.js	Free (beta)	5 min	Yes

A decision framework — which one is actually right for you

Skip the listicle paralysis. Pick based on your dominant problem:

"I need to know when my API breaks and why." → Pingoni or Nurbak if you're on Node/PaaS. Sentry if you want to add deep error context.
"I need uptime + a status page for customers." → Better Stack.
"I want the most Datadog-like experience for free." → New Relic.
"I refuse to pay for monitoring." → SigNoz self-hosted, or Grafana + Prometheus + Loki.
"I have a real DevOps team." → Grafana Cloud, or stay on Datadog and optimize your spend.
"I'm calling LLM APIs and getting surprise bills." → Pingoni (LLM cost tracking) or Helicone.

You don't need to pick once and never switch. Pick the simplest tool that solves your current problem. Migrate when your problem changes.

A note on cost — the math nobody runs honestly

When teams compare Datadog to alternatives, they usually compare list price. That misses the bigger cost: setup and maintenance time. A team of 3 engineers losing 2 days to onboarding Datadog at a $200K loaded cost per engineer = $4,600 in invisible cost on top of the bill. If your alternative gets you to value in 30 minutes, you just saved more than your first year of subscription.

Optimize for time-to-value, not just sticker price. The cheapest tool you never get fully set up is more expensive than the more expensive one you start using on day one.

Final thoughts

The observability space in 2026 is healthier than it's ever been. Datadog has real competition at every price point, and small teams have legitimate options that didn't exist three years ago. The market is no longer "Datadog or roll your own."

Pick something today. Set it up this week. The worst observability stack is the one you keep meaning to set up but haven't, because it means you find out about outages from angry customers instead of from your dashboard.

If you're a Node/PaaS dev who wants API monitoring that takes 5 minutes and costs less than a coffee subscription, Pingoni's free tier is built for you. If you're somewhere else on the spectrum, one of the other seven tools above will fit. The only wrong answer is doing nothing.