# How to Vibe Code Your Own Cronitor (and Stop Paying for It)

> Simple monitoring for any application

- Site: https://cronitor.io
- Category: Developer Tools
- Platforms: Web app
- Verdict: **Solid side project** (62/100 vibecodeable)
- Estimated effort: 3-4 weekends of focused building and debugging

## Verdict

Build a personal subset for your homelab or keep paying, because coordinating global synthetic probes and ingestion reliability requires substantial weekend engineering.

Cronitor combines several distinct subsystems—cron telemetry ingestion, HTTP uptime checking, heartbeat listeners, RUM collection, and status pages. While a solo developer can easily scaffold the Next.js dashboard, database models, and webhook dispatchers using AI coding tools, building a bulletproof background ingestion cron runner and multi-region uptime checker introduces real debugging friction around concurrency, timeouts, and false alarms. For personal use, a streamlined single-server clone handling cron pings and local uptime checks is entirely practical, but matching their production-grade global reliability is out of reach.

### What you can't replicate

- Global synthetic probing infrastructure across 12+ enterprise regions
- Massive ecosystem of battle-tested open-source language SDKs
- 12-year operational reliability track record

## What it does

An application and infrastructure monitoring platform unifying cron job monitoring, uptime checks, heartbeats, RUM analytics, and status pages.

### Core features

- Cron job execution tracking and alert dispatch (timeouts, silent failures)
- Website and API uptime checks via HTTP/HTTPS polling
- Heartbeat monitoring endpoint ingestion
- Hosted public/private status pages with uptime history
- Cookie-free Real User Monitoring (RUM) tracker script and metrics
- Webhook and notification integrations (Slack, Discord, Email)

## The business

### Pricing

- Hacker: Free
- Business: $2/mo per monitor + $5/mo per user
- Enterprise: From $6,000/yr

Founded 2014.
Team size: Small independent team.

## The hard parts

- Global distributed synthetic uptime probing from multiple regions to avoid false positives
- High-throughput telemetry ingestion pipeline that must never drop background task pings
- Time-series data storage and retention aggregation across months of metrics
- Asynchronous non-blocking client-side RUM script capturing web vitals without cookies

## How to vibe code Cronitor

### Prerequisites

- Node.js (free): Runtime environment for Next.js development
- GitHub (free): Source control and CI/CD deployment connection
- Cloudflare Account (free): Hosting the Next.js application and serverless worker endpoints

### Recommended AI tools

- Claude Code: Terminal-based agentic coding tool capable of building multi-file Next.js features and debugging API routes end-to-end.
- Cursor: AI code editor ideal for iterative UI polish on the monitoring dashboard and status pages.

### Stack

- Frontend: Next.js (App Router, Tailwind CSS, shadcn/ui)
- Backend: Next.js API Routes / Cloudflare Workers
- Database: Turso (SQLite at the edge for relational configurations and event logs)
- Auth: better-auth
- Payments: None (Personal clone)
- Other: Resend (Email alerts), Sentry (Error tracking)

### Hosting

- Cloudflare (Hosting Next.js app, serverless API endpoints, and telemetry ingestion worker): $0/mo
- Turso (Serverless SQLite database for monitor configs and execution logs): $0/mo

### Build guide

1. **Project Scaffolding & Database Schema** — Initialize the Next.js 16 project with Tailwind CSS, TypeScript, and set up the Turso database client with Drizzle ORM.

```
Create a new Next.js 16 application using App Router, TypeScript, and Tailwind CSS. Initialize Drizzle ORM configured for Turso (SQLite). Create database schemas for: 1) 'monitors' (id, user_id, name, type [cron, uptime, heartbeat], schedule_expression, timeout_seconds, status [pending, ok, failing], last_ping_at, created_at), 2) 'monitor_pings' (id, monitor_id, status, duration_ms, output, timestamp), and 3) 'status_pages' (id, user_id, title, slug, custom_domain, published). Ensure proper foreign key constraints and indexes on monitor_id and timestamp.
```

2. **Authentication & Dashboard Layout** — Implement authentication with better-auth and build the main dashboard layout with monitor overview widgets.

```
Install and configure better-auth in the Next.js app supporting email/password authentication. Build a clean, developer-focused dashboard layout using Tailwind CSS and shadcn/ui aesthetics (dark mode primary, crisp borders, status badges). Create the main `/app/dashboard` page displaying a summary count of failing, paused, and active monitors, alongside a list view fetching monitors from Turso.
```

3. **Telemetry Ingestion API (`cronitor.link` clone)** — Build high-performance public telemetry ingestion endpoints for cron jobs, heartbeats, and check pings.

```
Create an API route at `/api/telemetry/[apiKey]/[monitorKey]` (and supporting a separate ingestion handler) that accepts incoming GET/POST requests from cron jobs and heartbeats. The endpoint must extract execution metrics (status=complete/fail, duration, message output), record a row in `monitor_pings`, update the parent monitor's `last_ping_at` and `status` fields, and return a lightweight 200 JSON response instantly. Ensure this endpoint handles unauthenticated or invalid keys gracefully without throwing server faults.
```

4. **Cron & Uptime Scheduler Worker** — Implement background worker logic to evaluate missed cron schedules and execute HTTP uptime checks.

```
Implement a background cron checking worker (using Cloudflare Cron Triggers or a scheduled API route secured by a cron secret). The worker must query monitors where type='cron' and `last_ping_at` exceeds their expected schedule threshold plus grace period, flagging them as failing and triggering alert dispatches. For monitors where type='uptime', issue parallel fetch requests to the target URL, measuring response time and verifying status codes, recording failures if assertions fail.
```

5. **Alert Dispatcher (Slack & Email)** — Build notification routing to send alerts via Resend and Webhooks when monitors fail or recover.

```
Build an alert notification service that triggers when a monitor transitions from OK to Failing or Failing to OK. Support dispatching formatted notifications to Slack via incoming webhooks and transactional alert emails using Resend. Create a settings UI in the dashboard allowing users to configure webhook URLs and notification email addresses per monitor or globally.
```

6. **Hosted Status Pages** — Build public status pages displaying real-time system health and historical uptime bars.

```
Create a public status page feature accessible at `/status/[slug]`. The page should render the status of all monitors associated with that status page, displaying an aggregate system health banner ('All Systems Operational' or 'Degraded Performance'), individual component health cards, and a 30-day uptime history bar chart. Ensure this page is publicly viewable without requiring authentication.
```

7. **RUM Tracker Script & Analytics** — Create a lightweight tracking script and ingestion endpoint for cookie-free real user monitoring.

```
Build a lightweight, cookie-free client-side JavaScript tracking snippet (compiled and served via a public static route `/rum.js`) that captures pageviews, navigation changes, Web Vitals (FCP, LCP, CLS), and JS errors, transmitting them asynchronously via beacon to `/api/rum/collect`. Build a corresponding analytics dashboard view aggregating pageviews and performance metrics over time while ensuring visitor IP addresses are never stored in the database.
```

### Cost vs paying

**Starting costs (one-time):**

- AI Coding Assistant Subscription: $20
- Total: $20 one-time

**Ongoing costs (monthly):**

- Cloudflare & Turso Hobby Tiers: $0/mo
- Total: $0/mo

- Paying for the SaaS instead: ~$30/mo (Business plan with monitors)
- Build time: 25-35 hours
- AI tool credits: $20 (1 month Claude Pro)
- Break-even: Free forever (self-hosted)

## Sources

- [Cronitor Home Page](https://cronitor.io)
- [Cronitor Pricing Page](https://cronitor.io/pricing)
- [Cronitor Developer Documentation](https://cronitor.io/docs)
- [Cronitor API Documentation](https://cronitor.io/docs/api)
- [Cronitor RUM FAQ](https://cronitor.io/docs/rum-faq)
- [Cronitor Security Policy](https://cronitor.io/docs/security)