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.
