Monitoring Twenty CRM with Vigilmon: API Health, Web UI, Worker Processes & SSL Alerts

Twenty is the open-source CRM that sales and customer success teams use to manage contacts, track deals, log activities, and coordinate follow-ups — on infrastructure they fully control. It is a full-stack TypeScript application backed by PostgreSQL, with a NestJS API backend, a React frontend, and background worker processes that handle data synchronisation, email integration, and webhook delivery. When Twenty goes down, your team loses visibility into active deals, contact history, and the pipeline that drives revenue decisions. Vigilmon gives you external visibility into Twenty's API health endpoint, web UI availability, worker process signals, and SSL certificate so you're notified the moment your CRM becomes unreachable.

What You'll Build

• An HTTP monitor for Twenty web UI availability
• A liveness check on the Twenty API health endpoint
• SSL certificate monitoring for your Twenty domain

Prerequisites

• A running Twenty instance with a public or network-reachable domain
• HTTPS configured via a reverse proxy (e.g., https://crm.example.com)
• A free account at vigilmon.online

Step 1: Verify Twenty Web UI Availability

Twenty serves its React frontend from the root path. A successful response confirms the frontend build is being served and the reverse proxy is routing traffic correctly:

curl -I https://crm.example.com
# Expected: HTTP/2 200

A 200 response at the root path confirms that the React app bundle is reachable. This is your primary availability signal — if it fails, sales reps and customer success managers cannot access their contact records, deal pipelines, or activity logs.

Step 2: Create a Vigilmon HTTP Monitor for Web UI Availability

1. Log in to Vigilmon → Add Monitor → HTTP.
2. URL: https://crm.example.com.
3. Check interval: 60 seconds.
4. Response timeout: 10 seconds.
5. Expected status: 200.
6. Keyword: Twenty.
7. Label: Twenty CRM Web UI.
8. Click Save.

This monitor catches:

• React frontend service crashes or container restarts
• Nginx or Caddy reverse proxy failures blocking access to the application
• Out-of-memory kills that terminate the frontend serving process
• Build or deployment errors that cause the frontend to become unservable
• DNS misconfiguration that makes the domain unreachable

When this monitor fires, your team loses access to all CRM functionality — contacts, deals, activities, and reporting become unavailable until the service recovers.

Step 3: Monitor the Twenty API Health Endpoint

Twenty exposes a health check route on the NestJS API backend. This endpoint confirms the application server is running and the database connection is healthy:

curl https://crm.example.com/api/healthz
# Expected: HTTP 200

A typical response:

{"status": "ok"}

This confirms the NestJS API process is running and PostgreSQL is reachable.

1. Add Monitor → HTTP.
2. URL: https://crm.example.com/api/healthz.
3. Check interval: 2 minutes.
4. Expected status: 200.
5. Keyword: ok.
6. Label: Twenty API Health.
7. Click Save.

Why monitor the API separately? In Twenty's Docker Compose stack, the React frontend (served statically) and the NestJS API backend are separate containers. The frontend static files can be served by nginx while the API backend is down — monitoring both gives you independent signals. An API failure means contacts and deals stop loading in the UI even if the frontend itself appears reachable.

Step 4: Monitor Worker Processes

Twenty's background workers handle email sync (IMAP/SMTP integration), webhook delivery, data import/export, and search indexing. A worker crash is silent from the user's perspective — the UI loads normally, but email sync stops, webhooks queue up, and imports hang indefinitely.

Use Vigilmon's cron heartbeat monitor to verify workers are running:

1. In Vigilmon, click Add Monitor → Cron Heartbeat.
2. Set the expected interval to match your worker's health ping frequency (e.g., every 5 minutes).
3. Copy the heartbeat URL.
4. Add the ping to your Twenty worker service configuration or a companion health-check script:

# Run as a sidecar health script alongside your worker container
while true; do
  sleep 300
  curl -s https://vigilmon.online/heartbeat/YOUR_HEARTBEAT_URL
done

If the worker container crashes or the job queue stalls, the heartbeat stops arriving and Vigilmon alerts you before your users notice that their email sync has silently stopped.

Step 5: Monitor SSL Certificates

Twenty stores your team's customer data — contact records, deal history, email threads, and meeting notes. Losing HTTPS access means losing access to all of it:

• Browser certificate errors block all user access immediately
• API integrations (email clients, Zapier, webhook consumers) break simultaneously
• Mobile access fails with TLS errors

1. Add Monitor → SSL Certificate.
2. Domain: crm.example.com.
3. Alert when expiry is within: 30 days.
4. Alert again: 14 days, 7 days, 3 days, 1 day.
5. Click Save.

Step 6: Configure Alerting

In Vigilmon under Settings → Notifications, configure your alert channels:

| Monitor | Trigger | Action | |---|---|---| | Web UI | Non-200 or keyword missing | Check frontend container; inspect nginx/proxy logs; verify DNS | | API Health | Non-200 or keyword missing | Check NestJS container; verify PostgreSQL connectivity; review API logs | | Worker Heartbeat | Heartbeat missing | Check worker container; inspect job queue; verify Redis connectivity | | SSL certificate | < 30 days to expiry | Renew certificate; verify Let's Encrypt auto-renewal is running |

Alert after: 2 consecutive failures for HTTP monitors — this covers ~2 minutes of genuine downtime while filtering single-probe transient failures.

Common Twenty CRM Failure Modes and What Vigilmon Catches

| Scenario | Vigilmon monitor | |---|---| | NestJS API process crash | API Health monitor fires; alert within 2 minutes | | React frontend container crash | Web UI monitor fires; alert within 60 seconds | | PostgreSQL connection failure | API fails to serve data; API Health monitor fires | | Worker container crash | Heartbeat monitor fires after interval passes | | Redis unavailable | Job queue stalls; worker heartbeat stops | | Reverse proxy misconfiguration | Web UI fires; API containers remain running | | SSL certificate expires | SSL monitor alerts at 30 days; all browser access breaks | | Database migration failure after upgrade | API fails to start; API Health monitor fires |

Your CRM is the system of record for every customer relationship your team manages. Vigilmon watches Twenty's web UI, API health endpoint, worker processes, and SSL certificate so you're alerted within 60 seconds of any failure — before your sales team discovers they can't access their pipeline.

Start monitoring Twenty CRM in under 5 minutes — register free at vigilmon.online.