Monitoring Infrastructure.
Built For Real Systems.
Monitor websites, APIs, and services with real-time event streaming powered by Redis Pub/Sub, Socket.IO, PostgreSQL, and background workers.
Built for Real-Time Monitoring
Every monitor check travels through a resilient event-driven pipeline powered by background workers, PostgreSQL, Redis Pub/Sub, Socket.IO, and intelligent alerting.
Every layer chosen
with intent.
No boilerplate padding. Each technology solves a specific problem in Pulse Monitor's production pipeline.
Everything you need to monitor with confidence.
From sub-second alerting to a 6-month availability heatmap — a complete operational picture in one place.
One screen. Every signal.
This is what your team sees during an incident — monitors, alerts, latency, and the event stream, all in one operations view.
History you can actually read.
Every check, stored and charted — 32 weeks of availability at a glance, and response time down to the minute.
Built with intention. Engineered for production.
Every architectural decision has a reason. Here's the thinking behind the systems that power Montu Pilot.
Scheduling thousands of HTTP checks reliably without blocking the web server or losing jobs on restart.
A dedicated background worker process polls a persistent job queue, executes checks in isolation, and writes results directly to PostgreSQL — fully decoupled from the Next.js server lifecycle.
Long-running tasks like HTTP checks cannot live inside HTTP request handlers — they time out, block event loops, and lose state on deploy.
Workers run as a separate process with their own lifecycle. Each check job is idempotent — retried up to 3 times on failure, with exponential backoff to avoid thundering herd.
Pushing a check result to every connected browser client without polling, and without coupling the worker to the WebSocket layer.
The worker PUBLISHes to a Redis channel after every check. The Socket.IO server SUBSCRIBEs and fans out to all rooms — O(1) publish cost regardless of how many clients are connected.
Keeping dashboards in sync with check results as they happen, without clients polling the API on an interval.
Socket.IO subscribes to Redis on server startup and re-emits events to client rooms. Clients receive live updates via a persistent WebSocket connection — zero polling, sub-100ms delivery.
Storing every check result for every monitor without the table growing unbounded or queries slowing down over time.
Prisma ORM with PostgreSQL. The check_results table is indexed on (monitor_id, checked_at DESC) for fast range queries. Older records are archived via a scheduled cleanup worker.
Securing the dashboard and API without building and maintaining a custom auth system from scratch.
Auth.js handles OAuth 2.0 (Google, GitHub) with server-side sessions persisted in PostgreSQL via the Prisma adapter. Server Actions validate session tokens at the boundary — no exposed REST layer.
Ensuring untrusted data from forms and API calls never reaches the database in an invalid state.
Zod schemas are co-located with every form and Server Action. Input is parsed and validated at every trust boundary — client, server action, and database write — with descriptive error messages surfaced to the user.
Demonstrating a coherent, production-ready architecture that scales beyond a single monolith.
Pulse Monitor separates concerns across three processes: the Next.js web server, the background worker, and the Socket.IO relay. Each has a single responsibility — independently deployable and replaceable.
Built to monitor production systems.
Engineered to demonstrate full-stack excellence.
Pulse Monitor is a fully open-source portfolio project. Explore the source code, read the architecture, and see how every piece fits together.