Monitoring RxResume with Vigilmon: Uptime, Health Checks & SSL Alerts for Your Self-Hosted Resume Builder

RxResume is a free, open-source resume builder you can self-host on your own infrastructure. Unlike cloud-based resume tools, a self-hosted RxResume gives you full control over your data — but it also means you're responsible for keeping it running. The app depends on a PostgreSQL database, an S3-compatible storage backend (typically MinIO), and the Node.js web server itself. If any of those layers fail, your users get a broken experience with no one to call. Vigilmon gives you external uptime monitoring that watches RxResume from outside your server and alerts you the moment something goes wrong.

What You'll Build

• A Vigilmon HTTP monitor on RxResume's /api/health endpoint
• A keyword assertion to confirm the backend is genuinely healthy
• A heartbeat monitor to verify database and storage writes succeed
• SSL certificate expiry alerts (if you're running behind a reverse proxy)

Prerequisites

• A running RxResume instance accessible over HTTPS (reverse proxy with Nginx or Caddy recommended)
• A free account at vigilmon.online

Step 1: Verify RxResume's Health Endpoint

RxResume exposes a health endpoint at /api/health on the same port as the web server (default :3000). This endpoint confirms the API server is accepting connections.

curl https://your-rxresume-domain.com/api/health

A healthy response returns HTTP 200 with a JSON body similar to:

{"status":"ok"}

If the API server is down or the Node.js process has crashed, the connection will be refused or time out. If PostgreSQL connectivity fails, the response may return 503.

HTTPS setup: Run RxResume behind a reverse proxy with a TLS certificate. Caddy handles this automatically:

your-domain.com {
  reverse_proxy localhost:3000
}

Step 2: Create an HTTP Monitor in Vigilmon

1. Log in to Vigilmon → Add Monitor → HTTP.
2. URL: https://your-rxresume-domain.com/api/health.
3. Check interval: 60 seconds.
4. Response timeout: 15 seconds.
5. Expected status: 200.
6. Click Save.

Vigilmon will start probing your RxResume health endpoint every 60 seconds from an external location — independent of your VPS, so it catches issues your internal monitoring would miss.

Step 3: Add a Keyword Assertion

A 200 status code confirms the HTTP server responded, but not that RxResume's internals are healthy. Add a keyword assertion to verify the response body content.

In the same monitor:

• Keyword: ok
• Keyword must be present: yes

This catches scenarios where a reverse proxy intercepts the request and returns a 200 with an error page instead of the actual RxResume response body.

Step 4: Monitor Database Connectivity

RxResume depends on PostgreSQL. A database outage will cause resume saves and user authentication to fail even if the web server appears to respond. The best way to verify end-to-end database health is with a Vigilmon heartbeat monitor driven by a cron job that performs a real database query.

Create a Heartbeat monitor in Vigilmon:

1. Add Monitor → Heartbeat.
2. Name: RxResume DB heartbeat.
3. Expected ping interval: 5 minutes.
4. Grace period: 2 minutes.
5. Copy the generated heartbeat URL.

Add a cron job on your server that queries PostgreSQL and pings the heartbeat only on success:

# /etc/cron.d/rxresume-db-heartbeat
*/5 * * * * root \
  psql "$DATABASE_URL" -c "SELECT 1" -q --no-psqlrc > /dev/null 2>&1 && \
  curl -fsS -X POST https://vigilmon.online/api/heartbeat/YOUR-HEARTBEAT-ID

Replace $DATABASE_URL with your PostgreSQL connection string (e.g., postgresql://user:pass@localhost:5432/rxresume). If the database goes offline, the cron job fails silently and the heartbeat stops — Vigilmon alerts you within 7 minutes.

Step 5: Monitor MinIO / S3 Storage Connectivity

RxResume stores uploaded assets (profile photos, resume PDFs) in an S3-compatible backend. If MinIO goes offline or loses connectivity, resume exports and image uploads will fail even though the web server reports healthy.

Add a second heartbeat monitor for storage health:

# /etc/cron.d/rxresume-storage-heartbeat
*/5 * * * * root \
  mc admin info local > /dev/null 2>&1 && \
  curl -fsS -X POST https://vigilmon.online/api/heartbeat/YOUR-STORAGE-HEARTBEAT-ID

This uses the MinIO Client (mc) to query the local MinIO admin API. If you use a remote S3 provider, replace the mc check with a lightweight aws s3 ls command against your bucket.

Step 6: SSL Certificate Monitoring

If RxResume is behind a reverse proxy with HTTPS, add an SSL certificate monitor to get notified before your certificate expires:

1. Add Monitor → SSL Certificate.
2. Domain: your-rxresume-domain.com.
3. Alert when: certificate expires within 14 days.

Let's Encrypt certificates expire every 90 days. Auto-renewal usually works — but "usually" isn't good enough for a production instance. This monitor catches renewal failures before your users start seeing browser certificate warnings.

Step 7: Configure Alerting

In Vigilmon under Settings → Notifications:

| Trigger | Channel | Action | |---|---|---| | /api/health returns non-200 | Email + Slack | Restart RxResume: systemctl restart rxresume | | Response timeout (> 15 s) | Email | Check Node.js logs: journalctl -u rxresume -n 50 | | Keyword ok missing | Email | Inspect reverse proxy config for interception | | DB heartbeat misses | Email | Check PostgreSQL: systemctl status postgresql | | Storage heartbeat misses | Email | Check MinIO: systemctl status minio | | SSL expires within 14 days | Email | Run certbot renew or check Caddy renewal logs |

Alert after: 1 consecutive failure — RxResume is not a flapping service; if it's down, it's down.

Running RxResume as a systemd Service

For VPS deployments, keep RxResume running with auto-restart:

# /etc/systemd/system/rxresume.service
[Unit]
Description=RxResume
After=network.target postgresql.service

[Service]
Type=simple
User=rxresume
WorkingDirectory=/opt/rxresume
EnvironmentFile=/opt/rxresume/.env
ExecStart=/usr/bin/node /opt/rxresume/apps/server/dist/main.js
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

sudo systemctl enable --now rxresume

With systemd auto-restart and Vigilmon external monitoring:

1. RxResume crashes → systemd restarts within 5 seconds
2. If the restart fails, Vigilmon detects the outage within 60–120 seconds and alerts you
3. You SSH in and check journalctl -u rxresume -n 100

What Vigilmon Catches That Server Logs Miss

| Scenario | Server logs | Vigilmon | |---|---|---| | Node.js process OOM crash | May log before exit | HTTP monitor fires within 60–120 s | | PostgreSQL disk full | DB error logs | DB heartbeat stops; alert fires | | MinIO unreachable | App error logs | Storage heartbeat stops; alert fires | | SSL certificate expired | Nothing logged | SSL monitor alerts 14 days early | | VPS network partition | Logs inaccessible | External Vigilmon still detecting outage |

Self-hosting RxResume puts you in control of your data, but it also puts you on the hook when things go wrong. Vigilmon closes that gap with external, independent monitoring that watches every critical layer — web server, database, storage, and SSL — and tells you exactly where the problem is when it happens.

Start monitoring your RxResume instance in under 5 minutes — register free at vigilmon.online.