Real-Time Server Health Monitoring

Monitoring system health in real time is critical for maintaining reliability in modern applications. In this project, I built a full-stack server monitoring dashboard designed to track the availability, latency, and overall performance of multiple target URLs simultaneously. The idea was to create a system that doesn’t just log data, but actively streams live metrics to the frontend, giving instant visibility into system status.

At the core of the platform is a Node.js and Express-based backend that handles API communication, scheduling, and real-time updates through Socket.IO. Instead of relying on static polling, the system pushes live data directly to connected clients, ensuring that users always see the latest system state without refreshing the page. This makes the dashboard highly responsive and suitable for real-time monitoring environments.

To extend monitoring beyond basic uptime checks, I integrated a Python-based telemetry agent built with Flask and psutil. This agent collects system-level metrics such as CPU usage, memory consumption, and process data, providing deeper insights into server performance. By combining URL health checks with internal system metrics, the platform offers a more complete monitoring solution.

The architecture is designed with scalability in mind. The system separates the API layer from the scheduler, allowing independent scaling and smoother deployment in containerized environments. It supports both SQLite and PostgreSQL as database backends, making it flexible for development and production use cases. Role-based authentication using JWT ensures that access is controlled, with Admin users having full control and Viewers limited to monitoring capabilities.

From an infrastructure perspective, the entire system is fully Dockerized, making deployment consistent and reproducible across environments. Nginx is used as a reverse proxy to handle routing and improve production readiness. This setup ensures that the platform can handle real-world workloads while maintaining stability and performance.

Overall, this project demonstrates how real-time technologies, combined with a modular and scalable architecture, can transform simple monitoring into a powerful, live observability system.

Tools & Technologies

Frontend: React.js, TypeScript

Backend: Node.js, Express.js, TypeScript, Socket.IO

Telemetry Agent: Python, Flask, psutil

Authentication: JWT-based role access (Admin / Viewer)

Database: SQLite, PostgreSQL

Infrastructure: Docker, Docker Compose, Nginx

Core Systems:

• Real-time data streaming (WebSocket / Socket.IO)
• Health & latency monitoring
• Scheduler-based probing system
• Role-based dashboard access

Deployment Features:

• Containerized services
• Reverse proxy setup
• Scalable API + worker architecture

This project goes beyond basic uptime monitoring and moves toward a real-time observability system that provides immediate insight into both external service health and internal server performance. By combining live data streaming with system-level telemetry, it delivers a clear and continuous view of what’s happening across multiple services at any given moment.

The use of a modular architecture with a separate API layer, scheduler, and telemetry agent ensures that the system remains scalable and easy to extend. Real-time updates via Socket.IO eliminate delays in monitoring, while Dockerized deployment and Nginx integration make the platform production-ready and consistent across environments.

In the end, this dashboard demonstrates how modern tools and thoughtful system design can transform monitoring from a passive process into an active, real-time experience helping developers and teams respond faster, make better decisions, and maintain system reliability with confidence.