Checkly: Monitoring as Code for DevOps and SRE

Checkly is a monitoring as code platform that unifies testing, monitoring and observability in an AI-native workflow. Detect. Communicate. Resolve.

The 3 Pillars of Checkly

What is Monitoring as Code?

Monitoring as Code means managing your monitoring checks, alerts, and dashboards through code—stored in Git, reviewed through PRs, and deployed via CI/CD. It brings the same benefits to monitoring that Infrastructure as Code brings to infrastructure:

• Version control: Full history of monitoring changes
• Code review: Team reviews monitoring logic before production
• Reproducibility: Same checks across environments
• Collaboration: Developers and SREs work together
• Automation: Deploy monitoring with your application

Key Features

1. Synthetic Monitoring with Playwright

Checkly natively supports Playwright for end-to-end testing in production. Write tests once, run them continuously:

import { test } from '@playwright/test';

test('user can login', async ({ page }) => {
  await page.goto('https://app.example.com/login');
  await page.fill('input[name="email"]', 'user@example.com');
  await page.fill('input[name="password"]', 'password123');
  await page.click('button[type="submit"]');
  await page.waitForURL('**/dashboard');
  // Check logged in successfully
});

2. API Monitoring

Monitor REST APIs, GraphQL endpoints, and webhooks:

• HTTP checks: GET, POST, PUT, DELETE with assertions
• Response validation: Status codes, headers, JSON body
• Performance monitoring: Response time tracking
• Multi-step scenarios: Chain API calls with variable passing

import { ApiCheck } from '@checkly/cli/constructs';

new ApiCheck('api-users-list', {
  name: 'GET /api/users',
  request: {
    url: 'https://api.example.com/users',
    method: 'GET',
    headers: {
      'Authorization': 'Bearer {{API_TOKEN}}'
    }
  },
    assertions: [
    {
      source: 'STATUS_CODE',
      comparison: 'EQUALS',
      target: 200
    },
    {
      source: 'JSON_BODY',
      property: '$.data.length',
      comparison: 'GREATER_THAN',
      target: 0
    }
  ],
  locations: ['us-east-1', 'eu-west-1']
});

3. TypeScript/JavaScript CLI

Define checks as code using TypeScript or JavaScript:

// checkly.config.ts
import { defineConfig } from '@checkly/cli';

export default defineConfig({
  projectName: 'My App',
  logicalId: 'my-app',
  checks: {
    frequency: 5, // minutes
    locations: ['us-east-1', 'eu-west-1'],
    tags: ['production'],
    alertChannels: ['email', 'slack']
  }
});

4. CI/CD Integrations

Seamless integration with your CI/CD pipeline:

• GitHub Actions: Official Checkly action for automated checks
• GitLab CI: Deploy checks alongside application code
• Vercel: Automatic monitoring for every deployment
• Jenkins: Plugin for traditional CI/CD workflows

name: Deploy Monitoring
on: [push]

jobs:
  deploy-checks:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: checkly/checkly-cli-action@v1
        with:
          checkly-api-key: ${{ secrets.CHECKLY_API_KEY }}
          checkly-account-id: ${{ secrets.CHECKLY_ACCOUNT_ID }}
          command: deploy

5. Infrastructure as Code Support

• Terraform provider: Manage checks with HashiCorp Terraform
• Pulumi provider: Use Pulumi for cross-cloud monitoring
• Import/Export: Migrate existing checks to code

Alerting and Communication

Alert Channels

Get notified where your team works:

• Slack: Channel notifications with detailed context
• PagerDuty: Incident management integration
• Opsgenie: On-call escalation
• Email: Team or individual notifications
• Webhooks: Custom integrations
• SMS: Critical alerts for high-priority checks

Public Status Pages

Included with every Checkly account (no extra cost like other tools):

• Custom domain: status.yourdomain.com
• Branding: Logo, colors, custom CSS
• Incident communication: Update users during outages
• Subscriber notifications: Email/SMS subscriptions
• Historical uptime: 90-day uptime percentage

OpenTelemetry Tracing

Checkly supports OpenTelemetry for distributed tracing, connecting monitoring to your application traces:

• Root cause analysis: See which service caused the failure
• End-to-end visibility: From user action to database query
• Standard format: Works with existing OTel infrastructure
• Performance bottlenecks: Identify slow services in the chain

Advantages vs Alternatives

Cost Savings

Use Cases

1. E-commerce Critical Path Monitoring

• Monitor product search, add to cart, checkout flow
• Multi-region testing for global availability
• Performance budgets (e.g., checkout must complete in <3s)

2. SaaS Application Monitoring

• Login flows across SSO providers
• API endpoints used by customers
• Background jobs and webhooks

3. Mobile Backend Monitoring

• REST/GraphQL APIs powering mobile apps
• Push notification delivery
• Authentication endpoints

4. Financial Services Compliance

• Regulatory uptime requirements (99.9%+)
• Transaction processing monitoring
• Audit trails for compliance reporting

Getting Started

1. Sign Up and Install CLI

# Install Checkly CLI globally
npm install -g @checkly/cli

# Login to your account
npx checkly login

# Initialize a new project
npx checkly init

2. Create Your First Check

// __checks__/homepage.check.ts
import { ApiCheck } from '@checkly/cli/constructs';

new ApiCheck('homepage-check', {
  name: 'Homepage is up',
  request: {
    url: 'https://yourdomain.com',
    method: 'GET'
  },
  assertions: [
    {
      source: 'STATUS_CODE',
      comparison: 'EQUALS',
      target: 200
    }
  ]
});

3. Deploy to Checkly

# Test locally first
npx checkly test

# Deploy to production
npx checkly deploy

Additional Resources

• Checkly Official Website
• Checkly Documentation
• DevOps Expertise: our DevOps services
• All our publications: tech guides and news

Article published on 2025-12-06. Complete guide to Checkly monitoring as code platform for DevOps and SRE teams.