Monitoring Nocobase with Vigilmon: Platform Uptime, API Health, Plugin Endpoint Checks & SSL Certificate Monitoring

Nocobase is an open-source no-code and low-code platform that teams self-host to build internal tools, data management applications, and workflows without writing frontend code. Because Nocobase is self-hosted, the entire infrastructure responsibility falls on you: the application server, the database, the plugin runtime, and the API layer. When Nocobase goes down, the internal tools that run on it — CRM interfaces, inventory management, project trackers — become unavailable for every team that depends on them. Vigilmon gives you an external, independent monitoring layer for your Nocobase installation: web interface uptime, API health, admin console availability, SSL certificate expiry, and the application health endpoint.

What You'll Build

A monitor on the Nocobase web frontend to catch application and web server failures
An API health check confirming the Nocobase REST API is responding
An admin interface monitor catching auth layer issues before users hit them
SSL certificate monitoring for your Nocobase domain
Alerting configured for internal tooling infrastructure

Prerequisites

Nocobase installed and accessible via HTTPS (version 0.x or 1.x)
A domain with a valid TLS certificate configured
A free account at vigilmon.online

Step 1: Monitor the Nocobase Web Frontend

Nocobase serves its frontend as a React single-page application through a Node.js server (or nginx reverse proxy). A crash in the Node.js process, a failed deployment, or a database connectivity issue can take down the frontend. Monitor the root URL directly:

curl -I https://your-nocobase.example.com/

A healthy Nocobase instance returns 200 with the application shell HTML. Add the monitor:

Log in to Vigilmon → Add Monitor → HTTP.
URL: https://your-nocobase.example.com/.
Check interval: 60 seconds.
Expected status: 200.
Keyword: nocobase or NocoBase (present in the HTML of the application shell).
Label: Nocobase Web Frontend.
Click Save.

Reverse proxy deployments: If Nocobase is behind nginx or Caddy, a crash of the Nocobase Node.js process returns 502 Bad Gateway from the proxy. A 200 from this monitor confirms both the reverse proxy and the Node.js application are running.

Step 2: Monitor the Nocobase API

Nocobase exposes a REST API at /api/ that the frontend, plugins, and any external integrations use to read and write data. The API is backed by the database — if the database becomes unreachable, the API returns errors even when the frontend HTML loads from cache. Add a monitor on a lightweight, publicly accessible API endpoint:

curl https://your-nocobase.example.com/api/app:getInfo

The app:getInfo endpoint returns application metadata and requires no authentication. A healthy response returns 200 with JSON:

{"data": {"version": "1.0.0", "lang": "en-US"}}

Add the monitor:

Add Monitor → HTTP.
URL: https://your-nocobase.example.com/api/app:getInfo.
Check interval: 60 seconds.
Expected status: 200.
Keyword: version (present in all healthy API responses).
Label: Nocobase API - App Info.
Click Save.

Why this endpoint matters: The frontend HTML can be served by the proxy from a static file cache even when the Node.js application is crash-looping. The app:getInfo endpoint requires the full Node.js application stack to be running. A frontend monitor that stays green while this monitor fires means the Node.js process is cycling.

Step 3: Monitor the Admin Interface

Nocobase's admin console at /admin is where your team configures collections, builds interfaces, and manages permissions. An issue with the auth middleware or routing configuration can break the admin console while the user-facing frontend stays healthy. Monitor the admin login page:

curl -I https://your-nocobase.example.com/admin/signin

A healthy Nocobase admin interface returns 200 with the sign-in page. Add the monitor:

Add Monitor → HTTP.
URL: https://your-nocobase.example.com/admin/signin.
Check interval: 5 minutes.
Expected status: 200.
Keyword: Sign in or NocoBase (a term present in the admin sign-in page).
Label: Nocobase Admin Console.
Click Save.

Step 4: Add an Authenticated API Health Check

The unauthenticated app:getInfo check confirms the API is running but does not verify that authentication and database queries are working end-to-end. Create a dedicated monitoring user and add an authenticated probe:

First, create a read-only monitoring user in Nocobase:

In the Nocobase admin console, go to Settings → Users & Permissions → Users.
Create a user: vigilmon-monitor@your-domain.com, role: member (minimum permissions).
Set a strong password.

Then test authentication from the command line:

curl -X POST https://your-nocobase.example.com/api/auth:signIn \
  -H "Content-Type: application/json" \
  -d '{"email": "vigilmon-monitor@your-domain.com", "password": "your-password"}'

A successful response returns a token in data.token. Add the monitor:

Add Monitor → HTTP.
URL: https://your-nocobase.example.com/api/auth:signIn.
Method: POST.

Request body:

{"email": "vigilmon-monitor@your-domain.com", "password": "your-password"}

Request headers: Content-Type: application/json.
Check interval: 5 minutes.
Expected status: 200.
Keyword: token (present in a successful auth response; absent on database errors).
Label: Nocobase API - Auth Check.
Click Save.

What this catches: If PostgreSQL or MySQL becomes unreachable, app:getInfo may still return cached data while the auth endpoint fails with a database error. This is Nocobase's most common production failure mode.

Step 5: Monitor SSL Certificates

Nocobase hosts internal tools that your team relies on daily. An expired TLS certificate on your Nocobase domain locks out every user — they see a browser certificate warning and cannot access their tools until the certificate is renewed. Internal tooling teams often do not notice certificate expiry until it happens.

Add SSL monitoring:

Add Monitor → SSL Certificate.
Domain: your-nocobase.example.com.
Alert when expiry is within: 30 days.
Alert again: 14 days, 7 days, 3 days, 1 day.
Click Save.

If Nocobase is accessed on a bare domain and also a www. subdomain, add separate SSL monitors for both. Certificate coverage should match every URL that users actually access.

Step 6: Configure Alerting

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

| Monitor | Trigger | Action | |---|---|---| | Nocobase Web Frontend | Non-200 or keyword missing | Node.js crash or reverse proxy issue; check process status and nginx logs | | Nocobase API - App Info | Non-200 or version missing | Node.js application layer broken; restart service; check application logs | | Nocobase Admin Console | Non-200 or keyword missing | Routing or auth middleware issue; check Node.js logs for middleware errors | | Nocobase API - Auth Check | Non-200 or token missing | Database unreachable or auth service broken; check database connectivity | | SSL Certificate | < 30 days to expiry | Renew certificate; alert at 30 days to handle internal approval processes |

Alert sensitivity: Nocobase hosts internal tooling that teams use during business hours. Alert immediately (1 consecutive failure) during working hours. If your team is small, route alerts to a group channel rather than paging individuals for internal tool availability.

Database alerts: The Auth Check monitor is your proxy for database health. When it fires, check your database server (PostgreSQL or MySQL) before investigating the Nocobase application layer.

Common Nocobase Failure Modes and What Vigilmon Catches

| Scenario | Vigilmon monitor | |---|---| | Node.js process crash (OOM, uncaught exception) | Web Frontend fires (502 from proxy); API monitors follow | | Database server unreachable | Auth Check fires; App Info may stay green (cached response) | | Failed Nocobase upgrade breaks startup | Web Frontend fires with 502; all API monitors fire | | Plugin install causes crash loop | Web Frontend and API monitors fire; admin console inaccessible | | Disk full on Nocobase host | Node.js crashes; all monitors fire simultaneously | | nginx/Caddy reverse proxy misconfiguration | Web Frontend fires with 502/504 | | SSL certificate expires | SSL monitor alerts at 30-day threshold; all monitors fire after expiry | | Database migration fails during upgrade | Auth Check fails; admin interface may return 500 | | Memory leak causes gradual performance degradation | Monitors show increasing response times before crashing | | Network partition isolating the server | All monitors fire simultaneously |

Why Monitor Nocobase with an External Tool

Self-hosted software creates full infrastructure ownership — including the monitoring responsibility. Nocobase has no SLA, no built-in availability alerting, and no external watchdog. If your Nocobase server crashes at midnight, you find out when your first colleague arrives in the morning and reports they cannot access their tools. Vigilmon is the external watchdog that Nocobase cannot provide for itself: independent of your server's health, monitoring from outside your network, alerting through separate channels the moment your Nocobase installation stops responding.

The monitoring gap for self-hosted internal tools is real and common. Nocobase specifically is often installed quickly for a specific use case and then becomes load-bearing infrastructure as teams build processes around it. External monitoring closes that gap before the first production outage.

Nocobase gives teams the power to build internal applications without engineering resources. Vigilmon ensures the platform those applications run on is available when teams need it — with external uptime monitoring, API health checks, and SSL certificate alerting that operates independently of the Nocobase installation itself.

Start monitoring your Nocobase installation in under 5 minutes — register free at vigilmon.online.