tutorial

Monitoring Reactive Resume with Vigilmon

Reactive Resume handles sensitive personal data and relies on PostgreSQL, a NestJS API, and a Chrome/Puppeteer PDF renderer. Here's how to monitor every component — from the React SPA to the PostgreSQL database to the Puppeteer print service — with Vigilmon.

Reactive Resume is a polished, feature-rich self-hosted resume builder — real-time preview, multiple templates, ATS-optimized PDF export, and OpenID Connect SSO. It runs as a multi-container Docker Compose stack: a React frontend, a NestJS API backend, PostgreSQL for data storage, MinIO or local filesystem for uploaded assets, and a Chrome/Puppeteer sidecar for PDF rendering. Each of those containers is an independent failure point. The Puppeteer container can stall while the main app looks healthy. PostgreSQL can go down while the API accepts requests but returns 503. Vigilmon monitors each layer independently so you catch failures before your users do.

What You'll Set Up

  • HTTP availability monitor for the Reactive Resume React frontend
  • NestJS API health endpoint monitor with keyword verification
  • TCP probe to PostgreSQL for independent database health monitoring
  • TCP probe to the Puppeteer print service (port 4000) for PDF rendering health
  • SSL certificate expiry alerts for HTTPS deployments
  • Heartbeat monitoring for the PDF rendering workflow

Prerequisites

  • Reactive Resume deployed via Docker Compose (official amruthpillai/reactive-resume images)
  • Frontend accessible on port 3000 and API on port 3100 (or behind a reverse proxy)
  • PostgreSQL running and accessible on port 5432
  • A free Vigilmon account

Step 1: Monitor the Reactive Resume Frontend

The React SPA is served by a Node.js server on port 3000. A 200 response confirms the frontend container is running and serving the application:

  1. Log in to vigilmon.online and click Add Monitor.
  2. Set Type to HTTP / HTTPS.
  3. Enter your Reactive Resume URL: http://resume.yourdomain.com (or https:// if behind a TLS reverse proxy).
  4. Set Check interval to 1 minute.
  5. Set Expected HTTP status to 200.
  6. Click Save.

Monitor the public-facing URL if Reactive Resume is behind nginx, Traefik, or Caddy — this validates the proxy routing as well as the upstream container.

Step 2: Monitor the NestJS API Health Endpoint

The NestJS backend exposes a health endpoint that checks internal dependencies. The API can be running while the database connection is degraded, and the health endpoint surfaces this before users encounter errors:

  1. Click Add Monitor → HTTP / HTTPS.
  2. URL: http://resume.yourdomain.com/api/health (or http://your-server-ip:3100/api/health if the API port is directly accessible).
  3. Set Check interval to 1 minute.
  4. Enable Keyword check and enter ok as the expected keyword.
  5. Set Expected HTTP status to 200.
  6. Click Save.

The health endpoint returns {"status":"ok"} when the API and its database connection are healthy. A PostgreSQL connection failure causes the health endpoint to return a non-200 status — earlier warning than waiting for users to report failed resume saves.

Step 3: TCP Probe PostgreSQL Database

Reactive Resume stores all resume content, user accounts, and session data in PostgreSQL. A database failure causes the API to return 503 errors on every operation — resume creation, editing, and viewing all fail. Monitor the database independently from the application:

  1. Click Add Monitor → TCP Port.
  2. Enter your PostgreSQL server hostname or IP.
  3. Set Port to 5432.
  4. Set Check interval to 1 minute.
  5. Click Save.

A TCP connection to port 5432 confirms PostgreSQL is accepting connections. This provides earlier warning than waiting for the API health check to reflect a database failure — particularly important because NestJS connection pool exhaustion can cause silent degradation where new connections fail but the health endpoint still returns cached success.

Step 4: TCP Probe the Puppeteer Print Service

Reactive Resume uses a separate Chrome/Puppeteer container to render resumes as PDF files. This print service runs on port 4000 in the default Docker Compose configuration. A stalled or crashed Puppeteer container causes PDF export to silently time out while the rest of the application appears healthy:

  1. Click Add Monitor → TCP Port.
  2. Enter your Reactive Resume server hostname or IP.
  3. Set Port to 4000.
  4. Set Check interval to 2 minutes.
  5. Click Save.

Chrome/Puppeteer containers are memory-intensive and prone to OOM kills on servers with limited RAM. A TCP connection to port 4000 confirms the print service is running. Combine this with a memory alert on your server monitoring stack to catch resource pressure before it kills the Puppeteer container.

If your deployment exposes the printer health endpoint, you can also add an HTTP monitor:

  1. Click Add Monitor → HTTP / HTTPS.
  2. URL: http://your-server-ip:4000/health (check your deployment's printer service documentation for the exact path).
  3. Set Expected HTTP status to 200.
  4. Click Save.

Step 5: SSL Certificate Alerts for HTTPS Reactive Resume

Resume data contains sensitive personal information — full name, home address, phone number, employment history, references. HTTPS is not optional. An expired certificate blocks access to the entire application and may expose data in transit if users bypass the browser warning. Add SSL monitoring:

  1. Open the HTTPS monitor created in Step 1.
  2. Enable Monitor SSL certificate.
  3. Set Alert when certificate expires in less than 21 days.
  4. Click Save.

If Reactive Resume is used by job seekers during an active job search, certificate expiry during that period disrupts PDF downloads and sharing — a 21-day window gives you time to renew before it affects active users.

Step 6: Heartbeat Monitoring for the PDF Rendering Workflow

The Puppeteer print service can be running (port 4000 open) while being unable to generate PDFs — Chrome may be running in a degraded state, unable to render pages, or the filesystem mount for PDF output may be broken. Use a heartbeat that exercises the actual PDF generation path:

  1. In Vigilmon, click Add Monitor → Cron Heartbeat.
  2. Name it Reactive Resume PDF Renderer Heartbeat.
  3. Set the expected ping interval to 30 minutes.
  4. Copy the heartbeat URL (e.g., https://vigilmon.online/heartbeat/abc123).

Create a scheduled test that hits the print service directly:

#!/bin/bash
# Reactive Resume PDF renderer health check
# Run via cron every 30 minutes

PRINTER_URL="${REACTIVE_RESUME_PRINTER_URL:-http://localhost:4000}"
VIGILMON_HEARTBEAT="https://vigilmon.online/heartbeat/abc123"

# Check printer service TCP connectivity
if ! nc -z -w5 localhost 4000 2>/dev/null; then
  echo "$(date): Printer service port 4000 unreachable" >&2
  exit 1
fi

# Check printer HTTP health if endpoint is available
HTTP_STATUS=$(curl -s -o /dev/null -w "%{http_code}" \
  --max-time 15 "${PRINTER_URL}/health" 2>/dev/null)

if [ "$HTTP_STATUS" = "200" ] || [ "$HTTP_STATUS" = "404" ]; then
  # 404 means the health path isn't exposed but port is responding
  curl -s --max-time 10 "${VIGILMON_HEARTBEAT}"
  echo "$(date): Reactive Resume printer health check passed"
else
  echo "$(date): Printer returned HTTP ${HTTP_STATUS}" >&2
fi

Add to cron:

# /etc/cron.d/reactive-resume-health
*/30 * * * * root /usr/local/bin/reactive-resume-healthcheck.sh >> /var/log/reactive-resume-health.log 2>&1

Step 7: Monitor MinIO or Local Asset Storage

If your Reactive Resume deployment uses MinIO for uploaded profile photos and assets, add a TCP probe to MinIO's API port:

  1. Click Add Monitor → TCP Port.
  2. Enter your MinIO server hostname or IP.
  3. Set Port to 9000.
  4. Set Check interval to 2 minutes.
  5. Click Save.

A MinIO failure causes profile photos to disappear from resume previews and breaks any uploaded signature or logo assets — visible to users even when the core resume editing functionality works.

Step 8: Configure Alert Channels

  1. Go to Alert Channels in Vigilmon and add email, Slack, or a webhook.
  2. For the PostgreSQL TCP probe, set Consecutive failures before alert to 1 — a database failure immediately breaks all write operations.
  3. For the Puppeteer port 4000 probe, set Consecutive failures before alert to 2 — Puppeteer containers occasionally restart briefly under load.
  4. For the frontend and API monitors, set Consecutive failures before alert to 2 to absorb brief container restarts during docker compose up -d deployments.
  5. Group monitors with a reactive-resume tag for easy dashboard filtering.

Summary

| Monitor | Target | What It Catches | |---|---|---| | HTTP frontend | http(s)://resume.domain.com | Frontend container crash, proxy failure | | API health | /api/health — keyword "ok" | NestJS error, database connection loss | | TCP port 5432 | PostgreSQL host | Database unavailability | | TCP port 4000 | Printer service | Puppeteer crash, OOM kill | | SSL certificate | HTTPS resume URL | Certificate expiry | | Cron heartbeat | Printer heartbeat URL | Silent Puppeteer degradation | | TCP port 9000 | MinIO (optional) | Asset storage failure |

Reactive Resume puts a polished, privacy-respecting resume builder on your own infrastructure — but multi-container Docker Compose stacks have multiple failure points. With Vigilmon monitoring the frontend, API health, PostgreSQL, Puppeteer renderer, and optional MinIO storage independently, you get early warning across every layer before a stalled PDF renderer or database failure reaches your users.

Monitor your app with Vigilmon

Free plan — 5 monitors, no credit card required. Up and running in 60 seconds.

Start free →
← Back to all articles