How to Monitor Corteza with Vigilmon

Corteza is a modern open-source low-code platform and enterprise CRM framework (Go backend / TypeScript frontend, Apache 2.0) designed as a self-hosted alternative to Salesforce Low Code and Microsoft Power Apps. It ships with a production-ready built-in CRM (Corteza CRM), Corteza Messaging, a visual workflow automation engine (Corteza Workflow), and a low-code application builder (Corteza Compose) for custom business applications — all deployed as a single Docker-based service.

When you self-host Corteza, you own the uptime. This tutorial shows you how to set up comprehensive monitoring for a Corteza deployment using Vigilmon, covering the web UI, built-in health endpoint, API gateway, SSL certificates, and workflow engine health.

Why monitoring Corteza matters

Corteza is a Go-based API server with a TypeScript SPA frontend, a PostgreSQL database, and an event-driven workflow automation engine. Each layer can fail independently:

API server crash — the Go server stops responding; all frontend operations fail simultaneously
Database connectivity loss — Corteza's backend loses its PostgreSQL connection; reads and writes fail with 500 errors
Workflow engine failure — the event-driven Corteza Workflow processor stops handling automation rules; business processes silently stall
Message queue stoppage — Corteza's internal message queue stops processing; sink endpoints and webhook integrations queue up or drop
Frontend asset failure — a bad deployment causes the TypeScript SPA to fail to load; users get a blank or broken UI

External monitoring from Vigilmon checks each layer from the outside — the same way your users and integrated tools experience Corteza.

What you'll need

A running self-hosted Corteza instance (Docker Compose recommended)
A free Vigilmon account — no credit card required
Your Corteza public URL (e.g. https://crm.yourdomain.com)

Step 1: Monitor the Corteza web UI

The web UI check confirms that your reverse proxy is running and the Corteza frontend is being served.

Log in to vigilmon.online and go to Monitors → New Monitor
Choose HTTP / HTTPS
Set the URL to:
```
https://crm.yourdomain.com/
```
Check interval: 1 minute
Expected status code: 200
(Optional) Response body contains: Corteza
Save the monitor

A 200 response confirms the reverse proxy (Nginx or Caddy) is running and the SPA is being served. This is your fastest first-line check.

Step 2: Monitor the built-in health endpoint

Corteza exposes a /healthcheck endpoint that returns the health status of all system components — including the database connection, internal services, and the workflow engine.

Create a new HTTP / HTTPS monitor
URL:
```
https://crm.yourdomain.com/healthcheck
```
Check interval: 1 minute
Expected status code: 200
(Optional) Response body contains: "healthy":true or "status":"ok"
Save the monitor

This is Corteza's primary health endpoint. The Go server returns HTTP 200 with a JSON payload listing the health of each internal component when everything is healthy, and returns a non-200 status when any critical component fails. Make this your primary uptime alert.

Step 3: Monitor the Corteza API gateway

The Corteza API server exposes all its functionality through an API gateway. Monitoring the /api/system/ endpoint confirms the API layer is operational and routing requests correctly.

Create a new HTTP / HTTPS monitor
URL:
```
https://crm.yourdomain.com/api/system/
```
Check interval: 2 minutes
Expected status code: 200
Save the monitor

The Corteza API system endpoint returns JSON metadata about the system API. An unauthenticated GET request returns API documentation or a 200 with a version payload — confirming that the Go server is accepting connections, the API router is functional, and the system module is initialised.

Step 4: Monitor the message queue sink endpoint

Corteza's message queue drives its integration layer — the /api/system/sink/ endpoint handles inbound webhook payloads and integration events. Monitoring this endpoint independently catches message queue failures that might not affect the primary health check.

Create a new HTTP / HTTPS monitor

URL:

https://crm.yourdomain.com/api/system/sink/

Method: GET
Check interval: 5 minutes
Expected status code: 200 or 400 (a 400 for a missing signature parameter confirms the endpoint is reachable)
Save the monitor

A GET request to the sink endpoint without required signature parameters returns a 400 Bad Request — which is expected and confirms the endpoint is reachable and the message queue handler is running. Set the expected status code to 400 for this monitor, or use body content matching.

Step 5: Monitor SSL certificate expiry

An expired TLS certificate locks out every user and API integration with no in-application warning.

Create a new SSL Certificate monitor in Vigilmon
Domain: crm.yourdomain.com
Alert thresholds:
- Warning: 30 days before expiry
- Critical: 7 days before expiry
Save the monitor

Step 6: Monitor workflow automation engine health with a heartbeat

Corteza Workflow processes automated business rules through an event-driven engine. Workflows handle CRM automation, data transformations, notifications, and integrations with external services. If the workflow engine stops processing events — due to a Go panic, resource exhaustion, or a bad deployment — business automation silently stops.

The /healthcheck endpoint includes workflow engine status. Use it as the basis for a heartbeat-style verification:

Option A: Use the /healthcheck endpoint as the workflow health probe

Add a dedicated slow-interval monitor for /healthcheck with strict body matching:

Create a new HTTP / HTTPS monitor
URL:
```
https://crm.yourdomain.com/healthcheck
```
Check interval: 2 minutes
Expected status code: 200
Response body contains: "healthy":true
Save the monitor with name Corteza Workflow Engine Health

Option B: Configure a scheduled heartbeat from within Corteza Workflow

Use Corteza Workflow to send a periodic heartbeat ping from inside the workflow engine itself — this verifies that the engine is not just reachable but actively processing scheduled triggers:

In Vigilmon, create a Heartbeat / Cron Job monitor named Corteza Workflow Engine
Set the expected interval to 10 minutes

Copy the heartbeat URL:

https://vigilmon.online/heartbeat/YOUR_TOKEN

In Corteza Workflow, create a new workflow:
- Trigger: Schedule → every 10 minutes
- Step: HTTP Request → method GET, URL: https://vigilmon.online/heartbeat/YOUR_TOKEN
Save and activate the workflow

If the workflow engine stops processing scheduled triggers, Vigilmon misses the heartbeat and alerts you — even if the /healthcheck HTTP endpoint still returns 200.

Step 7: Configure alert channels

In Vigilmon, go to Alert Channels → Add Channel
Add your preferred notification channels:
- Slack — route critical alerts to #engineering or #ops-alerts
- Email — notify the platform administrator
- Webhook — forward to PagerDuty, OpsGenie, or a custom endpoint for on-call escalation

Recommended alert tiers:

| Tier | Trigger | Channel | |------|---------|---------| | Immediate | /healthcheck fails (any component down) | Slack + email + pager | | Immediate | /api/system/ unavailable | Slack + email | | Warning | Workflow engine heartbeat missed | Slack + email | | Warning | Message queue sink unreachable | Slack | | Maintenance | SSL expiry within 30 days | Email |

Step 8: Docker Compose deployment with health checks

Corteza's recommended deployment is via Docker Compose. Add container-level health checks:

version: "3.9"

services:
  server:
    image: cortezaproject/corteza:latest
    ports:
      - "80:80"
      - "443:443"
    environment:
      DB_DSN: postgres://corteza:${DB_PASSWORD}@db:5432/corteza?sslmode=disable
      AUTH_JWT_SECRET: ${JWT_SECRET}
      DOMAIN: crm.yourdomain.com
    depends_on:
      db:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost/healthcheck"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s
    restart: unless-stopped

  db:
    image: postgres:15-alpine
    environment:
      POSTGRES_USER: corteza
      POSTGRES_PASSWORD: ${DB_PASSWORD}
      POSTGRES_DB: corteza
    volumes:
      - corteza_db:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U corteza"]
      interval: 10s
      timeout: 5s
      retries: 5
    restart: unless-stopped

volumes:
  corteza_db:

The healthcheck on the server container uses the built-in /healthcheck endpoint — the same one Vigilmon monitors — so Docker and Vigilmon agree on what "healthy" means.

Complete monitor setup summary

| Monitor | Type | Target | Interval | Catches | |---------|------|--------|----------|---------| | Web UI | HTTP | / | 1 min | Reverse proxy / SPA failure | | System health | HTTP | /healthcheck | 1 min | API server, DB, component failures | | API gateway | HTTP | /api/system/ | 2 min | API routing failure | | Workflow engine health | HTTP | /healthcheck + body check | 2 min | Workflow engine stoppage | | Message queue sink | HTTP | /api/system/sink/ | 5 min | Message queue failure | | Workflow heartbeat | Heartbeat | Corteza Workflow → Vigilmon ping | 10 min | Workflow scheduler stoppage | | SSL certificate | SSL | crm.yourdomain.com | Daily | Certificate expiry |

Conclusion

Corteza's Go backend delivers high performance and a rich API surface for enterprise low-code applications — but self-hosting it means you own its uptime. A database connection loss, a workflow engine panic, or a message queue stall can silently break your CRM automations and integrations for hours.

With Vigilmon monitoring Corteza's health endpoint, API gateway, and workflow engine, you get 60-second detection of every outage. The workflow heartbeat check goes one step further — verifying that scheduled automation is actually processing, not just that the server is accepting connections.

Start monitoring for free at vigilmon.online.