diff --git a/guides/monitoring-ecommerce-apps-using-playwright.mdx b/guides/monitoring-ecommerce-apps-using-playwright.mdx
index 372902f8b..45ef782ba 100644
--- a/guides/monitoring-ecommerce-apps-using-playwright.mdx
+++ b/guides/monitoring-ecommerce-apps-using-playwright.mdx
@@ -1,6 +1,6 @@
---
title: Monitor a checkout flow
-sidebarTitle: Monitoring a Checkout Flow
+sidebarTitle: Monitoring a checkout flow
description: Cover browse, search, add to cart, and checkout on a shop with a Playwright Check Suite that asserts the order confirmation, uses safe test data, and runs against a per-environment base URL.
canonical: 'https://www.checklyhq.com/docs/guides/monitoring-ecommerce-apps-using-playwright/'
---
diff --git a/guides/monitoring-ecommerce-apps-using-terraform.mdx b/guides/monitoring-ecommerce-apps-using-terraform.mdx
index 7fc4d567a..38991d72a 100644
--- a/guides/monitoring-ecommerce-apps-using-terraform.mdx
+++ b/guides/monitoring-ecommerce-apps-using-terraform.mdx
@@ -1,6 +1,6 @@
---
title: Monitor a shop with Terraform
-sidebarTitle: Monitoring a Shop with Terraform
+sidebarTitle: Monitoring a shop with Terraform
description: Declare a shop's whole monitoring stack in Terraform with the Checkly provider, from the alert channel and check group to Browser checks loaded from spec files and an API check with body assertions.
canonical: 'https://www.checklyhq.com/docs/guides/monitoring-ecommerce-apps-using-terraform/'
---
diff --git a/guides/monitoring-the-stripe-api.mdx b/guides/monitoring-the-stripe-api.mdx
index a6eee26ae..c17a29c80 100644
--- a/guides/monitoring-the-stripe-api.mdx
+++ b/guides/monitoring-the-stripe-api.mdx
@@ -1,5 +1,5 @@
---
-title: How to monitor the Stripe customer API with Checkly | API Monitoring Examples
+title: How to monitor the Stripe customer API with Checkly | API monitoring examples
displayTitle: How to monitor the Stripe customer API with Checkly
sidebarTitle: Monitoring a Stripe API
description: Application Programming Interfaces (APIs) are used throughout software to define interactions between different software applications. In this article we focus on web APIs specifically, taking a look at how they fit in the Jamstack architecture and how we can set up API monitoring in order to make sure they don't break and respond fast.
@@ -364,7 +364,7 @@ As we increase our monitoring coverage across our APIs, we can also increase the
2. [Defining our API checks as code](/guides/structuring-a-checkly-project) to scale our setup while lowering maintenance needs.
3. Combining our API checks with [E2E monitoring](/learn/monitoring/end-to-end-monitoring/) for any website or web app service whose API we might be monitoring.
-## Read More
+## Read more
@@ -375,7 +375,7 @@ As we increase our monitoring coverage across our APIs, we can also increase the
Learn end-to-end monitoring with Playwright to test key website flows.
-
+
OpenAPI and Swagger help users design and document APIs in a way that is readable from both humans and machines.
diff --git a/guides/playwright-testing-to-monitoring.mdx b/guides/playwright-testing-to-monitoring.mdx
index d0f89d478..2a6245f63 100644
--- a/guides/playwright-testing-to-monitoring.mdx
+++ b/guides/playwright-testing-to-monitoring.mdx
@@ -1,6 +1,6 @@
---
title: Turn your Playwright tests into monitors
-sidebarTitle: Turning Tests into Monitors
+sidebarTitle: Turning tests into monitors
description: Run the Playwright tests you already have as scheduled production monitors with a Playwright Check Suite, without rewriting them.
canonical: 'https://www.checklyhq.com/docs/guides/playwright-testing-to-monitoring/'
---
diff --git a/guides/reading-traces.mdx b/guides/reading-traces.mdx
index 8d9fc0070..856be29dc 100644
--- a/guides/reading-traces.mdx
+++ b/guides/reading-traces.mdx
@@ -1,6 +1,6 @@
---
title: Debug a failed check
-sidebarTitle: Debug a Failed Check
+sidebarTitle: Debug a failed check
description: Go from a failing Playwright check to its root cause with the Checkly CLI, the Playwright trace in your terminal, and Rocky AI, then confirm the fix with a test run before you deploy.
canonical: 'https://www.checklyhq.com/docs/guides/reading-traces/'
---
diff --git a/guides/sdlc-monitoring.mdx b/guides/sdlc-monitoring.mdx
index b0ea28656..46fe1c75c 100644
--- a/guides/sdlc-monitoring.mdx
+++ b/guides/sdlc-monitoring.mdx
@@ -1,6 +1,6 @@
---
title: Run checks on every deploy
-sidebarTitle: Monitoring Every Release
+sidebarTitle: Monitoring every release
description: Test pull request previews before merging, trigger deployed checks after production deployments, and record the commit, branch, and environment.
canonical: 'https://www.checklyhq.com/docs/guides/sdlc-monitoring/'
---
diff --git a/guides/setup-scripts-for-apis.mdx b/guides/setup-scripts-for-apis.mdx
index ea828da19..b0baf5d10 100644
--- a/guides/setup-scripts-for-apis.mdx
+++ b/guides/setup-scripts-for-apis.mdx
@@ -1,8 +1,8 @@
---
-title: How to Use Setup and Teardown Scripts for Better API Monitoring
+title: How to use setup and teardown scripts for better API monitoring
description: Setup and teardown scripts are fundamental tools to tailor API checks to your target endpoints. This guide presents real-world examples to help you master these tools.
tags: API Monitoring
-sidebarTitle: Setup and Teardown Scripts
+sidebarTitle: Setup and teardown scripts
canonical: 'https://www.checklyhq.com/docs/guides/setup-scripts-for-apis/'
---
@@ -240,7 +240,7 @@ if (response.statusCode >= 200 && response.statusCode < 300) {
## Read more
-
+
Full reference for setup and teardown scripts, including built-in variables and technical details.
diff --git a/guides/structuring-a-checkly-project.mdx b/guides/structuring-a-checkly-project.mdx
index 736f968ba..b5f79be69 100644
--- a/guides/structuring-a-checkly-project.mdx
+++ b/guides/structuring-a-checkly-project.mdx
@@ -1,6 +1,6 @@
---
title: Structure a Checkly project for a real codebase
-sidebarTitle: Structuring a Project
+sidebarTitle: Structuring a project
description: Organize checks by service with groups, keep shared settings in one config, and deploy monitoring from CI on every merge to main.
canonical: 'https://www.checklyhq.com/docs/guides/structuring-a-checkly-project/'
---
diff --git a/guides/uptime-monitoring.mdx b/guides/uptime-monitoring.mdx
index 3afaab2a0..73a3aeeb4 100644
--- a/guides/uptime-monitoring.mdx
+++ b/guides/uptime-monitoring.mdx
@@ -1,6 +1,6 @@
---
title: Cover every endpoint with uptime monitors
-sidebarTitle: Growing Monitoring Coverage
+sidebarTitle: Growing monitoring coverage
description: Turn a list of public pages into URL monitors, tell slow from down, and watch the certificate every one of them depends on, all from a few lines of code.
canonical: 'https://www.checklyhq.com/docs/guides/uptime-monitoring/'
---
diff --git a/index.mdx b/index.mdx
index 1067e00b9..01ad87633 100644
--- a/index.mdx
+++ b/index.mdx
@@ -1,5 +1,5 @@
---
-title: 'Checkly Documentation'
+title: 'Checkly documentation'
sidebarTitle: 'Home'
description: 'The active monitoring layer for engineers and agents. Detect, communicate, and resolve failures with checks defined as code.'
mode: "frame"
@@ -11,7 +11,7 @@ import { CopyPromptButton } from '/snippets/copy-prompt-button.jsx';
> **For AI agents:** Start with [llms.txt](https://www.checklyhq.com/docs/llms.txt) for the full documentation index. Append `.md` to any docs URL to get its Markdown. To set Checkly up in a project, follow the [Quickstart](https://www.checklyhq.com/docs/quickstart.md).
-# Checkly Documentation
+# Checkly documentation
Checkly is the active monitoring layer for engineers & agents. Detect downtime with Playwright-powered monitors defined in TypeScript running from global or internal locations. Communicate outages with custom alerts and status pages. Resolve errors with traces and AI root cause analysis for new failures.
diff --git a/integrations/alerts/discord.mdx b/integrations/alerts/discord.mdx
index 318ac25a8..96981deac 100644
--- a/integrations/alerts/discord.mdx
+++ b/integrations/alerts/discord.mdx
@@ -1,5 +1,5 @@
---
-title: 'Send Alerts to Discord'
+title: 'Send alerts to Discord'
description: 'Configure Discord integration to receive real-time alerts from Checkly monitors'
sidebarTitle: 'Discord'
canonical: 'https://www.checklyhq.com/docs/integrations/alerts/discord/'
@@ -34,9 +34,9 @@ deliver failure, degradation, and recovery messages to any project in your Disco
Congratulations! You have successfully integrated Checkly with Discord!
-## Advanced Discord Configuration
+## Advanced Discord configuration
-### Custom Discord Alerts
+### Custom Discord alerts
For more control over Discord alert formatting, you can create custom webhook payloads using Discord's embed format:
@@ -74,7 +74,7 @@ For more control over Discord alert formatting, you can create custom webhook pa
}
```
-### Discord Alert Colors
+### Discord alert colors
Use different colors to distinguish alert types:
@@ -82,7 +82,7 @@ Use different colors to distinguish alert types:
- **Orange (16776960)**: Degraded performance alerts
- **Green (3066993)**: Recovery notifications
-### Discord Best Practices
+### Discord best practices
- Use separate channels for different environments (production, staging, development)
- Configure appropriate notification settings to avoid alert fatigue
diff --git a/integrations/alerts/email.mdx b/integrations/alerts/email.mdx
index 959090f10..daeb29064 100644
--- a/integrations/alerts/email.mdx
+++ b/integrations/alerts/email.mdx
@@ -1,5 +1,5 @@
---
-title: 'Email Notifications'
+title: 'Email notifications'
description: 'Configure email alerts for individuals or distribution lists'
sidebarTitle: 'Email'
canonical: 'https://www.checklyhq.com/docs/integrations/alerts/email/'
@@ -24,7 +24,7 @@ Email notifications provide a reliable and widely-supported way to receive alert
/>
-## Basic Email Configuration
+## Basic email configuration
To receive alerts, you'll need to add one or more valid email addresses, choose what states you want to receive alerts for, and then also add subscriptions to checks.
diff --git a/integrations/alerts/gitlab_alerts.mdx b/integrations/alerts/gitlab_alerts.mdx
index c9a3a2c2d..7d85e10b3 100644
--- a/integrations/alerts/gitlab_alerts.mdx
+++ b/integrations/alerts/gitlab_alerts.mdx
@@ -1,7 +1,7 @@
---
-title: "Integrating GitLab Alerts"
+title: "Integrating GitLab alerts"
description: "Configure GitLab Alerts integration to receive failure, degradation, and recovery messages from Checkly"
-sidebarTitle: "GitLab Alerts"
+sidebarTitle: "GitLab alerts"
canonical: 'https://www.checklyhq.com/docs/integrations/alerts/gitlab_alerts/'
---
diff --git a/integrations/alerts/msteams.mdx b/integrations/alerts/msteams.mdx
index fc90f94b6..c0fdb0b90 100644
--- a/integrations/alerts/msteams.mdx
+++ b/integrations/alerts/msteams.mdx
@@ -1,5 +1,5 @@
---
-title: 'Send Alerts to Microsoft Teams'
+title: 'Send alerts to Microsoft Teams'
description: 'Configure Microsoft Teams integration to receive failure, degradation, and recovery messages from Checkly'
sidebarTitle: 'Microsoft Teams'
canonical: 'https://www.checklyhq.com/docs/integrations/alerts/msteams/'
diff --git a/integrations/alerts/phone-calls.mdx b/integrations/alerts/phone-calls.mdx
index 56852e452..bb339b90c 100644
--- a/integrations/alerts/phone-calls.mdx
+++ b/integrations/alerts/phone-calls.mdx
@@ -1,7 +1,7 @@
---
-title: 'Phone Calls'
+title: 'Phone calls'
description: 'Configure phone call notifications for critical alerts and emergency escalation'
-sidebarTitle: 'Phone Calls'
+sidebarTitle: 'Phone calls'
canonical: 'https://www.checklyhq.com/docs/integrations/alerts/phone-calls/'
---
diff --git a/integrations/alerts/slack.mdx b/integrations/alerts/slack.mdx
index f6f514c06..dab91a9fb 100644
--- a/integrations/alerts/slack.mdx
+++ b/integrations/alerts/slack.mdx
@@ -24,7 +24,7 @@ To send alerts to a second Slack workspace, or to a workspace whose admins don't
If you're using a free Slack workspace, be aware of [message limits](https://slack.com/help/articles/115002422943-Usage-limits-for-free-workspaces). Exceeding these limits may prevent new alerts from being delivered.
-## Example Failed Slack Alert
+## Example failed Slack alert
For each check and / or monitor, the Slack alert message contains key information, a possible root cause analysis and key actions like rerunning the check.
@@ -34,7 +34,7 @@ For each check and / or monitor, the Slack alert message contains key informatio
The root cause analysis uses AI to analyze your logs, traces, test source code, error information and other artefacts available to Checkly. Be aware that AI can make mistakes so outputs should be verified independently.
-## Example Recovered Slack Alert
+## Example recovered Slack alert
From the recovered Slack message, you can see the timestamp as well as a link to the check itself.
@@ -108,6 +108,6 @@ If the test message arrives but alerts don't, check that:
The [alert notification log](/communicate/alerts/notification-log) shows the Slack deliveries that failed.
-## Privacy Policy
+## Privacy policy
For information about how Checkly collects, uses, and protects your data, see our [Privacy Policy](https://checklyhq.com/privacy).
\ No newline at end of file
diff --git a/integrations/alerts/sms.mdx b/integrations/alerts/sms.mdx
index 5994113ee..d9b918fed 100644
--- a/integrations/alerts/sms.mdx
+++ b/integrations/alerts/sms.mdx
@@ -1,5 +1,5 @@
---
-title: 'SMS Alerts'
+title: 'SMS alerts'
description: 'Configure SMS text message notifications for critical alerts and emergency escalation'
sidebarTitle: 'SMS'
canonical: 'https://www.checklyhq.com/docs/integrations/alerts/sms/'
diff --git a/integrations/alerts/telegram.mdx b/integrations/alerts/telegram.mdx
index 65f1e6cbc..bc6a9dd1e 100644
--- a/integrations/alerts/telegram.mdx
+++ b/integrations/alerts/telegram.mdx
@@ -1,5 +1,5 @@
---
-title: 'Send Alerts via Telegram'
+title: 'Send alerts via Telegram'
description: 'Learn how to send Checkly alerts to Telegram direct chats, groups, and forum topics'
sidebarTitle: 'Telegram'
canonical: 'https://www.checklyhq.com/docs/integrations/alerts/telegram/'
@@ -16,7 +16,7 @@ deliver failure, degradation, and recovery messages to direct chats, groups, and
-## Telegram Bot
+## Telegram bot
1. Create a **Telegram Bot** using the [@BotFather](https://t.me/botfather). Detailed instructions can be found [here](https://core.telegram.org/bots), however you can simply message the Telegram user `@BotFather` and send them the command message `/newbot`. Then follow the instructions the bot replies with.
@@ -32,13 +32,13 @@ deliver failure, degradation, and recovery messages to direct chats, groups, and
For direct messages, you can retrieve your user Chat ID with an ID bot. For groups and forum topics, query the Telegram API to retrieve the target group's Chat ID and optional Message Thread ID.
-#### ID Bot
+#### ID bot
You can retrieve your own Telegram Chat ID by starting a chat with another bot. This Telegram bot user can be found at `@get_id_bot`.
1. Send the `@get_id_bot` bot the `/my_id` command. Copy the ID from its reply.
-#### API Query
+#### API query
Use the bot API to retrieve a Chat ID for any target chat. For a forum group, the same response includes the Message Thread ID, which Telegram also calls the topic ID.
@@ -71,7 +71,7 @@ Use the bot API to retrieve a Chat ID for any target chat. For a forum group, th
The `getUpdates` method does not work while your bot has an outgoing webhook configured. In that case, retrieve these fields from the update sent to your webhook.
-## Checkly Integration
+## Checkly integration
With the **HTTP API Token**, **Chat ID**, and optional **Message Thread ID** in hand, you can create a Telegram alert channel in Checkly.
@@ -94,16 +94,16 @@ Congratulations! You have successfully integrated Checkly with Telegram!
Telegram also accepts messages via an HTTP `GET` request. Therefore, you can use the API Token and Chat ID to create a custom Telegram alert channel with a [webhook alert channel](/integrations/alerts/webhooks). The webhook should use the `GET` method and target `https://api.telegram.org/bot/sendMessage?chat_id=&text=Your%20Alert%20Title`. To target a forum topic, add `&message_thread_id=` before the `text` parameter. See Telegram's [`sendMessage` documentation](https://core.telegram.org/bots/api#sendmessage) for more information.
-## Telegram Best Practices
+## Telegram best practices
-### Group vs Direct Messages
+### Group vs direct messages
- **Direct Messages**: Use your personal chat ID for personal notifications
- **Group Chats**: Add the bot to group chats and use the group's Chat ID for team notifications
- **Forum Topics**: Use the group's Chat ID together with the topic's Message Thread ID
- **Channels**: Bots can post to channels if added as administrators
-### Message Formatting
+### Message formatting
Checkly sends Telegram messages with HTML formatting (`parse_mode=HTML`), so use HTML tags such as ``, `` and `` in your payload. Markdown syntax is shown as plain text.
@@ -119,7 +119,7 @@ Error: {{CHECK_ERROR_MESSAGE}}
View Details
```
-### Security Considerations
+### Security considerations
- **Bot Token Security**: Keep your bot tokens secure and never share them publicly
- **Chat ID Privacy**: Chat IDs can be sensitive information, especially for private groups
diff --git a/integrations/alerts/webhooks.mdx b/integrations/alerts/webhooks.mdx
index 0e1c9e1d8..13557bb8a 100644
--- a/integrations/alerts/webhooks.mdx
+++ b/integrations/alerts/webhooks.mdx
@@ -1,5 +1,5 @@
---
-title: "Webhook Integrations"
+title: "Webhook integrations"
description: "Create custom webhook integrations to send Checkly alerts to any API endpoint"
sidebarTitle: "Webhooks"
canonical: 'https://www.checklyhq.com/docs/integrations/alerts/webhooks/'
@@ -19,7 +19,7 @@ Webhooks allow you to POST custom payloads to any endpoint in your own infrastru
- Create a **custom payload body** using any environment variables and specific instance variables per event. If the check that triggers the alert belongs to a Group, you can also use the Group's variables, whether the webhook is attached to the check or to the Group.
- **Debug and test the webhook** in the editor by sending test messages.
-## Using Variables
+## Using variables
The example above shows a webhook configured to create a Jira ticket on each event. Notice the following:
@@ -139,7 +139,7 @@ When [automatic Rocky AI analysis](/resolve/ai-root-cause-analysis/overview#auto
}
```
-### Handlebars Helpers
+### Handlebars helpers
Webhook templates support [Handlebars built-in helpers](https://handlebarsjs.com/guide/builtin-helpers.html), such as `if`, `unless`, and `each`, as well as these Checkly helpers:
@@ -241,7 +241,7 @@ Two clear benefits here:
- You only need to create one webhook to inform a 3rd party system.
- You can translate Checkly terms to your 3rd party tool's term for the same concept, i.e. the "up status" of a check.
-## Webhook Secrets
+## Webhook secrets
You can validate each webhook we deliver to your endpoint(s). Using the optional webhook secret, you can:
@@ -334,7 +334,7 @@ def webhook(request):
-## Webhook Retries
+## Webhook retries
Checkly will retry your webhook up to **5 times** if the request fails, for example with an HTTP response higher than 399 (such as a 404 or 503), a network error, or no response within 5 seconds. Retries back off exponentially: 10, 20, 40, 80 and 160 seconds, about 5 minutes in total.
@@ -369,7 +369,7 @@ A reminder repeats the `ALERT_TYPE` of the alert it reminds you about, with `IS_
To recognize a webhook you already processed, for example after a retry, combine `CHECK_RESULT_ID`, `ALERT_TYPE` and `REMINDER_SEQUENCE`. Together they identify one notification, and retries resend the same values.
-## Webhook Examples
+## Webhook examples
The following examples give an idea how to integrate Checkly with 3rd party alerting and issue tracking systems.
diff --git a/integrations/ci-cd/gitlab/overview.mdx b/integrations/ci-cd/gitlab/overview.mdx
index 852f2d123..f2017bad3 100644
--- a/integrations/ci-cd/gitlab/overview.mdx
+++ b/integrations/ci-cd/gitlab/overview.mdx
@@ -16,7 +16,7 @@ Leave **Protect variable** unchecked for both, or the `e2e-staging` job, which r
GitLab passes these variables to every job as environment variables, and `checkly test` and `checkly deploy` read them from there.
-## A Basic GitLab Pipeline Example
+## A basic GitLab pipeline example
Create a new `.gitlab-ci.yml` file in your repo, or add the steps and stages from the example below to your existing file.
This pipeline is "branch aware" and treats the `main` branch as the production branch. This means checks are only deployed
diff --git a/integrations/ci-cd/jenkins/overview.mdx b/integrations/ci-cd/jenkins/overview.mdx
index db52f6c58..88edeb9fc 100644
--- a/integrations/ci-cd/jenkins/overview.mdx
+++ b/integrations/ci-cd/jenkins/overview.mdx
@@ -20,7 +20,7 @@ You can also set these data items specifically by using environment variables.
-## A Basic pipeline example
+## A basic pipeline example
Create a new Jenkinsfile in your repo, or add the steps and stages from the example below to your existing file.
This pipeline is "branch aware" and treats the `main` branch as the production branch. This means checks are only deployed
@@ -45,7 +45,7 @@ Store them as "secret text" and assign and ID to the credential.

-## Configuring the Jenkins Pipeline
+## Configuring the Jenkins pipeline
Add the `Jenkinsfile` to your repo that defines the basic stages and steps. Make sure to set up your SCM settings
correctly so Jenkins can fetch your git repo and look for the `Jenkinsfile` in the root of your project.
diff --git a/integrations/ci-cd/overview.mdx b/integrations/ci-cd/overview.mdx
index a3760bb1f..ae3c98e11 100644
--- a/integrations/ci-cd/overview.mdx
+++ b/integrations/ci-cd/overview.mdx
@@ -17,18 +17,18 @@ Regardless of the provider or platform you use, integrating Checkly into your CI
With this approach, you can validate your application and infrastructure before deploying to production, staging or any other environments.
Simultaneously , you can life cycle (create/update/delete) your checks from your code base as part of your CI/CD workflow.
-## CI/CD Integration with the Checkly CLI
+## CI/CD integration with the Checkly CLI
The preferred and most flexible way to integrate Checkly with your CI/CD is through the [Checkly CLI](/cli/overview).
-## CI/CD Integration using vendor webhooks
+## CI/CD integration using vendor webhooks
- [Vercel](/integrations/ci-cd/vercel/overview)
- [GitHub deployment hooks](/integrations/ci-cd/github/deployments)
-## CI/CD Basics
+## CI/CD basics
We've optimized the [Checkly CLI](/cli/overview) to work in any CI/CD workflow. Here are the basics you need to know that
will come in handy when adapting the examples we give you to your own, specific setup.
diff --git a/integrations/ci-cd/vercel/deployment-protection.mdx b/integrations/ci-cd/vercel/deployment-protection.mdx
index 73d932834..c91e1b8da 100644
--- a/integrations/ci-cd/vercel/deployment-protection.mdx
+++ b/integrations/ci-cd/vercel/deployment-protection.mdx
@@ -1,7 +1,7 @@
---
title: Vercel Deployment Protection
description: "Let Checkly's Browser checks reach protected Vercel preview and production deployments by passing a Protection Bypass for Automation secret in your tests."
-sidebarTitle: Deployment Protection
+sidebarTitle: Deployment protection
canonical: 'https://www.checklyhq.com/docs/integrations/ci-cd/vercel/deployment-protection/'
---
@@ -13,7 +13,7 @@ so we can validate your preview branches before they reach production and contin
Vercel has a few different ways to authenticate your deployments. Each work a bit different. We will go over each of them below.
-## Bypass for Automation
+## Bypass for automation
You can fully bypass any deployment protection using Vercel's [Protection Bypass for Automation feature](https://vercel.com/docs/security/deployment-protection/methods-to-bypass-deployment-protection/protection-bypass-automation).
With this feature, you can provide a secret in an HTTP header or query parameter to bypass any deployment protection.
@@ -51,14 +51,14 @@ For an API check you can do something similar
request.headers['x-vercel-protection-bypass'] = process.env.VERCEL_BYPASS_TOKEN
```
-## Vercel Authentication
+## Vercel authentication
Vercel has a few different ways to authenticate your deployments. Each work a bit different and require a different approach
to make them work with Checkly.
> Vercel enables **Standard Protection** by default on all new deployments.
-### Standard Protection
+### Standard protection
[Standard Protection](https://vercel.com/docs/concepts/deployments/deployment-protection#vercel-authentication)
works by prompting the user to log in to Vercel with their normal Vercel user before they can access the deployment.
@@ -119,7 +119,7 @@ You will have to supply your GitHub username and password as environment variabl
the code example) to your Checkly account or as part of the [Browser check's environment variables](/platform/variables).
-### Only Preview Deployments
+### Only preview deployments
[Only Preview Deployments](https://vercel.com/docs/concepts/deployments/deployment-protection#vercel-authentication)
is the same as Standard Protection, but only applies to Preview deployments. This means that we need to tweak the above code
@@ -183,7 +183,7 @@ explore bypassing 2FA using the `otpauth` library. [Check our blog post for more
-## Password Protection
+## Password protection
Vercel's [Password Protection](https://vercel.com/docs/concepts/deployments/deployment-protection#password-protection) is a paid
addon that allows you to set a dedicated password for your deployments and specifically bypass protection for E2E tests / automation.
You can accomplish this using the resources referenced in the docs for [Browser checks](/learn/playwright/login-automation)
diff --git a/integrations/ci-cd/vercel/managing-plan.mdx b/integrations/ci-cd/vercel/managing-plan.mdx
index f61131301..45f84d517 100644
--- a/integrations/ci-cd/vercel/managing-plan.mdx
+++ b/integrations/ci-cd/vercel/managing-plan.mdx
@@ -1,7 +1,7 @@
---
-title: Managing Users and Plans with Vercel
+title: Managing users and plans with Vercel
description: "Manage Checkly users, plans, and billing through Vercel's native integration, adding team members and adjusting your plan from the Vercel dashboard."
-sidebarTitle: Managing Users and Plans
+sidebarTitle: Managing users and plans
canonical: 'https://www.checklyhq.com/docs/integrations/ci-cd/vercel/managing-plan/'
---
diff --git a/integrations/ci-cd/vercel/overview.mdx b/integrations/ci-cd/vercel/overview.mdx
index 0919523c1..78acbcd3a 100644
--- a/integrations/ci-cd/vercel/overview.mdx
+++ b/integrations/ci-cd/vercel/overview.mdx
@@ -17,7 +17,7 @@ Checkly offers two integrations for Vercel users:
Using Vercel deployment protection? Read [this section](/integrations/ci-cd/vercel/deployment-protection) on how to make this work with Checkly.
-## Installing the Marketplace Integration
+## Installing the Marketplace integration
To install Checkly's managed Vercel integration, navigate to the [integration's marketplace listing](https://vercel.com/integrations/checkly) and click `Install`.
@@ -54,7 +54,7 @@ Once the project and the check/group have been linked, you are able to specify w
Should you wish to unlink the Vercel project, simply click `Unlink this project`.
-### Targeting Preview deployments with `ENVIRONMENT_URL` and `ENVIRONMENT_NAME`
+### Targeting preview deployments with `ENVIRONMENT_URL` and `ENVIRONMENT_NAME`
On each deployment triggered by Vercel, we inject the Checkly runtime with two variables:
@@ -177,7 +177,7 @@ So, what does this mean for the blocking heuristics? It means that we will mark
For more info on the **Virtual Experience Score** [check the documentation on the Vercel site](https://vercel.com/docs/concepts/analytics/web-vitals#virtual-experience-score).
-### Skipping Performance checks
+### Skipping performance checks
In some cases, Checkly will completely skip performance checks. You will see the "skipped" status in your Vercel deployment overview.
Checkly skips performance checks when the domain of the visited URL in the script does not match the domain of the **deployment URL**. In 9 out of 10 cases this should be the URL for your Preview and Production deployments.
diff --git a/integrations/iac/pulumi/best-practices.mdx b/integrations/iac/pulumi/best-practices.mdx
index f654ea2e5..3c94f2b53 100644
--- a/integrations/iac/pulumi/best-practices.mdx
+++ b/integrations/iac/pulumi/best-practices.mdx
@@ -1,7 +1,7 @@
---
-title: 'Pulumi Best Practices'
+title: 'Pulumi best practices'
description: 'Best practices for managing monitoring as code with the Checkly Pulumi provider'
-sidebarTitle: 'Best Practices'
+sidebarTitle: 'Best practices'
canonical: 'https://www.checklyhq.com/docs/integrations/iac/pulumi/best-practices/'
---
@@ -12,12 +12,12 @@ This guide covers best practices for effectively managing your Checkly monitorin
The code samples on this page only show the properties that matter for each practice. A `checkly.Check` also needs `type`, `activated` and `frequency` (and a `request` for API checks), and a `checkly.CheckGroup` needs `activated` and `concurrency`. See the [Pulumi examples](/integrations/iac/pulumi/examples) for complete resources.
-## Resource Management
+## Resource management
-### Naming Conventions
+### Naming conventions
-
+
**Consistent Naming**
- Use descriptive, lowercase names with hyphens
- Include environment prefixes (dev, staging, prod)
@@ -25,7 +25,7 @@ The code samples on this page only show the properties that matter for each prac
- Avoid generic names like "check1" or "test"
-
+
**Organized Tagging**
- Use consistent tag patterns across resources
- Include environment, team, and purpose tags
@@ -55,7 +55,7 @@ new checkly.Check('check1', { name: 'Test' })
new checkly.Check('my_check', { name: 'My Check' })
```
-### Resource Organization
+### Resource organization
Organize your Pulumi code into logical modules and use check groups to maintain clear relationships between related resources.
@@ -82,9 +82,9 @@ apiChecks.forEach(check => {
})
```
-## Security Best Practices
+## Security best practices
-### Secret Management
+### Secret management
Never commit API keys, passwords, or other sensitive information directly in your Pulumi code or version control.
@@ -119,10 +119,10 @@ const apiKey = config.requireSecret('apiKey')
const accountId = config.require('accountId')
```
-### Access Control
+### Access control
-
+
**Secure API Keys**
- Use dedicated API keys for Pulumi
- Rotate keys regularly
@@ -130,7 +130,7 @@ const accountId = config.require('accountId')
- Monitor key usage
-
+
**Team Permissions**
- Use Pulumi organizations for team collaboration
- Implement role-based access control
@@ -139,9 +139,9 @@ const accountId = config.require('accountId')
-## Environment Management
+## Environment management
-### Stack Strategy
+### Stack strategy
Use separate Pulumi stacks for different environments to maintain isolation and enable environment-specific configurations.
@@ -180,7 +180,7 @@ const envConfig = {
const currentConfig = envConfig[environment]
```
-### Configuration Management
+### Configuration management
Use Pulumi's configuration system to manage environment-specific settings and avoid hardcoding values.
@@ -198,12 +198,12 @@ pulumi config set apiUrl https://staging-api.example.com --stack staging
pulumi config set apiUrl https://api.example.com --stack prod
```
-## Monitoring Strategy
+## Monitoring strategy
-### Check Frequency Optimization
+### Check frequency optimization
-
+
**High Frequency**
- 1-5 minute intervals for critical APIs
- Multiple locations for redundancy
@@ -211,7 +211,7 @@ pulumi config set apiUrl https://api.example.com --stack prod
- Comprehensive assertions
-
+
**Lower Frequency**
- 10-30 minute intervals for non-critical services
- Single location monitoring
@@ -220,7 +220,7 @@ pulumi config set apiUrl https://api.example.com --stack prod
-### Location Strategy
+### Location strategy
```javascript
// Critical service - multiple locations
@@ -238,7 +238,7 @@ new checkly.Check('admin-dashboard', {
})
```
-### Assertion Best Practices
+### Assertion best practices
**Comprehensive API checks:**
```javascript
@@ -278,9 +278,9 @@ new checkly.Check('comprehensive-api-check', {
})
```
-## Code Organization
+## Code organization
-### Modular Structure
+### Modular structure
Organize your Pulumi code into logical modules to improve maintainability and reusability.
@@ -325,7 +325,7 @@ function createApiChecks(environment) {
module.exports = { createApiChecks }
```
-### Reusable Functions
+### Reusable functions
```javascript
// utils/helpers.js
@@ -356,9 +356,9 @@ function createStandardApiCheck(name, url, options = {}) {
module.exports = { createStandardApiCheck }
```
-## CI/CD Integration
+## CI/CD integration
-### Automated Deployments
+### Automated deployments
@@ -410,9 +410,9 @@ jobs:
CHECKLY_API_KEY: ${{ secrets.CHECKLY_API_KEY }}
```
-## Testing and Validation
+## Testing and validation
-### Preview Changes
+### Preview changes
Always use `pulumi preview` before deploying to understand what changes will be made to your infrastructure.
@@ -426,24 +426,24 @@ pulumi preview --stack prod
pulumi preview --stack prod --show-replacement-steps
```
-### Validation Strategies
+### Validation strategies
-
+
- Validate environment variables are set
- Check API key permissions
- Verify account ID format
- Test connectivity to Checkly API
-
+
- Verify check configurations
- Test alert channel connectivity
- Validate check group assignments
- Confirm location availability
-
+
- Monitor initial check runs
- Verify alert channel notifications
- Check resource relationships
@@ -451,9 +451,9 @@ pulumi preview --stack prod --show-replacement-steps
-## Performance Considerations
+## Performance considerations
-### Resource Limits
+### Resource limits
Be mindful of Checkly's resource limits and pricing when creating large numbers of checks or high-frequency monitoring.
@@ -488,9 +488,9 @@ endpoints.forEach(endpoint => {
})
```
-## Maintenance and Updates
+## Maintenance and updates
-### Regular Reviews
+### Regular reviews
Schedule regular reviews of your monitoring infrastructure to ensure it remains effective and up-to-date.
@@ -517,25 +517,25 @@ Maintain comprehensive documentation of your monitoring infrastructure, includin
- Troubleshooting guides
- Change management procedures
-## Common Pitfalls to Avoid
+## Common pitfalls to avoid
-
+
**Problem**: Manual changes in Checkly UI create drift with Pulumi state
**Solution**: Always manage resources through Pulumi or document manual changes
-
+
**Problem**: Committing secrets to version control
**Solution**: Use environment variables and Pulumi's secret management
-
+
**Problem**: Too many checks or too frequent monitoring
**Solution**: Focus on critical paths and optimize check frequencies
-
+
**Problem**: Unclear or inconsistent resource names
**Solution**: Establish and follow naming conventions
diff --git a/integrations/iac/pulumi/ci-cd.mdx b/integrations/iac/pulumi/ci-cd.mdx
index 8ae9e4b1f..e951cf679 100644
--- a/integrations/iac/pulumi/ci-cd.mdx
+++ b/integrations/iac/pulumi/ci-cd.mdx
@@ -1,7 +1,7 @@
---
-title: 'CI/CD Integration'
+title: 'CI/CD integration'
description: 'Integrate Pulumi with CI/CD pipelines for automated monitoring infrastructure deployments'
-sidebarTitle: 'CI/CD Integration'
+sidebarTitle: 'CI/CD integration'
canonical: 'https://www.checklyhq.com/docs/integrations/iac/pulumi/ci-cd/'
---
@@ -15,7 +15,7 @@ CI/CD integration enables you to automatically deploy monitoring changes when co
-
+
**Continuous Deployment**
- Deploy monitoring changes automatically
- Reduce manual configuration errors
@@ -23,7 +23,7 @@ CI/CD integration enables you to automatically deploy monitoring changes when co
- Enable rapid iteration
-
+
**Multi-Environment Support**
- Separate stacks for each environment
- Environment-specific configurations
@@ -31,7 +31,7 @@ CI/CD integration enables you to automatically deploy monitoring changes when co
- Consistent monitoring across environments
-
+
**Secure Deployments**
- Secure secret management
- Role-based access control
@@ -39,7 +39,7 @@ CI/CD integration enables you to automatically deploy monitoring changes when co
- Compliance with security policies
-
+
**Team Workflows**
- Code review for monitoring changes
- Pull request-based deployments
@@ -50,10 +50,10 @@ CI/CD integration enables you to automatically deploy monitoring changes when co
## GitHub Actions
-### Basic Workflow
+### Basic workflow
-
+
```yaml .github/workflows/deploy.yml
name: Deploy Monitoring Infrastructure
@@ -125,7 +125,7 @@ jobs:
-### Multi-Environment Workflow
+### Multi-environment workflow
```yaml .github/workflows/multi-env.yml
name: Deploy Monitoring Infrastructure
@@ -165,7 +165,7 @@ jobs:
PULUMI_ACCESS_TOKEN: ${{ secrets.PULUMI_ACCESS_TOKEN }}
```
-### Advanced Workflow with Testing
+### Advanced workflow with testing
```yaml .github/workflows/pipeline.yml
name: Monitoring Infrastructure Pipeline
@@ -284,7 +284,7 @@ jobs:
## GitLab CI/CD
-### Basic Pipeline
+### Basic pipeline
```yaml .gitlab-ci.yml
stages:
@@ -710,9 +710,9 @@ workflows:
only: main
```
-## Security Best Practices
+## Security best practices
-### Secret Management
+### Secret management
@@ -723,7 +723,7 @@ workflows:
- Use least-privilege access
-
+
**Role-Based Access**
- Limit deployment permissions
- Use separate accounts for different environments
@@ -732,10 +732,10 @@ workflows:
-### Security Checklist
+### Security checklist
-
+
- [ ] Store secrets in CI/CD platform's secret management
- [ ] Use environment-specific secrets
- [ ] Rotate API keys regularly
@@ -743,7 +743,7 @@ workflows:
- [ ] Never log or expose secrets
-
+
- [ ] Implement approval gates for production
- [ ] Use separate accounts for environments
- [ ] Limit who can trigger deployments
@@ -751,7 +751,7 @@ workflows:
- [ ] Use branch protection rules
-
+
- [ ] Validate code before deployment
- [ ] Use trusted base images
- [ ] Scan for vulnerabilities
@@ -762,10 +762,10 @@ workflows:
## Troubleshooting
-### Common Issues
+### Common issues
-
+
**Problem**: Pulumi or Checkly authentication fails
**Solutions**:
- Verify API keys are correctly set in secrets
@@ -774,7 +774,7 @@ workflows:
- Test authentication locally first
-
+
**Problem**: Pipeline lacks permissions to deploy
**Solutions**:
- Check CI/CD platform permissions
@@ -783,7 +783,7 @@ workflows:
- Review branch protection rules
-
+
**Problem**: Resources already exist or conflict
**Solutions**:
- Use `pulumi refresh` to sync state
diff --git a/integrations/iac/pulumi/examples.mdx b/integrations/iac/pulumi/examples.mdx
index a61443119..1b96add58 100644
--- a/integrations/iac/pulumi/examples.mdx
+++ b/integrations/iac/pulumi/examples.mdx
@@ -1,5 +1,5 @@
---
-title: 'Pulumi Examples'
+title: 'Pulumi examples'
description: 'Comprehensive examples for different check types and configurations using the Checkly Pulumi provider'
sidebarTitle: 'Examples'
canonical: 'https://www.checklyhq.com/docs/integrations/iac/pulumi/examples/'
@@ -10,7 +10,7 @@ This page provides comprehensive examples of how to use the Checkly Pulumi provi
## Basic API checks
-### Simple GET Request
+### Simple GET request
@@ -67,7 +67,7 @@ new checkly.Check('simple-get-api', {
-### POST Request with JSON Body
+### POST request with JSON body
@@ -152,7 +152,7 @@ new checkly.Check('post-api-check', {
## Browser checks
-### Basic Page Load Check
+### Basic page load check
@@ -213,7 +213,7 @@ new checkly.Check('basic-browser-check', {
-### Login Flow Check
+### Login flow check
@@ -294,7 +294,7 @@ new checkly.Check('login-flow-check', {
## Check groups
-### Organizing Related Checks
+### Organizing related checks
@@ -581,9 +581,9 @@ new checkly.Check('critical-api', {
-## Advanced Configurations
+## Advanced configurations
-### Environment-Specific Configurations
+### Environment-specific configurations
@@ -690,10 +690,10 @@ new checkly.Check('environment-aware-check', {
-## Best Practices
+## Best practices
-
+
**Consistent Naming**
- Use descriptive names for resources
- Include environment prefixes
@@ -701,7 +701,7 @@ new checkly.Check('environment-aware-check', {
- Use consistent tagging strategies
-
+
**Logical Grouping**
- Group related checks together
- Use check groups for organization
@@ -717,7 +717,7 @@ new checkly.Check('environment-aware-check', {
- Implement least-privilege access
-
+
**Effective Monitoring**
- Define clear success criteria
- Use appropriate check frequencies
diff --git a/integrations/iac/pulumi/overview.mdx b/integrations/iac/pulumi/overview.mdx
index 3d769e1e3..010697d00 100644
--- a/integrations/iac/pulumi/overview.mdx
+++ b/integrations/iac/pulumi/overview.mdx
@@ -1,7 +1,7 @@
---
-title: 'The Checkly Pulumi Provider'
+title: 'The Checkly Pulumi provider'
description: 'Learn about the Checkly Pulumi Provider'
-sidebarTitle: 'Pulumi Provider'
+sidebarTitle: 'Pulumi provider'
canonical: 'https://www.checklyhq.com/docs/integrations/iac/pulumi/overview/'
---
@@ -133,7 +133,7 @@ $ pulumi config set checkly:apiKey cu_xxx --secret
$ pulumi config set checkly:accountId xxx
```
-### Install the Checkly Pulumi Provider
+### Install the Checkly Pulumi provider
Install the Checkly Pulumi provider (`@checkly/pulumi`) with `yarn` or `npm` to integrate it in your new project.
diff --git a/integrations/iac/pulumi/setup.mdx b/integrations/iac/pulumi/setup.mdx
index fcda425d0..ecdf97a51 100644
--- a/integrations/iac/pulumi/setup.mdx
+++ b/integrations/iac/pulumi/setup.mdx
@@ -1,7 +1,7 @@
---
-title: 'Pulumi Setup Guide'
+title: 'Pulumi setup guide'
description: 'Detailed setup instructions for Pulumi CLI and Checkly integration'
-sidebarTitle: 'Setup Guide'
+sidebarTitle: 'Setup guide'
canonical: 'https://www.checklyhq.com/docs/integrations/iac/pulumi/setup/'
---
@@ -20,7 +20,7 @@ Before starting, ensure you have:
## Step 1: Install Pulumi CLI
-
+
Select your preferred installation method based on your operating system and package manager
@@ -28,12 +28,12 @@ Select your preferred installation method based on your operating system and pac
Run the appropriate installation command for your system
-
+
Confirm Pulumi CLI is working correctly
-### Installation Options
+### Installation options
```bash install-pulumi-brew
@@ -45,7 +45,7 @@ curl -fsSL https://get.pulumi.com | sh
```
-### Verify Installation
+### Verify installation
```bash verify-installation
pulumi version
@@ -56,15 +56,15 @@ You should see output similar to:
v3.100.0
```
-## Step 2: Pulumi Account Setup
+## Step 2: Pulumi account setup
-### Create Account
+### Create account
1. Visit [app.pulumi.com/signup](https://app.pulumi.com/signup)
2. Sign up with your preferred method (GitHub, GitLab, etc.)
3. Complete the account verification process
-### Generate Access Token
+### Generate access token
1. Navigate to [app.pulumi.com/account/tokens](https://app.pulumi.com/account/tokens)
2. Click "Create token"
@@ -89,15 +89,15 @@ Verify your login:
pulumi whoami
```
-## Step 3: Checkly API Configuration
+## Step 3: Checkly API configuration
-### Get Your Account ID
+### Get your account ID
1. Log into [app.checklyhq.com](https://app.checklyhq.com)
2. Navigate to **Settings** → **Account** → **General**
3. Copy your **Account ID**
-### Create API Key
+### Create API key
1. Go to **Settings** → **User** → **API Keys**
2. Click "Create API Key"
@@ -108,15 +108,15 @@ pulumi whoami
API keys act with the [role and permissions](/admin/creating-api-key) of the user who created them. Keep them secure and never commit them to version control.
-## Step 4: Project Setup
+## Step 4: Project setup
-### Create Project Directory
+### Create project directory
```bash create-project
mkdir my-checkly-monitoring && cd my-checkly-monitoring
```
-### Initialize Pulumi Project
+### Initialize Pulumi project
```bash init-pulumi-project
pulumi new javascript
@@ -127,7 +127,7 @@ Follow the prompts:
- **Project description**: `Checkly monitoring infrastructure as code`
- **Stack name**: `dev` (or your preferred environment name)
-### Install Checkly Provider
+### Install Checkly provider
```bash install-checkly-npm
@@ -139,7 +139,7 @@ yarn add @checkly/pulumi
```
-## Step 5: Configure Authentication
+## Step 5: Configure authentication
### Option 1: Environment variables (recommended for development)
@@ -156,7 +156,7 @@ Reload your shell or source the profile:
source ~/.bashrc # or ~/.zshrc
```
-### Option 2: Pulumi Configuration (Recommended for Teams)
+### Option 2: Pulumi configuration (recommended for teams)
```bash setup-pulumi-config
pulumi config set checkly:apiKey your_api_key --secret
@@ -167,7 +167,7 @@ pulumi config set checkly:accountId your_account_id
Using Pulumi configuration is better for team environments as it stores settings with your stack and can be shared across team members.
-### Verify Configuration
+### Verify configuration
Test that your credentials are accessible:
@@ -182,7 +182,7 @@ Or check Pulumi config:
pulumi config
```
-## Step 6: Create Your First Check
+## Step 6: Create your first check
### Update index.js
@@ -214,9 +214,9 @@ new checkly.Check('hello-world-api', {
})
```
-## Step 7: Deploy Your Infrastructure
+## Step 7: Deploy your infrastructure
-### Preview Changes
+### Preview changes
```bash preview-changes
pulumi preview
@@ -236,25 +236,25 @@ When prompted, type `yes` to confirm the deployment.
Congratulations! You've successfully set up Pulumi with Checkly and deployed your first monitoring check.
-## Step 8: Verify Deployment
+## Step 8: Verify deployment
1. Visit your [Checkly dashboard](https://app.checklyhq.com)
2. Navigate to **Checks**
3. You should see your new "Hello World API" check
4. The check should be running and showing as "Passing"
-## Next Steps
+## Next steps
Explore more complex examples and configurations
-
+
Learn best practices for managing monitoring as code
-
+
Set up automated deployments in your CI/CD pipeline
@@ -265,10 +265,10 @@ Common issues and solutions
## Troubleshooting
-### Common Issues
+### Common issues
-
+
If you see authentication errors, verify:
- Your Checkly API key is correct and active
- Your account ID is correct
@@ -276,14 +276,14 @@ If you see authentication errors, verify:
- You're logged into Pulumi (`pulumi whoami`)
-
+
If the Checkly provider isn't found:
- Ensure you've installed `@checkly/pulumi`
- Check your `package.json` for the dependency
- Run `npm install` or `yarn install`
-
+
If you get permission errors:
- Verify your API key has the necessary permissions
- Check that your account ID is correct
diff --git a/integrations/iac/terraform/checks-groups.mdx b/integrations/iac/terraform/checks-groups.mdx
index 367b35ca4..a790b5342 100644
--- a/integrations/iac/terraform/checks-groups.mdx
+++ b/integrations/iac/terraform/checks-groups.mdx
@@ -1,6 +1,6 @@
---
title: 'Checks and groups for Terraform'
-sidebarTitle: 'Checks & Groups'
+sidebarTitle: 'Checks & groups'
description: 'Create and manage Browser checks, API checks, Heartbeat monitors, and check groups using Terraform'
canonical: 'https://www.checklyhq.com/docs/integrations/iac/terraform/checks-groups/'
---
diff --git a/integrations/iac/terraform/ci-cd.mdx b/integrations/iac/terraform/ci-cd.mdx
index 83dbd4cd0..e30320a35 100644
--- a/integrations/iac/terraform/ci-cd.mdx
+++ b/integrations/iac/terraform/ci-cd.mdx
@@ -1,6 +1,6 @@
---
title: 'CI/CD pipelines for Terraform'
-sidebarTitle: 'CI/CD Pipelines'
+sidebarTitle: 'CI/CD pipelines'
description: 'Integrate Terraform with CI/CD tools for automated monitoring setup deployment'
canonical: 'https://www.checklyhq.com/docs/integrations/iac/terraform/ci-cd/'
---
diff --git a/integrations/iac/terraform/command-line-triggers.mdx b/integrations/iac/terraform/command-line-triggers.mdx
index 6ea93941e..4d41cf021 100644
--- a/integrations/iac/terraform/command-line-triggers.mdx
+++ b/integrations/iac/terraform/command-line-triggers.mdx
@@ -1,6 +1,6 @@
---
title: 'Command line triggers for Terraform'
-sidebarTitle: 'Command line Triggers'
+sidebarTitle: 'Command line triggers'
description: 'Set up command line triggers to run checks from CI/CD pipelines or programmatically'
canonical: 'https://www.checklyhq.com/docs/integrations/iac/terraform/command-line-triggers/'
---
diff --git a/integrations/iac/terraform/dashboards.mdx b/integrations/iac/terraform/dashboards.mdx
index 1b035b67f..4cd060176 100644
--- a/integrations/iac/terraform/dashboards.mdx
+++ b/integrations/iac/terraform/dashboards.mdx
@@ -29,7 +29,7 @@ resource "checkly_dashboard" "dashboard-main" {
You can see all the configuration options for checks, as well as more examples, on the official Terraform registry [documentation page](https://registry.terraform.io/providers/checkly/checkly/latest/docs/resources/dashboard).
-### Private Dashboards
+### Private dashboards
> Available as of `v1.6.6`
diff --git a/integrations/iac/terraform/parameterized-resources.mdx b/integrations/iac/terraform/parameterized-resources.mdx
index 0c66f353d..917c55fde 100644
--- a/integrations/iac/terraform/parameterized-resources.mdx
+++ b/integrations/iac/terraform/parameterized-resources.mdx
@@ -1,6 +1,6 @@
---
title: 'Parameterized resources in Terraform'
-sidebarTitle: 'Parameterized Resources'
+sidebarTitle: 'Parameterized resources'
description: 'Use Terraform meta-arguments to create multiple resources from parameterized configurations'
canonical: 'https://www.checklyhq.com/docs/integrations/iac/terraform/parameterized-resources/'
---
diff --git a/integrations/iac/terraform/testing-scripts-locally.mdx b/integrations/iac/terraform/testing-scripts-locally.mdx
index 5ec38d41a..6b4b24e22 100644
--- a/integrations/iac/terraform/testing-scripts-locally.mdx
+++ b/integrations/iac/terraform/testing-scripts-locally.mdx
@@ -1,6 +1,6 @@
---
title: 'Testing Terraform scripts locally'
-sidebarTitle: 'Testing Scripts Locally'
+sidebarTitle: 'Testing scripts locally'
description: 'Run Playwright Test scripts locally for faster development and debugging of Browser checks'
canonical: 'https://www.checklyhq.com/docs/integrations/iac/terraform/testing-scripts-locally/'
---
diff --git a/integrations/incident-management/firehydrant.mdx b/integrations/incident-management/firehydrant.mdx
index cff3a29a2..6fb4fcf01 100644
--- a/integrations/incident-management/firehydrant.mdx
+++ b/integrations/incident-management/firehydrant.mdx
@@ -1,5 +1,5 @@
---
-title: 'Send Alerts to FireHydrant'
+title: 'Send alerts to FireHydrant'
description: 'Integrate with FireHydrant to create and resolve incidents from Checkly alerts'
sidebarTitle: 'FireHydrant'
canonical: 'https://www.checklyhq.com/docs/integrations/incident-management/firehydrant/'
diff --git a/integrations/incident-management/ilert.mdx b/integrations/incident-management/ilert.mdx
index ce286de5d..6a8c55ffe 100644
--- a/integrations/incident-management/ilert.mdx
+++ b/integrations/incident-management/ilert.mdx
@@ -1,5 +1,5 @@
---
-title: 'Send Alerts to ilert'
+title: 'Send alerts to ilert'
description: 'Configure ilert integration to monitor incidents from Checkly alerts'
sidebarTitle: 'ilert'
canonical: 'https://www.checklyhq.com/docs/integrations/incident-management/ilert/'
diff --git a/integrations/incident-management/incidentio.mdx b/integrations/incident-management/incidentio.mdx
index c506e6601..a1993170c 100644
--- a/integrations/incident-management/incidentio.mdx
+++ b/integrations/incident-management/incidentio.mdx
@@ -1,5 +1,5 @@
---
-title: 'Send Alerts to Incident.io'
+title: 'Send alerts to Incident.io'
description: 'Configure Incident.io integration to create and resolve incidents from Checkly alerts'
sidebarTitle: 'Incident.io'
canonical: 'https://www.checklyhq.com/docs/integrations/incident-management/incidentio/'
diff --git a/integrations/incident-management/opsgenie.mdx b/integrations/incident-management/opsgenie.mdx
index dc013db12..015529aa1 100644
--- a/integrations/incident-management/opsgenie.mdx
+++ b/integrations/incident-management/opsgenie.mdx
@@ -1,5 +1,5 @@
---
-title: 'Send Alerts to Opsgenie'
+title: 'Send alerts to Opsgenie'
description: 'Learn how to integrate Checkly with Opsgenie and deliver failure, degradation, and recovery events to any Opsgenie team'
sidebarTitle: 'Opsgenie'
canonical: 'https://www.checklyhq.com/docs/integrations/incident-management/opsgenie/'
diff --git a/integrations/incident-management/pagerduty.mdx b/integrations/incident-management/pagerduty.mdx
index a4069e5f3..69118d628 100644
--- a/integrations/incident-management/pagerduty.mdx
+++ b/integrations/incident-management/pagerduty.mdx
@@ -1,5 +1,5 @@
---
-title: 'Send Alerts to PagerDuty'
+title: 'Send alerts to PagerDuty'
description: 'Learn how Checkly integrates seamlessly with PagerDuty, delivering real-time failure and recovery alerts to your PagerDuty account'
sidebarTitle: 'PagerDuty'
canonical: 'https://www.checklyhq.com/docs/integrations/incident-management/pagerduty/'
@@ -43,7 +43,7 @@ to hit **Create PagerDuty channel**.
5. Checkly will trigger an incident in PagerDuty when checks fail and also mark them as resolved when the checks are passing again.

-## PagerDuty Best Practices
+## PagerDuty best practices
- **Service Organization**: Create separate PagerDuty services for different applications or teams
- **Escalation Policies**: Set up appropriate escalation chains based on check criticality
diff --git a/integrations/incident-management/rootly.mdx b/integrations/incident-management/rootly.mdx
index 518beb1ff..d4882fda7 100644
--- a/integrations/incident-management/rootly.mdx
+++ b/integrations/incident-management/rootly.mdx
@@ -1,5 +1,5 @@
---
-title: 'Send Alerts via Rootly'
+title: 'Send alerts via Rootly'
description: 'Configure Rootly integration to receive real-time alerts from Checkly monitors'
sidebarTitle: 'Rootly'
canonical: 'https://www.checklyhq.com/docs/integrations/incident-management/rootly/'
diff --git a/integrations/incident-management/spike.mdx b/integrations/incident-management/spike.mdx
index 8ce50aa04..844533aa5 100644
--- a/integrations/incident-management/spike.mdx
+++ b/integrations/incident-management/spike.mdx
@@ -1,5 +1,5 @@
---
-title: 'Send Alerts via Spike'
+title: 'Send alerts via Spike'
description: 'Configure Spike integration to receive real-time alerts from Checkly monitors'
sidebarTitle: 'Spike'
canonical: 'https://www.checklyhq.com/docs/integrations/incident-management/spike/'
diff --git a/integrations/incident-management/splunk-on-call.mdx b/integrations/incident-management/splunk-on-call.mdx
index 959bb4bb2..3b8332d40 100644
--- a/integrations/incident-management/splunk-on-call.mdx
+++ b/integrations/incident-management/splunk-on-call.mdx
@@ -1,5 +1,5 @@
---
-title: 'Send Alerts via Splunk On-Call'
+title: 'Send alerts via Splunk On-Call'
description: 'Configure Splunk On-Call integration to receive real-time alerts from Checkly monitors'
sidebarTitle: 'Splunk On-Call'
canonical: 'https://www.checklyhq.com/docs/integrations/incident-management/splunk-on-call/'
diff --git a/learn/incidents/anatomy-of-a-status-page.mdx b/learn/incidents/anatomy-of-a-status-page.mdx
index bd2105cfe..e145e5629 100644
--- a/learn/incidents/anatomy-of-a-status-page.mdx
+++ b/learn/incidents/anatomy-of-a-status-page.mdx
@@ -1,5 +1,5 @@
---
-title: Anatomy of a status page | Checkly Guide
+title: Anatomy of a status page | Checkly guide
displayTitle: Anatomy of a status page
sidebarTitle: Anatomy of a status page
description: Discover what makes a status page users trust - automated monitoring, clear visuals, service groupings, and more.
@@ -19,26 +19,26 @@ When I first started in the tech industry, a new idea was on the scene for your
A status page helps users know if your applications or services are working. Here’s what users expect from a good status page:
-### 1. Clear Status Updates
+### 1. Clear status updates
- Show if services are **up, down, or having issues**.
- Use simple labels (like "Operational," "Degraded," or "Outage").
-### 2. Externally Hosted
+### 2. Externally hosted
- The page should be on a separate system (not your main website). This way, users can check it even if your site is down.
-### 3. Subscribe Function
+### 3. Subscribe function
- Let users **subscribe** to updates via email, SMS, or RSS.
- Notify them when status changes.
-### 4. Easy for Everyone to Use
+### 4. Easy for everyone to use
- **Regular users** should understand it easily.
- **Application owners** should be able to manually mark a service as down if needed.
-### 5. Multiple Sections
+### 5. Multiple sections
- Support different **audiences** (e.g., one page for customers, another for internal teams).
- Let users **subscribe only to the pages they care about**.
diff --git a/learn/incidents/automation-incident-response.mdx b/learn/incidents/automation-incident-response.mdx
index 368ac023e..48911d02b 100644
--- a/learn/incidents/automation-incident-response.mdx
+++ b/learn/incidents/automation-incident-response.mdx
@@ -1,7 +1,7 @@
---
-title: Incident Response Automation - From Alerts to Action
+title: Incident response automation - From alerts to action
displayTitle: Automation in incident response
-sidebarTitle: Playbooks & Automation
+sidebarTitle: Playbooks & automation
description: Discover how to layer semi‑automated workflows, automated scripts, and safety checks into your playbooks for faster recovery.
date: 2025-02-15
author: Nocnica Mellifera
@@ -15,7 +15,7 @@ canonical: 'https://www.checklyhq.com/docs/learn/incidents/automation-incident-r
While human judgment remains essential, automation can significantly reduce response times, minimize human error, and streamline workflows. This guide explores how developers can integrate automation into incident playbooks effectively, balancing speed with safety. Often SaaS offerings will promise to ‘handle outages fully automatically’ but that’s generally not the reality. Why can’t we automate incident response, and what levels of automation make sense for your team?
-### **1. Automation Spectrum in Incident Response**
+### **1. Automation spectrum in incident response**
Automation in incident playbooks exists on a spectrum:
@@ -29,7 +29,7 @@ Most organizations lean toward **semi-automation** due to risk tolerance, but th
- **Failure domain isolation** (Can automation safely fix this without cascading failures?)
- **Regulatory/compliance requirements** (Some industries require human approval for changes.)
-## **2. Key Automation Use Cases in Playbooks**
+## **2. Key automation use cases in playbooks**
**A. Alert Enrichment & Context Gathering**
@@ -72,7 +72,7 @@ Example (ChatOps):
- **Route to the right team** based on symptoms (e.g., SRE vs. Data Engineering)
- **Follow availability and escalation rules** this is the kind of thing that is closely associated with PagerDuty: notifying the person who’s currently on-call, and escalating as needed if that person doesn’t respond
-## **3. Tools & Integration Patterns**
+## **3. Tools & integration patterns**
| **Tool** | **Use Case** | **Example Integration** |
| --- | --- | --- |
@@ -82,7 +82,7 @@ Example (ChatOps):
| **Ansible/Chef** | Safe, idempotent remediation | Rollback to last known good config |
| **Serverless (AWS Lambda)** | Lightweight automation hooks | Auto-mitigate S3 bucket throttling |
-## **4. Security & Guardrails**
+## **4. Security & guardrails**
Automation introduces risks—**fail-safes are critical**:
@@ -101,7 +101,7 @@ fi
```
-## **5. Cultural & Organizational Factors**
+## **5. Cultural & organizational factors**
- **Start small**: Automate only the most repetitive, low-risk tasks.
- **Trust through transparency**: Engineers should see what automation is doing (e.g., ChatOps command logging).
@@ -112,7 +112,7 @@ A quote from one engineer talking about how automation can get rolled back after
> "At one company, we automated DNS failover—until it once failed over unnecessarily. Now it pings the on-call first."
>
-### The final word on Automation in playbooks
+### The final word on automation in playbooks
Automation in incident playbooks isn’t about replacing humans—it’s about **augmenting response efforts** while minimizing toil. By focusing on **enrichment, safe remediation, and guardrails**, developers can build systems that accelerate recovery without sacrificing reliability.
diff --git a/learn/incidents/detection-best-practices.mdx b/learn/incidents/detection-best-practices.mdx
index f9d9ffc55..d161e64a8 100644
--- a/learn/incidents/detection-best-practices.mdx
+++ b/learn/incidents/detection-best-practices.mdx
@@ -1,7 +1,7 @@
---
-title: Best Practices for Detecting Downtime | Incident Response
+title: Best practices for detecting downtime | Incident response
displayTitle: Best Practices for Detecting Downtime - A Guide for Developers
-sidebarTitle: Detecting Downtime
+sidebarTitle: Detecting downtime
description: Discover how to implement multi‑layered monitoring, smart alerts, third‑party checks, failure drills & global probes to catch outages fast and reduce revenue loss
date: 2025-02-15
author: Nocnica Mellifera
@@ -16,7 +16,7 @@ canonical: 'https://www.checklyhq.com/docs/learn/incidents/detection-best-practi
Downtime can be costly—leading to lost revenue, frustrated users, and damage to your brand’s reputation. As a developer, ensuring high availability and quickly detecting outages is critical.
-## **1. Implement Multi-Layered Monitoring**
+## **1. Implement multi-layered monitoring**
Relying on a single monitoring method can lead to blind spots. Instead, use a combination of:
@@ -24,7 +24,7 @@ Relying on a single monitoring method can lead to blind spots. Instead, use a co
- **Application Monitoring**: Gather traces internal from your application, and look for errors or long timespans that indicate trouble. Send logs to a single locality to help you investigate problems after one is detected.
- **Infrastructure Monitoring**: Use tools like Prometheus, Grafana, or Nagios to keep an eye on the underlying health of your system.
-## **2. Set Up Intelligent Alerting**
+## **2. Set up intelligent alerting**
Avoid "alert fatigue" by ensuring alerts are meaningful and actionable:
@@ -32,7 +32,7 @@ Avoid "alert fatigue" by ensuring alerts are meaningful and actionable:
- **Prioritize Alerts**: Distinguish between *critical* (full outage) and *warning* (degraded performance). Any time your on-call team gets an alert that doesn’t require action, this should be counted as a false alarm and call for improvements to your alert thresholds.
- **Avoid Static Thresholds**: When a service that usually responds in 4.98 seconds starts responding after 5.1 seconds, it’s a negative trend that might call for some investigation. But it certainly does *not* call for a midnight alert to the on-call team. As just one example, Playwright’s assertions about page elements use an [auto-waiting](https://www.checklyhq.com/blog/playwright-auto-waiting/) system that is more flexible than static time thresholds.
-## **3. Monitor Third-Party Dependencies**
+## **3. Monitor third-party dependencies**
Your application may depend on APIs, CDNs, or cloud providers—any of which can fail.
@@ -40,7 +40,7 @@ Your application may depend on APIs, CDNs, or cloud providers—any of which can
- **Implement Fallbacks**: Gracefully degrade functionality if a dependency fails. For core dependencies this might go as far as switching to a backup payment provider if your primary service fails.
-## **4. Test Failure Scenarios**
+## **4. Test failure scenarios**
Proactively simulate outages to ensure your monitoring works:
@@ -50,7 +50,7 @@ Proactively simulate outages to ensure your monitoring works:
---
-## **5. Ensure Global Visibility**
+## **5. Ensure global visibility**
Downtime may only affect certain regions due to DNS, CDN, or cloud provider issues.
@@ -59,7 +59,7 @@ Downtime may only affect certain regions due to DNS, CDN, or cloud provider issu
---
-## **6. Automate Incident Response**
+## **6. Automate incident response**
When downtime occurs, speed is crucial.
diff --git a/learn/incidents/dora-metrics.mdx b/learn/incidents/dora-metrics.mdx
index 02c3c75ea..a8fa4b7fa 100644
--- a/learn/incidents/dora-metrics.mdx
+++ b/learn/incidents/dora-metrics.mdx
@@ -1,7 +1,7 @@
---
-title: How to Use DORA Metrics the Right Way | Checkly
+title: How to use DORA metrics the right way | Checkly
displayTitle: How to Use DORA Metrics the Right Way
-sidebarTitle: DORA Metrics for Performance Evaluation
+sidebarTitle: DORA metrics for performance evaluation
description: Learn to track and interpret DORA’s four metrics—deployments, lead time, failure rate, and restore time—to improve your software delivery.
date: 2025-03-13
author: Nocnica Mellifera
@@ -26,7 +26,7 @@ DORA metrics measurements are inherently subjective to your team and **not a goo
There’s an interesting variety in DORA metrics. Some are unequivocal in their interpretation (it’s always better to have a lower ‘time to restore service’), while others have no meaning outside context (I could write a script that makes small grammar edits and deploys them, massively boosting ‘deployment frequency’ with no benefit). Some are easy to measure like deployment frequency, others like change failure rate require some thought about *what* is being measured before we even ask why it matters. Here’s all four metrics in detail.
-### Deployment Frequency
+### Deployment frequency
Deployment frequency measures how often a team successfully releases code to production.
@@ -44,7 +44,7 @@ Deployment frequency is also an object lesson in why **DORA metrics don't transl
Factors like underlying code structure and QA practices can cause large differences between teams, so it's best to establish baselines for your team based on past performance.
-### Lead Time for Changes
+### Lead time for changes
Lead time for changes measures how long it takes for code to go from being written to running in production. To calculate it, find the time between when a commit is made and when it’s deployed. Use the middle value (median) of these times over a set period.
@@ -54,7 +54,7 @@ To measure lead time, start tracking when a pull request (PR) is created or merg
In general, shorter lead times are better. For example, top teams (elite performers) deploy changes in less than a day, while slower teams might take weeks or even months. Faster lead times mean your team can respond quickly to needs and keep improving.
-### Time to Restore Services
+### Time to restore services
Time to restore services measures how long it takes to fix a service after it fails. The clock stops when the issue is resolved, and the related bug or incident report is closed.
@@ -72,7 +72,7 @@ To calculate the metric, add up the time spent on all incidents and divide by th
Faster recovery times are better. Top teams (elite performers) fix issues in less than an hour, while slower teams might take days or even weeks.
-### Change Failure Rate
+### Change failure rate
Change failure rate measures how often deployments cause problems. It’s the percentage of deployments that fail out of the total number of deployments.
diff --git a/learn/incidents/incident-assessment-severity.mdx b/learn/incidents/incident-assessment-severity.mdx
index f26f330f7..804ea39b9 100644
--- a/learn/incidents/incident-assessment-severity.mdx
+++ b/learn/incidents/incident-assessment-severity.mdx
@@ -1,7 +1,7 @@
---
-title: Incident Assessment & Severity | Checkly Guide
+title: Incident assessment & severity | Checkly guide
displayTitle: Incident Assessment & Severity Guide for Engineering Teams (+ Cheat Sheet)
-sidebarTitle: Incident Assessment & Severity Guide
+sidebarTitle: Incident assessment & severity guide
description: Not every alert is an incident—and not every incident is equally urgent. How to classify incidents and determine their severity?
date: 2025-05-23
author: Sara Miteva
@@ -13,7 +13,7 @@ learn_incidents:
canonical: 'https://www.checklyhq.com/docs/learn/incidents/incident-assessment-severity/'
---
-## **Incident Assessment & Severity**
+## **Incident assessment & severity**
Not every alert is an incident—and not every incident is equally urgent.
@@ -28,7 +28,7 @@ The goal of incident assessment is to **evaluate the scope and impact** of a pro
Let’s break down what effective assessment looks like and how to build your own severity classification system.
-### **What Is Incident Assessment?**
+### **What is incident assessment?**
Incident assessment is the process of determining whether an observed issue qualifies as an incident—and if so, how serious it is.
@@ -41,7 +41,7 @@ To assess an incident, you typically ask:
The outcome of this process is a **severity level** that maps to your internal response playbook: who gets paged, how quickly you communicate, and how visible the incident becomes across the company.
-### **Why Severity Levels Matter**
+### **Why severity levels matter**
Clear severity definitions help your team:
@@ -52,7 +52,7 @@ Clear severity definitions help your team:
They also create psychological safety. When engineers know exactly what qualifies as a SEV1, they don’t waste time debating—they act.
-## Severity Levels: Example Framework
+## Severity levels: Example framework
Here’s a simple, 3-tier severity model you can adopt or adapt:
@@ -62,7 +62,7 @@ Here’s a simple, 3-tier severity model you can adopt or adapt:
| **SEV2** | High / Partial Outage | 10% of users can’t log in, degraded performance, partial failure | Escalate to on-call immediately. Frequent updates. Prioritized fix. |
| **SEV3** | Moderate / Minor Bug | Broken styling, slow dashboard load, minor UX issue | Fix during business hours. Log the issue. May not require updates. |
-### A Score-Based System for Classifying Severity
+### A score-based system for classifying severity
You can use a weighted scoring system that evaluates incidents across five dimensions. This adds structure and reduces subjective decisions:
@@ -93,30 +93,30 @@ Let’s say our business is a review site with an ecommerce store. Users on Micr
→ **Score: 12 → SEV1**
-## Downloadable Incident Severity Cheat Sheet
+## Downloadable incident severity cheat sheet
If you want to adopt or adapt this process, you can make a copy of our own [incident severity cheat sheet](https://docs.google.com/spreadsheets/d/18L2r8u5h8ylRWNbfMZv0Ff-amJ-ySk5ZU1FLxW2G4uY/edit?usp=sharing).
-## Creating Your Own Severity Rules
+## Creating your own severity rules
Every organization operates differently, and what counts as a critical incident for one team may be a routine alert for another. Here’s how to build a severity scoring system that reflects your team’s priorities, customer expectations, and business context.
-### **1. Pick Dimensions That Matter to You**
+### **1. Pick dimensions that matter to you**
Start by identifying the dimensions of impact that are most relevant to your systems and stakeholders. Common ones include **user impact**, **feature impact**, **business risk**, **urgency**, and **workaround availability**—but you might also include **compliance violations**, **customer tier affected**, or **data integrity** if those are key concerns. The goal is to capture the real-world consequences of an incident in a way that reflects your product and risk model.
-### **2. Agree on What “High”, “Medium”, and “Low” Mean**
+### **2. Agree on what “High”, “Medium”, and “Low” mean**
Without clear definitions, severity scoring quickly becomes subjective. What one engineer sees as a “minor issue” might be considered “urgent” by someone in customer success. To avoid this, document clear criteria for each level of impact. For example, define “High User Impact” as “more than 25% of users affected” or “SEV1 Business Impact” as “any outage that causes revenue loss or legal risk.” These definitions become your north star for consistent triage.
-### **3. Add Automation Where Possible**
+### **3. Add automation where possible**
Manual severity scoring can slow things down and introduce inconsistencies, especially during high-pressure incidents. Automate as much of the process as you can. A shared Google Sheet or Notion template can help teams select impact levels via dropdowns, with scores and severity levels calculated automatically. For more mature teams, connect this logic directly into your alerting pipeline or incident management tool so severity is auto-assigned on alert creation.
-### **4. Train Your Incident Responders**
+### **4. Train your incident responders**
Severity models only work if everyone is aligned on how to use them. Run training sessions or tabletop exercises with your incident response team. Use past incidents to “test” the model—how would they score it now, and does the outcome feel right in hindsight? Over time, this helps calibrate judgment, improves consistency across teams, and creates shared understanding between engineering, support, and leadership.
-## Final Words
+## Final words
Clear severity rules turn gut-feel decisions into structured, confident responses. With a shared scoring model, your team can triage faster, communicate better, and stay focused when it matters most.
diff --git a/learn/incidents/incident-communication.mdx b/learn/incidents/incident-communication.mdx
index 86c82a75a..9c0bec134 100644
--- a/learn/incidents/incident-communication.mdx
+++ b/learn/incidents/incident-communication.mdx
@@ -1,7 +1,7 @@
---
-title: Best Practices for Communicating During Outages and Incidents
+title: Best practices for communicating during outages and incidents
displayTitle: Incident Communication - Best Practices
-sidebarTitle: Incident Communication
+sidebarTitle: Incident communication
description: Lack of communication, or wrong communication, can often be the part of incident response that comes in for the most criticism. While it’s critical to define playbooks for communication, this article will talk in general about the best practices for communicating with users during an incident.
date: 2025-02-15
author: Nocnica Mellifera
@@ -73,7 +73,7 @@ Further, entrusting communications to a customer facing team member means that:
- The support or sales engineer tasked with communication is likely to understand what exactly this outage means for most users, as users average behavior is more clear to someone who works with users directly.
- Customer-facing engineers are often the best people to identify expected behavior for the product, proving enormously helpful during the diagnosis stage.
-## Conclusions: Communication Remains a Human Speciality
+## Conclusions: Communication remains a human speciality
Effective communication during an incident is just as critical as the technical response itself. While engineers naturally prioritize diagnosing and resolving issues, keeping users informed—accurately and promptly—can significantly mitigate frustration and prevent churn. This article has outlined key best practices for incident communication, emphasizing the importance of timing, automation, delegation, and trust in the on-call team’s judgment.
diff --git a/learn/incidents/incident-management-challenges.mdx b/learn/incidents/incident-management-challenges.mdx
index 80d1a2293..0d8e20943 100644
--- a/learn/incidents/incident-management-challenges.mdx
+++ b/learn/incidents/incident-management-challenges.mdx
@@ -1,7 +1,7 @@
---
-title: Incident Management Challenges | Checkly Guide
+title: Incident management challenges | Checkly guide
displayTitle: Incident Management Challenges
-sidebarTitle: Incident Management Challenges
+sidebarTitle: Incident management challenges
description: Find out what are the most common incident challenges and how to address them.
date: 2025-05-23
author: Sara Miteva
@@ -25,7 +25,7 @@ Let’s break down the real-world challenges teams face when managing incidents
.png)
-## Early Detection Is Still Hard
+## Early detection is still hard
Despite proactive monitoring tools, teams often struggle to detect incidents early enough. The challenge?
@@ -37,7 +37,7 @@ Instead, it’s a single failing endpoint. A slightly elevated latency. A login
In the end, early detection isn’t just about tooling. It’s about tuning, ownership, and continuously improving your signal-to-noise ratio.
-## **2. Defining What Is an Incident**
+## **2. Defining what is an incident**
*An **incident** is any unplanned disruption or degradation of a service that affects users or business operations and requires a response.*
@@ -57,13 +57,13 @@ Here’s an example of how you could classify incidents by severity:
The challenge is not just defining these, but aligning everyone—engineering, support, and leadership—on what they mean in practice.
-## 3. Coordination and Escalation Can Get Messy
+## 3. Coordination and escalation can get messy
When things go wrong, teams scramble. But without a clearly defined incident commander or roles like communication lead or scribe, progress stalls. People either duplicate efforts or wait for someone else to lead.
Escalation must be automatic. Everyone should know: when this happens, who gets paged, and who owns the response.
-## 4. Postmortems Get Ignored or Misused
+## 4. Postmortems get ignored or misused
The post-incident review often turns into a blame game or a checkbox exercise. But a good postmortem is blameless, structured, and actionable.
@@ -75,7 +75,7 @@ Ask:
Without real reflection, you’re doomed to repeat the same fire drills.
-## 5. Fear Slows Down Response
+## 5. Fear slows down response
One of the most dangerous challenges in incident management isn’t technical—it’s emotional.
@@ -93,7 +93,7 @@ If people are afraid of being called out, they'll wait. And in incident response
Your culture determines whether your team moves fast—or freezes. Choose transparency over silence. Choose learning over blame.
-## Chaos is the Enemy, Structure is the Fix
+## Chaos is the enemy, structure is the fix
Incident management is a high-stakes, high-pressure process. But when you build in structure—detection, communication, escalation, resolution, reflection—you replace chaos with clarity.
diff --git a/learn/incidents/modern-root-cause-analysis.mdx b/learn/incidents/modern-root-cause-analysis.mdx
index ece6f0cf9..f59130ef8 100644
--- a/learn/incidents/modern-root-cause-analysis.mdx
+++ b/learn/incidents/modern-root-cause-analysis.mdx
@@ -1,7 +1,7 @@
---
-title: Modern Root Cause Analysis | Checkly Guide
+title: Modern root cause analysis | Checkly guide
displayTitle: Modern Root Cause Analysis
-sidebarTitle: Modern Root Cause Analysis
+sidebarTitle: Modern root cause analysis
description: Discover how unified metrics, logs, traces, and synthetic tests help you pinpoint failures faster, reduce downtime, and more.
date: 2025-04-06
author: Nocnica Mellifera
@@ -36,7 +36,7 @@ Going from high level dashboards to logs is still common for operations engineer
As cloud architectures expand into greater complexity, broadening our search for a root cause, we need modern techniques enabled by tools like OpenTelemetry, Jaeger, and Checkly to tackle the problems of modern RCA.
-### Key Improvements in Modern RCA:
+### Key improvements in modern RCA:
1. **Automated Correlation** – With distributed tracing and [context propagation](https://www.checklyhq.com/learn/opentelemetry/context-propagation/), we shouldn’t be trying to line up time codes to correlate observability data from multiple services
2. **Context-Aware Alerts** – Alerts prioritize issues impacting business metrics (like checkout errors vs. low-severity logs). Sophisticated routing and status updates on tools like Rootly mean only the right team members get woken up during incidents.
@@ -51,7 +51,7 @@ A payment service fails intermittently. Traditional RCA might check logs in isol
- **Logs** highlight a third-party API throttling connections.
- **Dashboards** correlate this with a recent deployment, suggesting a rollback.
-### Tools for Effective RCA:
+### Tools for effective RCA:
- **OpenTelemetry** (unified data collection for the back end)
- **Prometheus/Grafana** (metrics visualization)
diff --git a/learn/incidents/mttr-challenges.mdx b/learn/incidents/mttr-challenges.mdx
index 85f6fc662..3e5f7da40 100644
--- a/learn/incidents/mttr-challenges.mdx
+++ b/learn/incidents/mttr-challenges.mdx
@@ -1,7 +1,7 @@
---
-title: MTTR Challenges & Solutions | Checkly
+title: MTTR challenges & solutions | Checkly
displayTitle: Best Practices for Reduced Mean Time To Repair
-sidebarTitle: Reducing Time to Repair
+sidebarTitle: Reducing time to repair
description: Find out why MTTR targets fail—from weak observability and slow detection to cloud‑native complexity—and apply practical tactics to meet your SLAs.
date: 2025-02-15
author: Nocnica Mellifera
@@ -15,7 +15,7 @@ canonical: 'https://www.checklyhq.com/docs/learn/incidents/mttr-challenges/'
Missing MTTR and the concomitant SLA targets is a common occurrence among large tech teams. We all start each quarter with a goal of always resolving issues quickly and delivering high uptime for our users. So why do we fail on these goals? This article is a list of the common causes of missed MTTR:
-### 1. **Observability Tools Are Falling Short**
+### 1. **Observability tools are falling short**
Often the longest period of an incident response is the time spent between knowing you have a problem and understanding what’s causing the problem. This is almost definitional, since once you know the nature of the problem it’s generally possible to fix or at least remediate it pretty quickly, for example with a rollback. But what makes this time to understanding the problem so long?
@@ -25,7 +25,7 @@ Imagine you’re trying to solve an outage that’s only affecting some users an
When tools are cumbersome and fail to provide actionable insights, engineers spend more time diagnosing problems, which increases MTTR.
-### 2. **Time to Detect (TTD) Is Overlooked**
+### 2. **Time to detect (TTD) is overlooked**
Another factor contributing to high MTTR is the time it takes to detect an issue in the first place. Reducing the mean time to detect ([MTTD](/learn/incidents/reduce-mttd)) is crucial for improving MTTR, as delays in detection can lead to prolonged outages.
An entire guide on time to detection is available on our Learn site, but in short the most common failures are:
@@ -36,7 +36,7 @@ An entire guide on time to detection is available on our Learn site, but in shor
Again these concerns and more are in a separate page on [optimizing time to detection](/learn/incidents/reduce-mttd).
-### 3. **The Complexity of Cloud-Native Environments**
+### 3. **The complexity of cloud-native environments**
Many organizations are adopting cloud-native architectures, such as containers and microservices, to improve efficiency and scalability. However, this shift has introduced greater complexity, higher data volumes, and increased pressure on engineering teams. Cloud-native architectures have made it harder to discover and troubleshoot incidents. This complexity can significantly delay the time it takes to detect and resolve issues.
@@ -47,15 +47,15 @@ If you’re unsure if this is true in your own organization, ask this question o
I believe that most engineers would honestly answer: “no,” and that this was different before cloud native architecture.
-## How Can Companies Improve MTTR?
+## How can companies improve MTTR?
To address these challenges, organizations need to focus on optimizing each stage of the incident response process:
-### 1. **Reduce Time to Detect (TTD)**
+### 1. **Reduce time to detect (TTD)**
Improving detection times requires robust monitoring and alerting systems that can quickly identify issues. This involves setting low scrape intervals for data collection and ensuring that observability tools can ingest and generate alerts rapidly. Faster detection allows teams to begin remediation efforts sooner, which can significantly reduce MTTR. This is covered in more detail in our page on [optimizing detection time](/learn/incidents/reduce-mttd).
-### 2. **Streamline Time to Remediate**
+### 2. **Streamline time to remediate**
Once an issue is detected, the next step is to stop the customer pain by implementing a temporary fix. This can be achieved by:
@@ -65,7 +65,7 @@ Once an issue is detected, the next step is to stop the customer pain by impleme
With these tools an on-call team can get the system working for users quickly, followed by a longer period of root cause analysis and postmortem.
-### 3. **Time to Remediate over Time to Repair**
+### 3. **Time to remediate over time to repair**
In our guide on defining MTTR we discussed how the time to remediate (how long it takes to patch the problem such that users are not experiencing an error) versus time to repair (how long it takes to fix the underlying problem). In a simple if outdated example: resetting a server with a memory leak remediates an out-of-memory error, finding and fixing the memory leak repairs the problem.
diff --git a/learn/incidents/on-call-schedule.mdx b/learn/incidents/on-call-schedule.mdx
index c4b546004..9c47976d0 100644
--- a/learn/incidents/on-call-schedule.mdx
+++ b/learn/incidents/on-call-schedule.mdx
@@ -1,7 +1,7 @@
---
-title: How to Set an On‑Call Schedule | Checkly Incident Response
+title: How to set an on‑call schedule | Checkly incident response
displayTitle: How to Set an On-Call Schedule
-sidebarTitle: On-Call Schedules - How to
+sidebarTitle: On-call schedules - How to
description: Learn to design effective on‑call rotations—shift models, clear response rules, scheduling tools, mock drills, and fairness to prevent burnout.
date: 2025-03-15
author: Nocnica Mellifera
@@ -15,13 +15,13 @@ canonical: 'https://www.checklyhq.com/docs/learn/incidents/on-call-schedule/'
Once an incident is detected, it’s time to classify the incident and coordinate with your team. To all that, you’ll need an on-call schedule. This guide covers the necessary components for a successful on-call schedule.
-## Why Have an On-Call Schedule?
+## Why have an on-call schedule?
Things break. People need help. No matter how well-designed, a software system that is constantly getting new features and scaling to meet demand will experience outages and other incidents. Putatively, an on-call schedule is there to make sure someone is always ready to fix problems, but really they tend to be adopted for another reason: burning out your best.
After the first inchoate stage of a software team, there will remain a tendency to bring all technical questions, at any hour of the day, to just 1 or 2 experts. These are often people who are both knowledgeable and possessed of a tendency to look at their phone during dinner. These very effective engineers will quickly get burnt out if they’re the only ones who can actually fix things during a crisis. As such, an on-call schedule can help focus minds as to who can cover during incidents, and who needs more training to get to that level.
-## Steps to Set Up Your Schedule
+## Steps to set up your schedule
First, decide who needs to be on call. Pick people who know how to handle problems and can respond quickly. Make sure everyone gets a turn so no one feels overworked.
@@ -33,14 +33,14 @@ After that, use tools to make it easier. A scheduling app like PagerDuty or Opsg
Finally, test the schedule before real problems happen. Send a practice alert to make sure it works. Ask the team for feedback and adjust if needed. A good on-call schedule keeps things running smoothly and helps everyone feel prepared.
-### 1. Choose Who Is On Call
+### 1. Choose who is on call
The first and arguably most important step of an on-call schedule is deciding who is eligible to help field reports of emerging issues. The number of available on-call engineers will affect every decision you make afterward.
- Pick team members who know how to handle emergencies.
- Make sure everyone gets a fair turn.
-### 2. Decide the Rotation
+### 2. Decide the rotation
Next, choose how long each shift will last. Some teams switch every day, while others cover a full week. Think about what works best for your team and how often emergencies happen.
@@ -52,7 +52,7 @@ The third model, **daylight hours**, spreads coverage across time zones so no on
It’s important to note that your team members will not all feel the same way about these rotations. If possible, let engineers choose a model that makes sense for them, and doesn’t simplistically assign a ‘fair’ system for how easy it is to administer. Remember that a small team can often get by with something like: ‘on-call rotates every day, if you need your day off you’re responsible for finding someone to switch with you.’
-### 3. Set Clear Rules
+### 3. Set clear rules
Try to answer questions about on-call expectations early in the process, not during a post-mortem for an incident that went unread for 8 hours.
@@ -63,7 +63,7 @@ Try to answer questions about on-call expectations early in the process, not dur
Answer these questions now, as a team, or face case-by-case problems and embarrassment later!
-### 4. Use Tools to Help
+### 4. Use tools to help
Unless your team is tiny, you’ll need a few tools to help coordinate on call rotations.
@@ -73,14 +73,14 @@ Unless your team is tiny, you’ll need a few tools to help coordinate on call r
A lot more could be written about how observability tools help during incidents, but those are considered in another guide, read on for more!
-### 5. Make It Fair
+### 5. Make it fair
Tech workers are happy to put up with a lot of ambiguity, complexity, and unpredictability in their jobs, but no one likes working in a situation that feels unfair.
- Avoid burnout. Don’t put the same person on call too often. - If you’re relying on one person to cover most of the on-call time, it’s time to take staff development seriously, and pair your on-call expert with someone who needs to gain those skills.
- Rotate holidays and weekends. - The more geographically diverse your team, the less likely you are to run into schedule conflicts.
-### 6. Test It
+### 6. Test it
As your team adjusts to a schedule and process, stage mock incidents to test out the process.
@@ -89,15 +89,15 @@ As your team adjusts to a schedule and process, stage mock incidents to test out
Again if you’re having frequent incidents this may not be necessary, but if every incident isn’t following process, it’s time to practice a dry run!
-### 7. Keep Improving
+### 7. Keep improving
- **Ask the team for feedback** - It’s critical to perform post-mortems, even after successfully handled incidents, ask ‘what could have gone better’ about the on-call process.
- **Continuously update your process** - Ideally your team and your market will be growing throughout each year, so the process that worked last year probably won’t keep working this year.
-## Be Kind
+## Be kind
Being on call can be stressful. Support your team. Say thanks. Help when needed.
-### You Have One Team
+### You have one team
On-call is one of the reasons that people list for leaving teams. Don’t destroy your team while trying to handle incidents, listen to your team members and find a solution that works for you. Spend your energy lifting each other up. A good on-call schedule keeps things running—and people happy.
\ No newline at end of file
diff --git a/learn/incidents/overview.mdx b/learn/incidents/overview.mdx
index 8aaddec1a..45e1448f6 100644
--- a/learn/incidents/overview.mdx
+++ b/learn/incidents/overview.mdx
@@ -1,5 +1,5 @@
---
-title: Incident Response - Improve Recovery & Avoid Downtime
+title: Incident response - Improve recovery & avoid downtime
displayTitle: Learn the fundamentals of Incident Response
description: Master incident response with real-world insights. Learn how to reduce downtime, regain user trust, and build a resilient incident management workflow.
date: 2025-04-07
@@ -15,11 +15,11 @@ We’ve all been there, the 3AM phone call, the bleary-eye scanning of a Slack c
In the last decade as the whole world has grown to accept software-as-a-service, the standards for uptime and responsiveness to issues have increased steadily. While day-long maintenance windows and hours-long outages were par for the course in 2015, now even an outage of a few minutes can affect business health.
Further, expectations about uptime have gone from ‘best practices’ to ‘binding agreements with financial costs for failures,’ with enterprise clients demanding service level agreements (SLAs) with penalty schedules if uptime goals aren’t met.
-## Getting Started
+## Getting started
Incident Response in the software industry refers to a time-critical response to some kind of availability incident.
@@ -32,14 +32,14 @@ Further, expectations about uptime have gone from ‘best practices’ to ‘bin
-## Detect and Resolve Incidents Faster With Playwright
+## Detect and resolve incidents faster with Playwright
-## On the Checkly Blog
+## On the Checkly blog
Learn seven best practices to fight alert fatigue.
@@ -51,7 +51,7 @@ Further, expectations about uptime have gone from ‘best practices’ to ‘bin
Strategies to configure your alerts for team success.
Five best practices to help you deploy your software more securely and reliably.
diff --git a/learn/incidents/playbooks.mdx b/learn/incidents/playbooks.mdx
index f50909aa4..e9b018596 100644
--- a/learn/incidents/playbooks.mdx
+++ b/learn/incidents/playbooks.mdx
@@ -1,7 +1,7 @@
---
-title: Incident Response Playbooks - Culture & Compliance | Checkly
+title: Incident response playbooks - Culture & compliance | Checkly
displayTitle: Incident Response Playbooks
-sidebarTitle: Incident Response Playbooks
+sidebarTitle: Incident response playbooks
description: Master playbooks by setting clear standards, empowering team autonomy, and refining processes when steps are skipped.
date: 2025-04-07
author: Nocnica Mellifera
@@ -15,7 +15,7 @@ canonical: 'https://www.checklyhq.com/docs/learn/incidents/playbooks/'
Incident management is a critical aspect of maintaining system reliability. When engineers are woken up late at night, getting on an incident chat, and trying to fix things while communicating with the team, a huge source of safety and stability is a playbook that describes what to do when. This article serves as a guide for application developers on how to get started writing playbooks for incident response.
-## Team Culture in Incident Response Playbooks
+## Team culture in incident response playbooks
The term ‘playbook’ sometimes implies a sort of mechanical process that tells engineers exactly what to do, a bit like a robot following lines of code. But of course the term is taken from sport, where a playbook lists individual plays that allow for human participants and implicit randomness. Team culture is a clear part of incident response, and you need to consider how real people will interpret plans when faced with real failures and stressful situations. Two early questions are how much standardization of playbooks should happen between teams, and how to handle cases where people don’t follow the process.
@@ -35,7 +35,7 @@ One senior ops engineer talks about the balance between team standardization and
That general truism should apply to your organization: if a team’s individual process for incidents isn’t working, it’ll show up in the number of incidents assigned to the team.
-### What to Do When Someone Doesn’t Follow the Process
+### What to do when someone doesn’t follow the process
People often skip steps when the process feels slow or hard. If this happens, it means something is wrong—maybe the process is confusing, scary, or takes too long. Others might not ask for help because they had a bad experience before or feel rushed.
diff --git a/learn/incidents/postmortems.mdx b/learn/incidents/postmortems.mdx
index a99171661..b8f66e17c 100644
--- a/learn/incidents/postmortems.mdx
+++ b/learn/incidents/postmortems.mdx
@@ -1,7 +1,7 @@
---
-title: Postmortems That Drive Real Improvements (+ Template) | Checkly Guide
+title: Postmortems that drive real improvements (+ template) | Checkly guide
displayTitle: Postmortems That Drive Real Improvement (+ Template)
-sidebarTitle: Postmortems That Drive Real Improvement (+ Template)
+sidebarTitle: Postmortems that drive real improvement (+ template)
description: Postmortems aren’t just documentation exercises. Check out how to properly do one + get a downloadable template.
date: 2025-05-23
author: Sara Miteva
@@ -20,7 +20,7 @@ Postmortems aren’t just documentation exercises. Done well, they’re powerful
In this article, we’ll walk through how to run postmortems that actually make your systems and teams stronger—not just your incident timeline longer.
-## Why Postmortems Matter
+## Why postmortems matter
Incidents are inevitable. What separates high-performing teams is not how rarely they fail—but **how well they learn from failure**.
@@ -33,7 +33,7 @@ A strong postmortem:
Too often, though, postmortems are rushed, overly technical, or just ignored. The result? No follow-through, no learning, no improvement.
-### The Firefighter Trap
+### The firefighter trap
We recently interviewed a senior tech lead who told us about an antipattern called ‘The Firefighter Trap:’
@@ -46,11 +46,11 @@ We recently interviewed a senior tech lead who told us about an antipattern call
It’s great to take a victory lap after an incident is resolved. But you must work to ensure that this problem is handled automatically in the future. Post-mortems, then are a critical step in incident response: Without them you’re likely to find yourself stuck in a loop of responding to incidents without solving their causes.
-## What a Great Postmortem Looks Like
+## What a great postmortem looks like
Here’s the anatomy of a postmortem that actually drives improvement, based on the framework shared in the webinar:
-### 1. **Create a Safe, Blameless Space**
+### 1. **Create a safe, blameless space**
Psychological safety is the foundation. No one should feel like they’re on trial. Focus on systems, not individuals. Use phrases like:
@@ -60,7 +60,7 @@ Psychological safety is the foundation. No one should feel like they’re on tri
If people fear blame, they’ll delay declaring incidents or avoid contributing to future postmortems. Safety enables transparency.
-### 2. **Write a Clear, Honest Timeline**
+### 2. **Write a clear, honest timeline**
Document the incident as it unfolded:
@@ -71,7 +71,7 @@ Document the incident as it unfolded:
Include timestamps, links to check results or traces, and any relevant logs. This isn’t just about storytelling—it’s about understanding time to detect, time to resolve, and where delays happened.
-### 3. **Analyze What Went Wrong—and Why**
+### 3. **Analyze what went wrong—and why**
Was there a monitoring gap? A failed alert? A communication bottleneck? A missing runbook?
@@ -90,7 +90,7 @@ Go beyond symptoms and look at root causes—technical and procedural.
- *Can we monitor this third-party service proactively, e.g., [with an API monitor](https://www.checklyhq.com/learn/monitoring/api-monitoring/)?*
-### 4. **Capture What Went Well**
+### 4. **Capture what went well**
It’s easy to focus on failures, but recognizing **what worked** reinforces good behavior and boosts team morale.
@@ -98,7 +98,7 @@ Did the alert fire correctly? Did someone step up as incident commander? Was cus
Call it out. Celebrate wins—even in chaos.
-### 5. **Define Next Steps With Owners**
+### 5. **Define next steps with owners**
Turn findings into action:
@@ -111,14 +111,14 @@ Each action item should have an **owner** and a **due date**. Otherwise, nothing
💡 *We did a whole webinar on incidents and post-mortems, which you can watch on-demand [here](https://www.checklyhq.com/webinars/incident-management-101-detection-to-communication/).*
-## Steal Our Postmortem Template
+## Steal our postmortem template
If you want a ready-to-use postmortem template you can steal and/or adapt, use ours:
- [Copy the Notion template](https://www.notion.so/Checkly-s-Incident-Postmortem-Template-for-Engineering-Teams-1ecec050b06e805e80b7d714d2a22fb3?pvs=21)
- [Download a Google Doc](https://docs.google.com/document/d/1qdLpwkn-qrF5kJk_Y-EFWHmMTiH6jmlRpQ6YFzOlZCU/edit?tab=t.0)
-## Postmortems Are Not Just for SEV1s
+## Postmortems are not just for SEV1s
Every SEV1 should have a postmortem. But consider doing them for SEV2s too—especially if:
@@ -128,7 +128,7 @@ Every SEV1 should have a postmortem. But consider doing them for SEV2s too—esp
Small incidents are often the warning signs for bigger ones. Don’t miss the learning moment.
-## Final Thoughts
+## Final thoughts
Postmortems aren't just a checkbox at the end of an incident—they're a lever for building resilience, clarity, and trust.
diff --git a/learn/incidents/reduce-mttd.mdx b/learn/incidents/reduce-mttd.mdx
index 1748ad5bd..9ad7bf759 100644
--- a/learn/incidents/reduce-mttd.mdx
+++ b/learn/incidents/reduce-mttd.mdx
@@ -1,7 +1,7 @@
---
-title: Reduce Mean Time to Detection MTTD - Best Practices Guide
+title: Reduce mean time to detection MTTD - Best practices guide
displayTitle: How to Detect Problems Faster
-sidebarTitle: MTTD Best Practices
+sidebarTitle: MTTD best practices
description: Avoid user‑reported outages with synthetic checks, anomaly detection, smart alerting, and rich failure traces for rapid detection.
date: 2025-02-15
author: Nocnica Mellifera
@@ -38,7 +38,7 @@ How do you stop relying on user reports of problems? In general there are three
With its power to find outages before your users do, the rest of this article will focus on the right way to user synthetic monitoring to find outages proactively.
-## Check Frequently
+## Check frequently
Automated tools like [Checkly](https://www.checklyhq.com/) can make sure that every outage is detected quickly and accurately, but if you set the interval between checks too long, you’ll still be relying on users to report some outages. If no checks of your service are running for more than 15 minutes, it’s highly likely that some outages will be discovered by your users before a synthetic monitor can alert you. For more aggressive SLA’s, you may want to [set your check cadence](https://www.checklyhq.com/blog/check-frequency/) to run every minute from at least one location.
@@ -90,6 +90,6 @@ A final point, once again related in part to alert fatigue, is making sure that
*A Checkly trace showing a full debug session for a failed check.*
-## Conclusions: Detect Faster to Fix Faster
+## Conclusions: Detect faster to fix faster
In this article I’ve argued that detection is a critical step in your time to repair, and thereby critical for meeting your SLA. Detection isn’t just about closer monitoring or a faster rate of monitoring. By engineering notifications and alerts to be informative, timely, and targtetted you can improve time to detection without any increased infrastructure cost, and reduced stress for your on-call team!
\ No newline at end of file
diff --git a/learn/incidents/root-cause-with-traces.mdx b/learn/incidents/root-cause-with-traces.mdx
index b94328cf8..09969133e 100644
--- a/learn/incidents/root-cause-with-traces.mdx
+++ b/learn/incidents/root-cause-with-traces.mdx
@@ -1,7 +1,7 @@
---
-title: Root Cause with Traces - Faster RCA | Checkly
+title: Root cause with traces - Faster RCA | Checkly
displayTitle: Tracing for Root Cause Analysis
-sidebarTitle: Tracing for Root Cause Analysis
+sidebarTitle: Tracing for root cause analysis
description: Combine distributed tracing with synthetic checks to pinpoint failures across microservices, preserve request context, and reduce MTTR.
date: 2025-04-06
author: Nocnica Mellifera
@@ -15,7 +15,7 @@ canonical: 'https://www.checklyhq.com/docs/learn/incidents/root-cause-with-trace
Modern applications built with microservices and distributed architectures make root cause analysis (RCA) increasingly complex. When failures occur across dozens of interconnected services, traditional debugging methods fall short. This guide explains how combining distributed tracing with synthetic monitoring creates a powerful approach for faster incident resolution through vastly improved time to understand the root cause of failure.
-## The Challenge of Modern Root Cause Analysis
+## The challenge of modern root cause analysis
One senior operations engineer I spoke to after a webinar mentioned his frustration with root cause analysis in his team:
@@ -36,9 +36,9 @@ All of these types of failures could have happened at a SaaS company ten years a
While we can use tools like synthetic monitoring to know that something isn’t working correctly, it’s become increasingly difficult to remediate failures, much less find the root cause.
-## The Solution: Tracing + Synthetic Checks
+## The solution: Tracing + synthetic checks
-### Distributed Tracing
+### Distributed tracing
Traces provide a complete map of requests as they flow through your system:
@@ -55,7 +55,7 @@ Example trace showing a failed payment process:
```
-### Synthetic Monitoring
+### Synthetic monitoring
Proactively test critical user journeys with:
@@ -69,15 +69,15 @@ When combined, these approaches:
2. **Preserve context** across frontend and backend
3. **Accelerate RCA** with complete request histories
-## Implementation Guide
+## Implementation guide
-### 1. Instrument Your Stack
+### 1. Instrument your stack
- Use synthetic checks for key user flows.
- Add OpenTelemetry for tracing.
- Correlate trace IDs with check results.
-### 2. Build Your Observability Stack
+### 2. Build your observability stack
| Tool Type | Example Tools | Purpose |
| --- | --- | --- |
@@ -85,7 +85,7 @@ When combined, these approaches:
| Synthetic | Checkly, Synthetics | Test user journeys proactively |
| Alerting | Rootly, Opsgenie | Route incidents effectively |
-### 3. Analyze Incidents
+### 3. Analyze incidents
When failures occur:
@@ -96,7 +96,7 @@ When failures occur:
- How long it took to fail
- What dependencies were involved
-## Real-World Example: E-Commerce Checkout Failure
+## Real-world example: E-commerce checkout failure
**Scenario**: Customers report payment failures during peak hours
@@ -117,7 +117,7 @@ When failures occur:
**Result**: MTTR reduced from 47 minutes to 8 minutes
-## Key Benefits
+## Key benefits
1. **Faster Detection**
- Catch issues before users do
@@ -129,7 +129,7 @@ When failures occur:
- Identify weak points in architecture
- Build resilience based on real failure patterns
-## Getting Started
+## Getting started
1. **Start small**: Instrument one critical user journey
2. **Correlate data**: Connect synthetic checks to traces
diff --git a/learn/incidents/slo-sla-sli.mdx b/learn/incidents/slo-sla-sli.mdx
index 17b49e85c..00448d864 100644
--- a/learn/incidents/slo-sla-sli.mdx
+++ b/learn/incidents/slo-sla-sli.mdx
@@ -1,5 +1,5 @@
---
-title: SLA vs SLO vs SLI - What’s the Difference? Comparison with examples
+title: SLA vs SLO vs SLI - What’s the difference? Comparison with examples
displayTitle: SLA vs SLO vs SLI - What’s the Difference?
sidebarTitle: SLA vs SLO vs SLI
description: Avoid user‑reported outages with synthetic checks, anomaly detection, smart alerting, and rich failure traces for rapid detection.
@@ -24,11 +24,11 @@ SLOs, or Service Level Objectives, are the specific goals that service providers
| **Who Builds It?** | A collaborative effort involving service providers and customers, often led by technical teams. | A collaborative effort involving technical teams to set measurable goals within the SLA framework. | Developed by technical teams to measure and monitor specific aspects of service performance. |
| **What Happens if It's Breached?** | Breaching SLA terms may lead to penalties, legal consequences, and reputation damage to the provider. | Breaching SLOs signifies a failure to meet performance goals, triggering corrective actions and potential reevaluation. | SLI breaches indicate deviations in specific performance metrics, requiring investigation and improvement. |
-## What is an SLA (Service Level Agreement)
+## What is an SLA (service level agreement)
At its core, a [Service Level Agreement (SLA)](https://www.techtarget.com/news/service-level-agreement-SLA/847216/) defines the expectations between service providers and customers. Overcoming challenges such as technical intricacies, customer preferences, language clarity, and detailed documentation is key to optimizing SLA effectiveness. By embracing best practices, SLAs become dynamic tools fostering transparency, accountability, and customer satisfaction.
-### SLA Challenges
+### SLA challenges
Hitting your SLAs can bring many challenges that demand a nuanced and strategic approach. Understanding and addressing these challenges is important for the success and effectiveness of SLAs:
@@ -39,7 +39,7 @@ Hitting your SLAs can bring many challenges that demand a nuanced and strategic
- **Monitoring Mechanisms:** Implementing robust mechanisms for [monitoring service level agreements](https://www.checklyhq.com/blog/how-to-monitor-all-the-nines-of-your-service-level-agreements/) is crucial. Regular assessments and timely feedback loops help identify and address deviations, ensuring service levels meet agreed-upon standards consistently.
- **Commitment to Continuous Improvement:** SLAs are not static documents. They are living agreements that demand a commitment to continuous improvement. A proactive approach to refining processes and adapting to changing circumstances is necessary for sustained success.
-### SLA Best Practices
+### SLA best practices
To overcome these challenges and ensure the effectiveness of SLAs, certain best practices should be observed:
@@ -48,7 +48,7 @@ To overcome these challenges and ensure the effectiveness of SLAs, certain best
- **Keep SLAs Simple and Use Clear Language:** Maintaining simplicity in SLAs is a best practice that cannot be overstated. Clear and straightforward language enhances understanding and reduces the risk of misinterpretation.
- **Document Everything:** Comprehensive documentation is crucial for successful SLAs. Documenting all aspects of the agreement ensures transparency. It also provides a reference point for dispute resolution and aids in continuous improvement.
-### Who Needs an SLA?
+### Who needs an SLA?
Understanding who benefits from SLAs is essential for businesses looking to establish effective service standards. In essence, SLAs are beneficial for:
@@ -56,7 +56,7 @@ Understanding who benefits from SLAs is essential for businesses looking to esta
- **Customers:** They have a transparent understanding of the services they can expect.
- **Businesses:** SLAs contribute to accountability, transparency, and customer satisfaction, ultimately impacting the bottom line positively.
-### SLA Examples
+### SLA examples
To illustrate the practical application and importance of effective SLA management, let's explore some real-world examples across various industries:
@@ -66,15 +66,15 @@ To illustrate the practical application and importance of effective SLA manageme
| IT Support | An agreement detailing response times for IT support requests, resolution times based on the severity of issues, and the modes of support available (e.g., phone, email, chat). |
| Telecommunications | SLA for a telecom company can include network availability targets, call quality standards, and maintenance window notifications. |
-## What is an SLO (Service Level Objective)
+## What is an SLO (service level objective)
[Service Level Objectives (SLOs)](https://www.gartner.com/en/information-technology/glossary/slo-service-level-objective) are critical to managing and maintaining reliable and efficient systems. An SLO is a set of quantitative measures that define the level of service a system must deliver. This helps teams align their performance goals with user expectations. SLOs play a pivotal role in ensuring that services meet user needs while allowing organizations to manage their resources effectively.
-### SLO Challenges
+### SLO challenges
Implementing SLOs comes with a set of challenges. Teams often face difficulties in defining precise and meaningful objectives and striking the right balance between aggressiveness and achievability. The challenge lies in creating objectives that align with user expectations while being realistic regarding system capabilities. Additionally, unforeseen contingencies can impact the achievement of SLOs, requiring continuous adaptation and improvement.
-### SLO Best Practices
+### SLO best practices
To overcome challenges associated with SLOs, it is essential to follow best practices that streamline the process and enhance the effectiveness of these objectives:
@@ -83,11 +83,11 @@ To overcome challenges associated with SLOs, it is essential to follow best prac
- **Create SLOs for Internal Systems:** While SLOs are often associated with customer-facing services, internal systems also benefit from performance metrics. Implementing SLOs for internal services ensures that the entire infrastructure operates at optimal levels. This contributes to overall organizational efficiency.
- **Don’t Create More Than Necessary SLOs:** Creating an excessive number of SLOs can be counterproductive. Focus on the most critical aspects of your services and establish a manageable set of objectives. This enables teams to prioritize effectively and dedicate resources where they are most needed.
-### Who Needs an SLO?
+### Who needs an SLO?
The adoption of SLOs is not limited to specific roles or teams. Anyone involved in delivering, managing, or maintaining services can benefit from implementing SLOs. Development teams, operations teams, and leadership play crucial roles in defining and achieving SLOs. SLOs serve as a unifying metric that aligns the efforts of various teams toward a common goal—ensuring a high-quality user experience.
-### SLO Examples
+### SLO examples
To demonstrate how Service Level Objectives (SLOs) set the stage for measuring and achieving service quality, here are examples from various industries.
@@ -97,25 +97,25 @@ To demonstrate how Service Level Objectives (SLOs) set the stage for measuring a
| Online Banking | For an online banking service, an SLO can specify a transaction success rate of 99.5%, ensuring reliability and trust in digital transactions. |
| Cloud Storage | A cloud storage service can have an SLO that guarantees data retrieval times of less than 300 milliseconds for 99% of requests, providing quick access to stored information. |
-## What is an SLI (Service Level Indicator)
+## What is an SLI (service level indicator)
[Service Level Indicators (SLIs)](https://www.techtarget.com/searchcustomerexperience/definition/service-level-indicator) are fundamental components of service level management. They provide measurable metrics to evaluate the performance of a system. SLIs are specific, quantifiable measurements that give insights into various aspects of a service. This enables teams to assess the service’s reliability and effectiveness.
-### SLI Challenges
+### SLI challenges
Implementing SLIs comes with its share of challenges. Defining metrics that accurately represent the user experience can be complex. Teams often struggle with selecting the right indicators that align with user expectations and business goals. Additionally, ensuring that SLIs remain relevant and meaningful over time requires continuous attention and adaptation.
-### SLI Best Practices
+### SLI best practices
Overcoming challenges associated with SLIs involves following best practices that enhance their accuracy and relevance.
- **Create Precise and Measurable SLIs:** SLIs should be crafted with precision, reflecting the specific aspects of a service that matter most to users. Measurable metrics allow for objective evaluation and facilitate data-driven decision-making. Avoid vague or overly broad indicators to ensure the effectiveness of SLIs.
- **Keep SLIs Simple:** Simplicity is key when designing SLIs. Clear and straightforward indicators are easier to understand and communicate across teams. Avoid unnecessary complexity that can lead to confusion and misinterpretation of performance metrics.
-### Who Needs an SLI?
+### Who needs an SLI?
The importance of SLIs extends to various roles within an organization. Anyone involved in the development, deployment, or maintenance of services can benefit from incorporating SLIs into their processes. Development teams use SLIs to monitor the impact of code changes. Operations teams leverage SLIs to ensure system reliability. Leadership relies on SLIs to make informed decisions about resource allocation and strategy.
-### SLI Examples
+### SLI examples
To refine our understanding of service measurement further, let's examine some Service Level Indicators (SLIs) that quantify the performance of services.
@@ -125,45 +125,45 @@ To refine our understanding of service measurement further, let's examine some S
| API Response | In API services, an SLI could be the average response time for API calls, with a target of responding within 500 milliseconds for 95% of the requests. |
| Customer Support Response | For a customer support team, an SLI can track the average response time to customer inquiries, with a goal of responding to 90% of inquiries within 1 hour. |
-## Why are SLAs, SLOs, and SLIs Important?
+## Why are SLAs, SLOs, and SLIs important?
Service Level Agreements (SLAs), Service Level Objectives (SLOs), and Service Level Indicators (SLIs) are integral components of effective service management. Each of them serves a unique purpose in ensuring the delivery of high-quality services. Understanding their importance is paramount for organizations striving to meet user expectations and maintain operational excellence.
-### Ensuring Accountability with SLAs
+### Ensuring accountability with SLAs
SLAs set the foundation for accountability and transparency. These agreements define the expected level of service a customer can anticipate. It also outlines measurable metrics such as response times, uptime, and resolution periods. By clearly defining these expectations, SLAs foster trust between service providers and customers. When complied with, SLAs help organizations demonstrate their commitment to delivering reliable and timely services.
-### Aligning Objectives with SLOs
+### Aligning objectives with SLOs
SLOs bridge the gap between user expectations and system capabilities. These objectives establish quantifiable performance goals. This allows teams to align their efforts with user needs. SLOs serve as a roadmap for maintaining service quality. They help organizations strike a balance between ambitious targets and achievable benchmarks. Establishing SLOs encourages continuous improvement, adaptability, and a proactive approach to managing service levels.
-### Gaining Insights Through SLIs
+### Gaining insights through SLIs
SLIs provide a granular view of service performance. These indicators offer specific, measurable metrics that serve as the building blocks for SLOs. SLIs enable teams to monitor various aspects of service. These range from latency and error rates to user interactions. By regularly evaluating SLIs, organizations gain valuable insights into the real-time health of their services. This process empowers them to make informed decisions, identify areas for improvement, and respond promptly to emerging issues.
-### The Collective Impact
+### The collective impact
When integrated, SLAs, SLOs, and SLIs form a comprehensive framework for service excellence. SLAs provide a contractual foundation, SLOs establish performance objectives, and SLIs offer tangible metrics to measure success. This triad ensures a holistic approach to service management, aligning customer expectations with organizational capabilities.
-## Practical Example: Implementing SLIs, SLOs, and SLAs for APIs
+## Practical example: Implementing SLIs, SLOs, and SLAs for APIs
In the context of managing a customer-facing, business-critical API, it's essential to establish clear standards and expectations to ensure high-quality service. Here, we dive into an example that outlines SLIs, SLOs, and SLAs, using a practical scenario.
-### SLI: Service Level Indicator
+### SLI: Service level indicator
The SLI acts as a measure of the performance and reliability of the API. In this case, the SLI is defined by the API's ability to respond successfully with HTTP status codes ranging from 200 to 499, coupled with a response time of under one second. This metric is crucial because it quantifies the operational performance of the API from a technical standpoint, focusing on availability and speed.
-### SLO: Service Level Objective
+### SLO: Service level objective
Building on the SLI, the SLO sets a target for the level of service the API aims to deliver. For our API, the objective is that the SLI conditions (response codes within 200-499 and response times below one second) are met for the 99th percentile of all requests. This means that out of 100 requests, at least 99 should satisfy these criteria. The SLO is a commitment to maintaining a high standard of service, ensuring that nearly all requests are handled efficiently and effectively.
-### SLA: Service Level Agreement
+### SLA: Service level agreement
The SLA transforms the SLO into a formal agreement with the customer. It guarantees that the service will achieve the SLO targets for a specified period, in this case, a quarter. The SLA also outlines the compensation customers will receive if the service fails to meet these expectations. This compensation could take various forms, such as financial credits, discounts, or other remedies. The SLA is a crucial part of customer contracts, providing a legal framework that ensures accountability and offers reassurance to customers about the reliability of the service.
By setting these SLIs, SLOs, and SLAs, the company not only commits to delivering a high-quality API service but also provides transparency and trust to its customers. This framework helps manage expectations, foster customer satisfaction, and drive continuous improvement in service performance.
-## **How Checkly Can Help You Hit Your SLAs**
+## **How Checkly can help you hit your SLAs**
[Checkly](https://www.checklyhq.com/) focuses on Synthetic Monitoring to track how well websites, applications, and APIs work. Its goal is to help [meet Service Level Agreements (SLAs)](https://www.checklyhq.com/blog/how-to-monitor-all-the-nines-of-your-service-level-agreements/) with customers with its features such as API checks, Browser checks, heartbeat monitoring, etc.
@@ -202,7 +202,7 @@ Checkly’s Browser checks can help you achieve your SLAs through:
*To find out more about Checkly’s Browser checks & how to get started, check out [this article](/detect/synthetic-monitoring/browser-checks/overview).*
-### **Checkly Best Practices**
+### **Checkly best practices**
If you’re using Checkly, here are some best practices that will help you make sure you’re doing everything you can to adhere to your SLAs.
@@ -214,7 +214,7 @@ If you’re using Checkly, here are some best practices that will help you make

-### **Integrating Into Your Existing Workflow**
+### **Integrating into your existing workflow**
Checkly enables you to monitor your SLAs by allowing you to monitor services closely and check how they perform worldwide in over 20 locations. You get instant alerts when there's any issue, helping you react quickly to fix it. The platform keeps an eye on services all the time and adjusts to new needs or changes.
diff --git a/learn/incidents/what-is-incident-response.mdx b/learn/incidents/what-is-incident-response.mdx
index 765dcd01a..0117c42d0 100644
--- a/learn/incidents/what-is-incident-response.mdx
+++ b/learn/incidents/what-is-incident-response.mdx
@@ -1,7 +1,7 @@
---
-title: What is Incident Response? Fundamentals and best practices
+title: What is incident response? Fundamentals and best practices
displayTitle: What is Incident Response?
-sidebarTitle: What is Incident Response?
+sidebarTitle: What is incident response?
description: Learn the key types and stages of incident response—outages, performance issues, security events, user‑reported problems—and keep your services resilient.
date: 2025-02-15
author: Nocnica Mellifera
@@ -14,7 +14,7 @@ canonical: 'https://www.checklyhq.com/docs/learn/incidents/what-is-incident-resp
---
"Incident Response" in the software industry refers to a time-critical response to some kind of availability incident. The terms are a bit vague since, although many incidents are also outages, not every incident is an outage of a service where it's unavailable to users. Whenever we need to gather one or more engineers to work outside of their scheduled work hours to handle a problem with our service, it's an incident. This intro page lists common incident categories, and the stages of incident response.
-### Types of Incidents
+### Types of incidents
Understanding the different types of incidents is key to managing them well. Here are the main types:
@@ -25,7 +25,7 @@ Understanding the different types of incidents is key to managing them well. Her
By knowing these types, teams can handle each one in the best way. This helps keep services running smoothly and keeps customers happy.
-### Stages of Incident Response
+### Stages of incident response
The incident response process helps teams handle problems quickly and effectively. As noted in the list, some stages may not happen in this order; for example the incident may be closed and reviewed with a root cause resolution not being deployed until later. Here are the key stages:
@@ -42,7 +42,7 @@ The incident response process helps teams handle problems quickly and effectivel
By following these stages, teams can handle incidents efficiently, reduce downtime, and keep services running smoothly.
-## Best Practices of incident response
+## Best practices of incident response
Each of the stages of incident response has associated best practices:
diff --git a/learn/kubernetes/centralized-logging.mdx b/learn/kubernetes/centralized-logging.mdx
index 8f3f01440..3df2314f7 100644
--- a/learn/kubernetes/centralized-logging.mdx
+++ b/learn/kubernetes/centralized-logging.mdx
@@ -1,7 +1,7 @@
---
title: Centralized logging in Kubernetes with OpenTelemetry - guide with examples
displayTitle: Centralized logging in Kubernetes with OpenTelemetry
-sidebarTitle: Centralized Logging
+sidebarTitle: Centralized logging
description: Monitoring logs effectively in a Kubernetes environment requires tools that centralize and streamline log management.
date: 2024-11-08
author: Nocnica Mellifera
@@ -13,19 +13,19 @@ canonical: 'https://www.checklyhq.com/docs/learn/kubernetes/centralized-logging/
---
Monitoring logs effectively in a Kubernetes environment requires tools that centralize and streamline log management. With OpenTelemetry, Kubernetes administrators can collect, process, and export logs from applications and infrastructure, ensuring consistent data and reducing the need for multiple, disparate logging solutions. Here’s an overview of how OpenTelemetry supports centralized logging in Kubernetes and the practical benefits it offers.
-### Why Centralized Logging Matters in Kubernetes
+### Why centralized logging matters in Kubernetes
Logs provide critical insights into application performance, errors, and security events. In a Kubernetes setup, workloads are distributed across many nodes, making it essential to have a centralized logging solution to collect logs in one place. Centralized logging enables teams to efficiently manage logs from across the entire Kubernetes cluster and prevents loss of logs during pod restarts or node replacements.
The OpenTelemetry project, initially created to address distributed tracing, has expanded to include metrics and now, comprehensive logging support. With its recent logging capabilities, OpenTelemetry provides a unified framework for collecting and correlating logs alongside traces and metrics, ensuring consistency and reliability.
-### Key Components of OpenTelemetry for Centralized Logging
+### Key components of OpenTelemetry for centralized logging
1. **OpenTelemetry Collector**: The [OpenTelemetry Collector](/learn/opentelemetry/what-is-the-otel-collector/) is at the heart of centralized logging with OpenTelemetry. It’s a standalone agent that can be deployed on Kubernetes nodes, Windows, or Linux hosts, and it’s capable of collecting logs from multiple sources. In Kubernetes, the collector can capture logs, system metrics (such as CPU and memory usage), and metrics from third-party applications.
2. **Instrumentation Libraries**: OpenTelemetry includes libraries and SDKs for popular programming languages, which can add logging capabilities directly to application code. By using OpenTelemetry’s appenders, developers can export logs in OpenTelemetry’s native format, simplifying log management and reducing the overhead typically required for parsing and reshaping logs.
3. **Data Model and Semantic Conventions**: OpenTelemetry introduces a standardized data model and semantic conventions, ensuring that logs have consistent metadata and structure across the entire system. This is critical for efficient querying and analysis, as it eliminates the need for complex parsing and filtering.
-### Benefits of Using OpenTelemetry for Centralized Logging
+### Benefits of using OpenTelemetry for centralized logging
OpenTelemetry’s approach to centralized logging addresses some common challenges in log management:
@@ -33,7 +33,7 @@ OpenTelemetry’s approach to centralized logging addresses some common challeng
- **Performance Optimization**: By processing logs directly in OpenTelemetry’s format, the collector minimizes CPU and memory usage associated with parsing and reshaping logs. Logs from OpenTelemetry-enabled applications can be sent directly to the collector without intermediary processing steps, saving resources.
- **Correlation Across Data Types**: OpenTelemetry simplifies correlating logs, traces, and metrics. This correlation provides a holistic view of application performance, helping teams diagnose and resolve issues quickly. For instance, logs from a failed request can be directly linked to corresponding trace data, helping teams identify the root cause faster.
-### How the OpenTelemetry Collector Works in Kubernetes
+### How the OpenTelemetry Collector works in Kubernetes
The OpenTelemetry Collector can be deployed as a DaemonSet in a Kubernetes cluster, running as an agent on each node. This setup allows the collector to:
@@ -43,7 +43,7 @@ The OpenTelemetry Collector can be deployed as a DaemonSet in a Kubernetes clust
The collector includes built-in parsers and transformation capabilities to handle logs in various formats, such as JSON or text. This flexibility is especially useful in Kubernetes environments where logs from different applications and services may not share a standard format. For more detail on deployment options for the collector, [see our guide to collector architecture](/learn/opentelemetry/what-is-the-otel-collector/).
-### Implementing Centralized Logging with OpenTelemetry in Kubernetes
+### Implementing centralized logging with OpenTelemetry in Kubernetes
Here’s how to set up centralized logging in Kubernetes with OpenTelemetry:
@@ -52,7 +52,7 @@ Here’s how to set up centralized logging in Kubernetes with OpenTelemetry:
3. **Define Transformations and Exports**: Use OpenTelemetry’s processing capabilities to normalize logs, add metadata, and apply semantic conventions. After processing, configure the collector to export logs to a centralized logging backend or a cloud-based logging service.
4. **Correlate Logs with Traces and Metrics**: The collector can correlate logs, traces, and metrics by applying consistent metadata and sampling rules. For instance, if you’re sampling traces at a certain rate, the collector can apply the same sampling rate to logs, ensuring that traces and logs remain aligned.
-### Advantages of OpenTelemetry Logging in Kubernetes
+### Advantages of OpenTelemetry logging in Kubernetes
By adopting [OpenTelemetry for centralized logging](https://www.checklyhq.com/learn/opentelemetry/logs/), Kubernetes administrators gain several benefits:
diff --git a/learn/kubernetes/events.mdx b/learn/kubernetes/events.mdx
index 3cb0ff67e..a99be625f 100644
--- a/learn/kubernetes/events.mdx
+++ b/learn/kubernetes/events.mdx
@@ -1,5 +1,5 @@
---
-title: Kubernetes Events - A Native Resource for State Insight
+title: Kubernetes events - A native resource for state insight
displayTitle: Kubernetes Events
sidebarTitle: Events
description: In Kubernetes, **Events** are a native resource, providing insight into actions and state changes of objects in the cluster. Events are platform-generated messages accessible through the Kubernetes API, often used by operators and users to understand what has happened to various Kubernetes objects.
@@ -20,7 +20,7 @@ Events serve as valuable resources for monitoring and debugging, allowing users
---
-## Event Mechanics
+## Event mechanics
Kubernetes Events can be accessed by querying the Kubernetes API. Each Event describes an action related to a Kubernetes object, such as a Pod, Deployment, or Node. These Events are often labeled with the following attributes:
- **Type**: Indicates whether the Event is `Normal` (standard actions) or `Warning` (indicating potential issues).
@@ -31,7 +31,7 @@ Kubernetes Events can be accessed by querying the Kubernetes API. Each Event des
---
-### Example: Viewing Events for a Pod
+### Example: Viewing events for a pod
To see Events associated with a specific Pod, use the `kubectl describe` command. Here’s an example output for a Pod named `webapp-5d8dbbd4bb-2lqfs`:
@@ -52,7 +52,7 @@ Warning BackOff 40s kubelet, ip-10-0-1-233 Back-off restartin
In this output, each Event shows a timestamp and message about actions related to the Pod, from scheduling to a restart back-off warning.
-### Example: Viewing Events for a Namespace
+### Example: Viewing events for a namespace
To retrieve Events for all resources in a namespace, you can use the `kubectl get events` command:
@@ -71,11 +71,11 @@ LAST SEEN TYPE REASON OBJECT MESSAGE
This output shows Events from the namespace, covering various resources, such as Pods, ReplicaSets, and Deployments, with some Events indicating a container restart issue for further investigation.
---
-## Monitoring and Alerting with Events
+## Monitoring and alerting with events
Events provide real-time insights, allowing operators to monitor Kubernetes activity. Although not commonly used for direct automation, some approaches leverage Events for alerting and monitoring:
-### Event Exporters
+### Event exporters
An **Event exporter** can expose Events as metrics to external monitoring systems. For example, Prometheus can scrape metrics derived from Events, enabling alerting based on conditions like frequent container restarts or persistent failures in Pod scheduling.
diff --git a/learn/kubernetes/klog.mdx b/learn/kubernetes/klog.mdx
index c45e7f24d..345fa956e 100644
--- a/learn/kubernetes/klog.mdx
+++ b/learn/kubernetes/klog.mdx
@@ -1,5 +1,5 @@
---
-title: Introducing klog - The Kubernetes Logging Library
+title: Introducing klog - The Kubernetes logging library
displayTitle: klog for structured logging
sidebarTitle: klog
description: Meet klog, the Kubernetes-specific logging library designed to provide structured and reliable logging across Kubernetes components. In this post, we’ll dive into klog’s purpose, key features, and how it’s transforming logging in Kubernetes.
@@ -20,7 +20,7 @@ klog is the logging library used within Kubernetes to manage logs across its var
Starting with Kubernetes v1.19, klog adopted structured logging to make log entries easier to parse, search, and analyze. This change enables administrators to move away from unstructured plain text logs, which often require custom parsing and lead to inconsistencies across components. Structured logs also allow for better integration with logging tools like Elasticsearch, Fluent Bit, and Grafana, making it easier to monitor, alert, and troubleshoot.
-### Why klog Matters for Kubernetes Logging
+### Why klog matters for Kubernetes logging
In Kubernetes, logs are generated by numerous components, each responsible for specific functions. For example:
@@ -30,7 +30,7 @@ In Kubernetes, logs are generated by numerous components, each responsible for s
Managing these logs without a consistent format can quickly become overwhelming. klog solves this issue by providing a structured approach to logging, allowing log aggregation and analysis tools to work more effectively. By adopting structured logging, Kubernetes improves observability, making logs easier to query and analyze.
-### Key Features of klog
+### Key features of klog
1. **Structured Logging with Key-Value Pairs**:
klog enables structured logging by supporting key-value pairs, allowing log entries to be machine-readable and easily parsable. This structure simplifies log queries, as logs with consistent fields can be filtered and aggregated efficiently.
@@ -41,17 +41,17 @@ klog provides new methods (`InfoS` and `ErrorS`) for logging informational and e
4. **Seamless Integration with Kubernetes Components**:
klog is embedded in the core of Kubernetes, meaning it’s natively supported by key system components. This allows for out-of-the-box structured logging across all critical areas of a Kubernetes cluster.
-### klog vs. Glog: Why the Shift?
+### klog vs. Glog: Why the shift?
Kubernetes previously relied on `glog`, but as the system grew, the limitations of `glog` became apparent. Glog’s lack of structured logging meant that logs were generated as plain text, making them hard to parse and analyze. With structured logging increasingly becoming the standard in observability, Kubernetes needed a library that could support a consistent format across components. klog, with its JSON support and key-value pair structure, was developed to meet these needs.
Structured logging also allows Kubernetes to integrate more easily with third-party monitoring tools, as JSON logs are more compatible with Elasticsearch, Grafana, Prometheus, and other tools that rely on consistent data formatting.
-### Key klog Methods: `InfoS` and `ErrorS`
+### Key klog methods: `InfoS` and `ErrorS`
To facilitate structured logging, klog introduced the `InfoS` and `ErrorS` methods. These methods replace traditional logging functions by enforcing a structured, key-value format.
-### 1. **InfoS**: Log Informational Messages
+### 1. **InfoS**: Log informational messages
The `InfoS` method captures general information in a structured format. This method requires a message followed by key-value pairs, where each key represents a field, and the associated value provides context.
@@ -62,7 +62,7 @@ klog.InfoS("Pod status updated", "pod", "kube-dns", "status", "ready")
This example logs an informational message, specifying the pod name (`kube-dns`) and its current status (`ready`).
-### 2. **ErrorS**: Log Error Messages
+### 2. **ErrorS**: Log error messages
The `ErrorS` method is used for error logging. It requires an error as the first parameter, followed by a descriptive message and key-value pairs that provide context for the error.
@@ -73,7 +73,7 @@ klog.ErrorS(err, "Failed to update pod status", "pod", "kube-dns")
In this example, `ErrorS` logs an error with a detailed message and relevant pod information. This structure makes it easier to track down issues within specific pods or components.
-### Example: JSON Output with klog
+### Example: JSON output with klog
klog’s structured approach outputs logs in JSON format, making it easier to parse and analyze. Here’s what a typical JSON log entry might look like when generated by klog:
@@ -91,27 +91,27 @@ klog’s structured approach outputs logs in JSON format, making it easier to pa
Each log entry contains key-value pairs for essential information like timestamp, log level, message, pod name, and status, making it easy for log management tools to filter and analyze the data.
-### Benefits of Structured Logging with klog
+### Benefits of structured logging with klog
1. **Improved Observability**: Structured logging makes it easier to monitor Kubernetes environments by providing consistent, easily searchable logs.
2. **Efficient Log Analysis**: By outputting logs in JSON, klog supports efficient parsing and querying, which is essential when working with large volumes of data.
3. **Enhanced Integration**: JSON logs integrate seamlessly with observability tools, allowing Kubernetes administrators to visualize and analyze logs more effectively.
4. **Reduced Parsing Complexity**: Structured logs eliminate the need for custom parsing, as log fields are consistent across entries, enabling more straightforward log processing.
-### Best Practices for Using klog in Kubernetes
+### Best practices for using klog in Kubernetes
1. **Use Key-Value Pairs Consistently**: Define standard fields for commonly logged events to keep logs consistent across components. For instance, use `"pod"`, `"namespace"`, and `"status"` consistently in pod-related logs.
2. **Set Log Levels Appropriately**: Use log levels (`InfoS` for informational logs and `ErrorS` for errors) to differentiate critical information from general updates. This ensures that logs are meaningful and that critical events are easy to identify.
3. **Monitor Log Performance**: Structured logging can add overhead, so monitor klog’s impact on performance, particularly in high-traffic clusters.
4. **Integrate with Log Management Tools**: klog is compatible with log management systems that support JSON, so integrate it with tools like Fluent Bit, Prometheus, and Grafana to visualize and analyze logs effectively.
-### Implementing klog in Your Kubernetes Environment
+### Implementing klog in your Kubernetes environment
To enable structured logging with klog, Kubernetes administrators can configure components to use `InfoS` and `ErrorS` methods and output JSON-formatted logs. This setup standardizes logs, improving the efficiency of log aggregation and analysis pipelines.
For a fully integrated solution, combine klog with logging agents like Fluent Bit or Fluentd. These agents can collect logs from across the Kubernetes cluster, parse them, and forward them to centralized storage or monitoring systems.
-### Future of klog and Structured Logging in Kubernetes
+### Future of klog and structured logging in Kubernetes
The move toward structured logging reflects a larger industry trend towards improving observability across distributed systems. With features like contextual logging and enhanced compatibility with monitoring tools, klog will continue to improve the reliability and manageability of Kubernetes logging.
diff --git a/learn/kubernetes/logging-best-practices.mdx b/learn/kubernetes/logging-best-practices.mdx
index eebd92d4d..fd3b87878 100644
--- a/learn/kubernetes/logging-best-practices.mdx
+++ b/learn/kubernetes/logging-best-practices.mdx
@@ -1,7 +1,7 @@
---
-title: Logging in Kubernetes - Best Practices
+title: Logging in Kubernetes - Best practices
displayTitle: Logging in Kubernetes - Best Practices
-sidebarTitle: Best Practices
+sidebarTitle: Best practices
description: Monitoring logs effectively in a Kubernetes environment requires tools that centralize and streamline log management.
date: 2024-11-08
author: Nocnica Mellifera
@@ -13,17 +13,17 @@ canonical: 'https://www.checklyhq.com/docs/learn/kubernetes/logging-best-practic
---
Logging in Kubernetes can be a challenge, especially when dealing with data across a distributed, containerized system. To keep your logs efficient and actionable, it's essential to understand logging best practices, from handling diverse formats to managing back pressure effectively. Here are the best practices for Kubernetes logging, focused on tools, performance, and scalability.
-### 1. Define Your Logging Goals
+### 1. Define your logging goals
The main goal of logging isn’t just to collect data—it’s to analyze it and gain insights into your system's health and performance. Collecting excess logs can create noise, so start by defining clear goals. Consider which data is essential for troubleshooting, compliance, and performance monitoring, and focus on collecting only that information. This targeted approach helps reduce unnecessary log volume and keeps analysis efficient.
-### 2. Centralize and Standardize Logging
+### 2. Centralize and standardize logging
Kubernetes applications can produce logs in various formats and locations. Some applications write to standard output, while others log to specific files. In addition, different applications, such as NGINX, syslog, or even Windows services, may log in entirely different formats. Use a centralized logging system to consolidate all logs into a single view.
A common tool for this purpose is **Fluent Bit**, which is lightweight, supports various inputs and outputs, and has a plugin system that allows it to integrate with numerous backends. Fluent Bit’s flexibility makes it a solid choice for aggregating logs from multiple sources and delivering them in a standardized format, such as JSON.
-### 3. Structure Your Logs
+### 3. Structure your logs
Unstructured logs (raw text logs) can be difficult to parse and analyze, especially at scale. Structuring logs, ideally in a key-value format, makes it easier to query and process them. Consider using structured logging formats like JSON to provide clear, consistent fields (e.g., timestamp, log level, message). Fluent Bit can handle log parsing and transformation to convert unstructured logs into a structured format.
@@ -41,11 +41,11 @@ For example, rather than storing a plain log message, structure it to include re
```
-### 4. Enrich Logs with Contextual Information
+### 4. Enrich logs with contextual information
In distributed systems, it’s often hard to pinpoint where an issue occurred based on logs alone. Enrich your logs with additional metadata, such as the Kubernetes namespace, pod name, and container ID. This metadata provides valuable context that makes debugging easier. Fluent Bit can automatically add Kubernetes metadata to logs, providing instant visibility into which parts of the system are generating specific logs.
-### 5. Filter and Reduce Log Volume
+### 5. Filter and reduce log volume
Logging everything can quickly lead to storage and performance issues, especially with high log volumes. It’s essential to filter out non-critical logs, such as verbose debug logs, to reduce unnecessary data. Implement filters to retain only the logs you need, based on severity (e.g., only errors and warnings in production environments).
@@ -59,7 +59,7 @@ In Fluent Bit, you can apply filters to drop debug-level logs in production. For
```
-### 6. Handle Sensitive Data Securely
+### 6. Handle sensitive data securely
Logs can sometimes contain sensitive information, such as user IDs or payment data. To prevent exposing sensitive data, redact or mask it in logs. Fluent Bit supports redaction and can modify logs to obscure sensitive data before it’s stored or transmitted.
@@ -73,13 +73,13 @@ Example: Use the `modify` filter's `Set` rule to overwrite a sensitive field, su
```
-### 7. Use Logs-to-Metrics Conversion
+### 7. Use logs-to-metrics conversion
Some logs contain high-frequency, repetitive events that might be more useful as metrics rather than logs. Converting these logs into metrics can improve performance and reduce storage needs. For instance, tracking the number of failed authentication attempts is often more efficient as a metric.
Fluent Bit can convert log entries to metrics, which can then be visualized and analyzed in tools like Prometheus. This approach reduces storage costs and enhances visibility for events that are better tracked over time.
-### 8. Manage Back Pressure and Buffering
+### 8. Manage back pressure and buffering
In high-throughput environments, the risk of back pressure increases, especially when logs are sent to remote endpoints with limited processing capacity. Fluent Bit provides buffering options, including in-memory and file-based buffers, to handle spikes in log traffic. Using a file-based buffer is generally more reliable for production, as it prevents data loss if in-memory buffers are exhausted.
@@ -103,13 +103,13 @@ Configure Fluent Bit with file-based buffering for resilience:
```
-### 9. Monitor Log Pipeline Health
+### 9. Monitor log pipeline health
Once your logging infrastructure is in place, monitor its health to ensure consistent performance. Metrics like input and output rates, dropped logs, and processing latency can reveal bottlenecks and prevent data loss.
You can use Prometheus to monitor Fluent Bit’s internal metrics and set up alerts for issues like increased log drop rates or high memory usage. Regular monitoring helps you catch problems early and ensures that your logging pipeline remains effective.
-### 10. Plan for Scale
+### 10. Plan for scale
Kubernetes clusters grow over time, so it’s essential to design your logging solution to scale with your application. Ensure your log storage backend can handle increased volumes, and consider using Fluent Bit’s load-balancing capabilities if you have multiple log destinations.
diff --git a/learn/kubernetes/monitoring-challenges.mdx b/learn/kubernetes/monitoring-challenges.mdx
index e032944bf..c0e02b063 100644
--- a/learn/kubernetes/monitoring-challenges.mdx
+++ b/learn/kubernetes/monitoring-challenges.mdx
@@ -1,5 +1,5 @@
---
-title: Learn How to Observe and Monitor your Kubernetes Environment with Open Source Tools
+title: Learn how to observe and monitor your Kubernetes environment with open source tools
displayTitle: The Challenge of Monitoring Production Kubernetes - Insights and Tools
sidebarTitle: Monitoring Kubernetes
description: Managing Kubernetes in production is no small feat, especially when it comes to monitoring and observability.
@@ -13,39 +13,39 @@ canonical: 'https://www.checklyhq.com/docs/learn/kubernetes/monitoring-challenge
---
Managing Kubernetes in production is no small feat, especially when it comes to monitoring and observability. As modern applications grow in complexity, traditional methods of monitoring, limited to CPU and memory usage, often fall short. In this article, we explore the unique challenges of monitoring Kubernetes environments and the open-source tools that can improve visibility and control.
-### The Layers of Complexity in Kubernetes
+### The layers of complexity in Kubernetes
Starting with Kubernetes can be straightforward—deploying a service, setting up replicas, and configuring basic settings. But as deployment scales, the complexity grows significantly. Organizations must manage stateful services, custom resource definitions (CRDs), networking, and more, which are essential to production-grade Kubernetes. Even experienced administrators can find these layers challenging, especially as each layer adds new demands and potential points of failure.
To aid with this complexity, the Cloud Native Computing Foundation (CNCF) offers a trail map of projects suited to various aspects of Kubernetes management, from containerization to continuous integration, service discovery, and, importantly, observability.
-### The Core of Observability: Logs, Metrics, and Traces
+### The core of observability: Logs, metrics, and traces
Observability in Kubernetes focuses on three pillars: logs, metrics, and traces. Each plays a distinct role in providing a clear picture of an application’s health and performance.
-### 1. Centralized Logging
+### 1. Centralized logging
In dynamic, cloud-native environments, centralized logging is essential. Logs help trace what happened in each instance, and they provide necessary details for compliance, especially in regulated industries like finance, which often require logs to be retained for years.
With centralized logging, administrators avoid the pitfalls of ephemeral logging. For example, if Kubernetes nodes are updated or workloads shift, logs can disappear. Tools like Loki, an open-source log aggregation tool, enable centralized logging by collecting logs across services and making them accessible in tools like Grafana. This setup ensures that logs are available from a central point, reducing the need to search individual nodes or pods.
-### 2. Metrics Collection
+### 2. Metrics collection
Metrics provide a big-picture view of resource consumption and application health over time. Unlike logs, which capture individual events, metrics are aggregated and are ideal for spotting trends, such as CPU or memory usage spikes, that indicate resource needs or scaling requirements.
Prometheus is a widely used tool in Kubernetes environments for metrics collection. Combined with Grafana, which provides visualization, administrators can access real-time dashboards that show cluster CPU usage, memory utilization, and other metrics. These insights are invaluable in optimizing resources and setting up auto-scaling rules to adjust to application demand.
-### 3. Distributed Tracing
+### 3. Distributed tracing
With microservices architectures, distributed tracing is crucial. It tracks the journey of requests across services, helping identify bottlenecks and pinpointing where failures occur. This is particularly helpful in production, where diagnosing issues quickly is critical to maintaining uptime.
Jaeger, a distributed tracing tool, integrates with OpenTelemetry to capture trace data across microservices, making it possible to follow a request’s entire journey and spot where time is spent or where errors occur. This visibility is essential for optimizing performance and understanding how services interact.
-### OpenTelemetry: A Standardized Approach
+### OpenTelemetry: A standardized approach
OpenTelemetry is a vendor-neutral standard that simplifies observability by consolidating data from multiple sources. It offers a single framework for instrumenting code, collecting, and exporting logs, metrics, and traces, reducing the need to install multiple agents or integrate separate SDKs. OpenTelemetry allows switching backends without major reconfiguration, avoiding vendor lock-in.
-### Challenges in Kubernetes Observability
+### Challenges in Kubernetes observability
Monitoring Kubernetes comes with its own set of challenges:
@@ -53,7 +53,7 @@ Monitoring Kubernetes comes with its own set of challenges:
- **Vendor Lock-In**: Proprietary monitoring tools can lead to lock-in. Open-source and standards-based tools like OpenTelemetry and Grafana help avoid this.
- **High Setup Overheads**: While the ecosystem offers many observability tools, setting them up and maintaining them can be complex.
-### Tools to Consider
+### Tools to consider
Here are a few recommended tools for Kubernetes observability:
diff --git a/learn/kubernetes/node-problem-detector.mdx b/learn/kubernetes/node-problem-detector.mdx
index d96efa2f0..575ae4480 100644
--- a/learn/kubernetes/node-problem-detector.mdx
+++ b/learn/kubernetes/node-problem-detector.mdx
@@ -14,23 +14,23 @@ canonical: 'https://www.checklyhq.com/docs/learn/kubernetes/node-problem-detecto
The **Node Problem Detector (NPD)** is a Kubernetes tool for monitoring the health of nodes. Designed to identify and report a range of node issues, NPD aims to maintain cluster stability by detecting faulty nodes and reporting them to the Kubernetes API server, so that other components can keep workloads off potentially unstable environments. NPD's purpose is to make sure workloads only run on healthy nodes, minimizing disruptions from faulty node behavior.
-### How Node Problem Detector Works
+### How Node Problem Detector works
Node Problem Detector operates by running as a DaemonSet on each node in the Kubernetes cluster. It monitors system logs and checks for specific conditions or failures that could compromise the node's stability. Once NPD detects an issue, it reports it to the API server as a node condition or an event. NPD does not cordon the node itself. A separate remedy system, such as the [Descheduler](https://github.com/kubernetes-sigs/descheduler), Cluster API's MachineHealthCheck or your cloud provider's node auto-repair, can act on these conditions and mark the node as "unschedulable" so the scheduler excludes it.
-### Remediation and Challenges
+### Remediation and challenges
While NPD does identify and isolate nodes with issues, automatically remediating these problems can be more challenging. Some of the common issues, like a read-only root filesystem, may point to deeper hardware faults or configurations that may need manual intervention. NPD's role is limited to problem detection; it doesn’t solve the underlying issues, which often require hardware fixes or support from system constructors, especially in physical environments.
In virtualized environments, such as on cloud-managed Kubernetes clusters, nodes flagged by NPD can often be drained and replaced. This is common in platforms like Azure Kubernetes Service (AKS), where a failing node can be terminated, and a new one created by the autoscaler. However, simply replacing nodes might not address the underlying cause, especially if it stems from node misconfiguration or application-related issues.
-### Use Cases and Limitations
+### Use cases and limitations
NPD's effectiveness shines in physical clusters where hardware inconsistencies can cause unexpected issues. Having NPD exclude problematic nodes prevents further complications and can be a stopgap until the hardware can be inspected or replaced. In virtual environments, NPD's role can sometimes be limited, as issues tend to arise more from configuration or workload setup, both of which should ideally be resolved in staging before hitting production.
In summary, Node Problem Detector acts as a health monitoring and early-warning system, isolating problematic nodes to protect workload stability. It’s especially valuable in detecting issues in physical nodes where hardware problems may be more common. However, for automated remediation in virtual clusters, the approach is usually to replace the node entirely, although this doesn’t address root causes directly.
-## How to Enable the Node Problem Detector
+## How to enable the Node Problem Detector
To enable **Node Problem Detector (NPD)** on your Kubernetes cluster, follow these steps to deploy and configure it as a DaemonSet. This deployment will ensure that NPD runs on each node, actively monitoring for issues and reporting them as node conditions and events.
@@ -44,7 +44,7 @@ kubectl apply -f https://k8s.io/examples/debug/node-problem-detector.yaml
This command downloads and applies a predefined DaemonSet configuration for NPD, ensuring it runs on each node in your cluster. The configuration file contains necessary setup for resource limits, logging, and permissions needed by NPD to function properly.
-### 2. Verify the Deployment
+### 2. Verify the deployment
After deploying the DaemonSet, confirm that NPD is running on each node:
@@ -54,7 +54,7 @@ kubectl get daemonset -n kube-system node-problem-detector
This command checks the status of the NPD DaemonSet in the `kube-system` namespace, where it’s typically deployed. Look for the `DESIRED`, `CURRENT`, and `AVAILABLE` fields to confirm that the DaemonSet is running on all nodes as expected.
-### 3. Check Node Problem Detector Logs
+### 3. Check Node Problem Detector logs
To see what issues NPD is detecting, check its logs. This can be useful for troubleshooting or confirming that NPD is actively monitoring node health:
@@ -64,7 +64,7 @@ kubectl logs -l k8s-app=node-problem-detector -n kube-system
This command fetches logs from all pods in the NPD DaemonSet, allowing you to review any node issues that NPD has detected.
-### 4. Configure Node Problem Detector (Optional)
+### 4. Configure Node Problem Detector (optional)
The default configuration may not cover all specific needs of your cluster. For example, you can customize what types of problems NPD detects by modifying the configuration file or using custom plugins. To edit NPD’s configuration, download the DaemonSet YAML file, make necessary changes, and reapply it:
@@ -74,7 +74,7 @@ kubectl apply -f /path/to/your-modified-node-problem-detector.yaml
Refer to the official [Node Problem Detector documentation](https://github.com/kubernetes/node-problem-detector) for available configuration options and plugins. Customizing NPD lets you tailor detection parameters to your environment, making it more effective in identifying relevant node issues.
-### 5. Confirm NPD’s Functionality
+### 5. Confirm NPD’s functionality
To ensure NPD is operating correctly, simulate a node condition or trigger an event that it should detect. Verify that the node shows the new condition (for example with `kubectl describe node`) or that an appropriate event is logged when NPD reports the condition.
diff --git a/learn/kubernetes/operators-metrics.mdx b/learn/kubernetes/operators-metrics.mdx
index 35a865b6f..0073c81ba 100644
--- a/learn/kubernetes/operators-metrics.mdx
+++ b/learn/kubernetes/operators-metrics.mdx
@@ -1,5 +1,5 @@
---
-title: Introduction to Kubernetes Operators - scraping metrics with Prometheus
+title: Introduction to Kubernetes operators - scraping metrics with Prometheus
displayTitle:
sidebarTitle: Operators
description: Operators in Kubernetes enable custom automation by encapsulating specific operational knowledge within Kubernetes itself. They function as custom controllers that manage complex applications and provide features like automated deployment, scaling, and management.
@@ -20,7 +20,7 @@ With operators, you can manage resources beyond the built-in types like Pods and
Kubebuilder is a development framework for building Kubernetes operators using the Go programming language. It provides project scaffolding, resource definitions, and controller logic to simplify operator creation. In short, Kubebuilder allows developers to create CRDs (Custom Resource Definitions) and controllers, which watch Kubernetes resources and act upon changes.
-#### Setting Up a Project with Kubebuilder
+#### Setting up a project with Kubebuilder
The typical process starts by setting up a basic project structure using the `kubebuilder init` command. This scaffolds the folders and files necessary for an operator project. The following commands initialize a project and create a custom API for a simple application:
@@ -31,7 +31,7 @@ kubebuilder create api --group app --version v1 --kind WebApp
This creates a project structure that includes an API definition for `WebApp`, a custom resource that will deploy and manage a Kubernetes Deployment and Service.
-#### Adding Metrics to the Operator
+#### Adding metrics to the operator
For observability, we can integrate Prometheus metrics into the operator. In Kubernetes, Prometheus can scrape data from custom endpoints to provide insights into application behavior. By using the `prometheus.NewCounter` method from the Prometheus Go client, we set up counters to track resource actions, such as the creation and deletion of `WebApp` instances.
@@ -59,7 +59,7 @@ func init() {
Each time the reconciliation loop (the main loop of the controller) handles a creation or update event, the counter increments.
-#### Deploying Prometheus to Scrape Metrics
+#### Deploying Prometheus to scrape metrics
You must configure Prometheus to scrape the operator’s metrics endpoint. Recent Kubebuilder scaffolds serve metrics over HTTPS on port `8443` and require authentication. The example below assumes plain HTTP on port `8080`, which you get by starting the manager with `--metrics-bind-address=:8080 --metrics-secure=false`. To achieve this, add a scrape configuration to the Prometheus setup, pointing to the operator service endpoint:
@@ -74,7 +74,7 @@ scrape_configs:
With Prometheus deployed, the operator exposes metrics under the `/metrics` path, which Prometheus regularly scrapes to collect data.
-#### Running the Operator and Observing Metrics
+#### Running the operator and observing metrics
After deploying the operator to a Kubernetes cluster (e.g., a local KIND cluster), we can create custom `WebApp` resources that initiate deployments. By applying YAML files with the custom `WebApp` definitions, developers can observe metrics that Prometheus scrapes and view them in a dashboard like Grafana.
diff --git a/learn/kubernetes/overview.mdx b/learn/kubernetes/overview.mdx
index 6c3afbb28..1f4a70524 100644
--- a/learn/kubernetes/overview.mdx
+++ b/learn/kubernetes/overview.mdx
@@ -1,5 +1,5 @@
---
-title: Learn How to Observe and Monitor your Kubernetes
+title: Learn how to observe and monitor your Kubernetes
displayTitle: Monitoring Kubernetes
sidebarTitle: Overview
description: Learn OpenTelemetry with Checkly. Add monitoring to every piece of your stack with the open standards and open-source tools.
@@ -12,7 +12,7 @@ canonical: 'https://www.checklyhq.com/docs/learn/kubernetes/overview/'
Learn about monitoring Kubernetes.
-## Getting Started
+## Getting started
-## Diving Deeper
+## Diving deeper
diff --git a/learn/monitoring/frontend-monitoring.mdx b/learn/monitoring/frontend-monitoring.mdx
index 210e2311b..99246b22a 100644
--- a/learn/monitoring/frontend-monitoring.mdx
+++ b/learn/monitoring/frontend-monitoring.mdx
@@ -1,7 +1,7 @@
---
-title: Frontend Monitoring - Benefits, Challenges, and Top Tools
+title: Frontend monitoring - Benefits, challenges, and top tools
displayTitle: Frontend Monitoring - a beginner's guide
-sidebarTitle: Frontend Monitoring
+sidebarTitle: Frontend monitoring
description: Discover the benefits, challenges, and top tools for frontend monitoring. Learn how to track performance, detect issues, and optimize user experience.
date: 2024-12-15
author: Nocnica Mellifera
@@ -26,14 +26,14 @@ Frontend monitoring ensures seamless user experiences by observing and analyzing
In this article, we’ll cover the basics of frontend monitoring, explore its various types, key metrics, benefits, and challenges, and review some top tools to help you manage and optimize your applications effectively.
-## What is Frontend Monitoring?
+## What is frontend monitoring?
Frontend monitoring involves tracking and analyzing the performance, reliability, and user experience of web applications from the user’s perspective. Frontend monitoring can either occur by observing users real interactions on the frontend (real user monitoring) or by sending an automated system to interact with your frontend (synthetic user monitoring).
It helps teams identify issues like slow page load times, JavaScript errors, or failed API calls that can negatively impact user satisfaction.
-## Types of Frontend Monitoring
+## Types of frontend monitoring
**Proactive Monitoring**
@@ -81,13 +81,13 @@ APM is a general term, usually referring to a combined solution that includes bo
---
-## How Frontend Monitoring Works
+## How frontend monitoring works
Frontend monitoring tools capture data through a combination of synthetic tests, browser instrumentation, and real user interactions. These tools generate insights by analyzing performance metrics, logging errors, and tracking user behavior.
---
-## Key Components of Frontend Application Monitoring
+## Key components of frontend application monitoring
- **Performance Metrics**: Monitor loading speeds, [rendering times, and resource usage](https://www.checklyhq.com/learn/playwright/performance/#performance-with-headless-tools).
- **Error Detection**: Identify JavaScript errors, API failures, and crashes. Crash reporting can be a complex problem but it’s great if it’s possible to report some details from user browser crashes.
@@ -95,7 +95,7 @@ Frontend monitoring tools capture data through a combination of synthetic tests,
---
-## Key Metrics in Frontend Monitoring
+## Key metrics in frontend monitoring
The key metrics for frontend monitoring—*performance*, *user interactions*, *errors*, and *availability*—are crucial for understanding and optimizing the user experience. **Performance** metrics, including page load time and Core Web Vitals (e.g., Largest Contentful Paint, Interaction to Next Paint), measure how fast and smoothly content is delivered to users. **User interactions** capture events like clicks, form submissions, and navigations to gauge how users engage with the application. **Errors** track JavaScript exceptions, resource failures, and API issues, helping teams identify and resolve defects impacting functionality. **Availability** monitors uptime and service reachability to ensure the application is consistently accessible. Together, these metrics provide a comprehensive view of application health, enabling teams to improve performance, address issues proactively, and enhance the overall user experience.
@@ -110,7 +110,7 @@ Key metrics in detail:
---
-## Common Use Cases of Frontend Monitoring
+## Common use cases of frontend monitoring
- **Monitoring Page Load Times**: [Ensure optimal page rendering speed](/detect/synthetic-monitoring/browser-checks/performance-metrics#total-blocking-time-tbt).
- **Tracking Third-Party Services**: No amount of pre-deploy testing with stubs of third party services can find all the possible interaction problems with those services. Frontend monitoring can detect issues caused by external libraries or APIs.
@@ -119,7 +119,7 @@ Key metrics in detail:
---
-## Benefits of Frontend Monitoring
+## Benefits of frontend monitoring
**Proactive Issue Detection**
@@ -139,7 +139,7 @@ By identifying specific areas that require attention, monitoring data enables te
---
-## Challenges of Frontend Monitoring
+## Challenges of frontend monitoring
**Managing Tool Sprawl and Integration Issues**
@@ -176,7 +176,7 @@ Frontend monitoring alone cannot provide a complete view of an application’s h
---
-## How to Choose the Right Frontend Monitoring Tool
+## How to choose the right frontend monitoring tool
Consider features like synthetic monitoring, RUM, session replay, language compatibility, and security. Evaluate pricing, ease of use, and whether an agent or agentless setup fits your needs.
@@ -184,7 +184,7 @@ Consider features like synthetic monitoring, RUM, session replay, language compa
Frontend monitoring has historically lagged behind backend systems in sophistication and integration. With OpenTelemetry (OTel), frontend monitoring can now achieve deeper insights into user experiences. However, it also brings unique challenges that require careful consideration.
-## Challenges in Using OpenTelemetry for Frontend Monitoring**
+## Challenges in using OpenTelemetry for frontend monitoring**
**1. Initial Complexity of Setup**
@@ -215,7 +215,7 @@ Traditional frontend monitoring tools often report *what* is happening (e.g., a
OpenTelemetry opens a new frontier for frontend observability, but it’s not a plug-and-play solution. Teams must balance instrumentation depth with performance and focus on collecting the data that best illuminates user experiences. By addressing these challenges head-on, developers can achieve a robust, connected view of their systems and elevate the standard of frontend monitoring.
-## Developing a Frontend Monitoring Strategy: A Step-by-Step Guide
+## Developing a frontend monitoring strategy: A step-by-step guide
1. **Identify Key Metrics**: Focus on what matters most to your application.
2. **Select Tools**: Choose tools that integrate with your tech stack.
@@ -224,7 +224,7 @@ OpenTelemetry opens a new frontier for frontend observability, but it’s not a
---
-## How Can Checkly Help with Frontend Monitoring?
+## How can Checkly help with frontend monitoring?
Checkly performs synthetic monitoring with the power of Playwright for robust testing of key workflows. By simulating real-world scenarios, it ensures applications remain functional and performant under varying conditions.
diff --git a/learn/monitoring/https-for-app-developers.mdx b/learn/monitoring/https-for-app-developers.mdx
index edf59ef78..da32458b4 100644
--- a/learn/monitoring/https-for-app-developers.mdx
+++ b/learn/monitoring/https-for-app-developers.mdx
@@ -1,5 +1,5 @@
---
-title: HTTPS Fundamentals - Beginner's Guide for App Developers
+title: HTTPS fundamentals - Beginner's guide for app developers
displayTitle: Intro to HTTPS
sidebarTitle: Intro to HTTPS
description: Let’s break down what HTTPS is, why it matters, and how to use it in your apps.
@@ -25,7 +25,7 @@ HTTPS stands for **HyperText Transfer Protocol Secure**. It’s the secure versi
---
-### Why Use HTTPS?
+### Why use HTTPS?
1. **Protects Data**: HTTPS encrypts data like passwords, credit card numbers, and messages. HTTPS is crucial on insecure networks (like public Wi-Fi) to prevent data tampering or theft. I
2. **Builds Trust**: Users see a padlock icon in their browser when your app uses HTTPS. This tells them your app is safe.
@@ -34,7 +34,7 @@ HTTPS stands for **HyperText Transfer Protocol Secure**. It’s the secure versi
---
-### How HTTPS Works
+### How HTTPS works
HTTPS uses two main tools to secure data:
@@ -49,7 +49,7 @@ To enhance security, developers should use HTTP Strict Transport Security (HSTS)
---
-### How to Add HTTPS to Your App
+### How to add HTTPS to your app
1. **Get an SSL/TLS Certificate**:
- You can buy one from a Certificate Authority (CA) or get a free one from services like Let’s Encrypt.
@@ -64,7 +64,7 @@ To enhance security, developers should use HTTP Strict Transport Security (HSTS)
---
-### Common Mistakes to Avoid
+### Common mistakes to avoid
- **Mixed Content**: Don’t mix HTTP and HTTPS. For example, if your app uses HTTPS but loads images over HTTP, it can break the security.
- **Expired Certificates**: Always renew your certificates on time.
diff --git a/learn/monitoring/intro-to-sdlc.mdx b/learn/monitoring/intro-to-sdlc.mdx
index 085506fff..0c2d5559a 100644
--- a/learn/monitoring/intro-to-sdlc.mdx
+++ b/learn/monitoring/intro-to-sdlc.mdx
@@ -1,5 +1,5 @@
---
-title: Understanding the Software Development Life Cycle (SDLC) for Engineers
+title: Understanding the software development life cycle (SDLC) for engineers
displayTitle: Understanding the Software Development Life Cycle (SDLC)
sidebarTitle: Understanding the SDLC
description: With fast-paced standards for development and operations; where Agile, DevOps, and continuous delivery dominate—understanding SDLC remains crucial.
@@ -46,7 +46,7 @@ The SDLC typically consists of several key phases:
*The traditional testing pyramid, inspired by Martin Fowler’s version*
-## **The Changing Landscape of Testing in the SDLC**
+## **The changing landscape of testing in the SDLC**
The traditional **Testing Pyramid** (favoring many unit tests over fewer UI tests) as a support of the SDLC is being questioned. Challenges include:
diff --git a/learn/monitoring/metrics-every-team-needs.mdx b/learn/monitoring/metrics-every-team-needs.mdx
index 9720ba794..472808e25 100644
--- a/learn/monitoring/metrics-every-team-needs.mdx
+++ b/learn/monitoring/metrics-every-team-needs.mdx
@@ -1,7 +1,7 @@
---
-title: Observability Basics - Metrics that every team needs
+title: Observability basics - Metrics that every team needs
displayTitle: Metrics Every Team Needs
-sidebarTitle: Metrics Every Team Needs
+sidebarTitle: Metrics every team needs
description: This article will help define the metrics that every team needs to get tracking of their system’s performance
date: 2025-04-15
author: Nocnica Mellifera
@@ -57,7 +57,7 @@ Of the metrics in this article, response time can be the most difficult to measu
Finally, when viewing response times **it’s critical not to just use simple averages to capture performance**. Special statistical slices like ‘percent of responses over threshold’ (how often did a user get an unacceptably slow response) and ‘95th percentile response times’ (including all but the very slowest responses, which are often outliers caused by special requests that are predictably quite slow) is critical to get an accurate picture of performance over time.
-## Infrastructure Metrics
+## Infrastructure metrics
You should always be able to see a small group of metrics that shows the health of your infrastructure. This article doesn’t give a single answer for these infrastructure metrics due to evolution of how we host applications, and what things stress us out now. In the old days of bare metal servers, infrastructure health was usually covered by looking at available memory and CPU usage. But if a team using mainly serverless computation on a public cloud, those numbers would be both meaningless and ephemeral, and of bigger concern is a metric showing how much is being spent to handle all customer requests. Some possible examples of key infrastructure metrics:
@@ -71,7 +71,7 @@ These metrics are still critical for any operations or on-call team, and are esp
The best practices for infrastructure management could fill a whole book, but at the very highest level the most critical skill for monitoring infrastructure is to **perform deep, blameless postmortems any time you have an outage that was user-reported**. Outages reported by users are failures that your current observability tools can’t detect. By asking ‘what did we miss’ you’ll begin to identify what needs to be measured better, and surfaced better for your engineers, from your infrastructure.
-## Error Rate
+## Error rate
Error rate is a critical APM metric that quantifies the frequency of failed requests or transactions within an application, expressed as a percentage of total requests. It captures HTTP errors (e.g., 4xx client errors, 5xx server errors), timeouts, exceptions, and can cover business logic failures (e.g., payment declines, API call failures). This metric is often segmented by endpoint, service, or dependency to pinpoint failure hotspots. A high or rising error rate may indicate code defects, infrastructure instability (e.g., database overload), or third-party service degradation. Engineering teams use error rate alongside logs and distributed tracing to diagnose root causes. In SLOs (Service Level Objectives), error rate thresholds (e.g., <0.1%) help enforce reliability targets. Proactive monitoring and alerting on error rate spikes enable faster [incident response](https://www.checklyhq.com/learn/incidents/what-is-incident-response/), reducing MTTR (Mean Time to Repair) and minimizing user impact.
@@ -107,7 +107,7 @@ This kind of response, with a `200 OK` status and an error in the body, may not
For all of these four key metrics, I can think of examples where only one of them will be ‘off’ during a certain type of failure. Therefore all four are the table stakes to monitoring a production application.
-## **Conclusions: The Sturdy Table of Your Application**
+## **Conclusions: The sturdy table of your application**
Effective observability begins with tracking **four foundational metrics**: **Throughput**, **Response Time**, **Infrastructure Health**, and **Error Rate**. Each of these metrics provides a unique lens into system performance, and missing any one of them can leave critical blind spots in your monitoring strategy.
@@ -116,7 +116,7 @@ Effective observability begins with tracking **four foundational metrics**: **Th
- **Infrastructure Metrics** ensure the underlying systems are healthy and cost-efficient.
- **Error Rate** exposes *how often* things are failing—even when failures are silent.
-### **Key Takeaways**
+### **Key takeaways**
1. **No Single Metric Tells the Whole Story**
2. **Define Metrics Clearly and Consistently**
@@ -133,7 +133,7 @@ Effective observability begins with tracking **four foundational metrics**: **Th
- Even "soft" errors (like payment declines) should be tracked if they impact UX.
- Beware of **false-success responses** (HTTP 200s with error messages).
-### **Final Thought: Start Small, Then Expand**
+### **Final thought: Start small, then expand**
While advanced observability (heatmaps, business intelligence, etc.) is valuable, these four metrics form the minimum viable dashboard every team should monitor. Once they’re stable, you can layer on deeper insights—but without them, you’re flying blind.
diff --git a/learn/monitoring/monitoring-as-code.mdx b/learn/monitoring/monitoring-as-code.mdx
index aaf93884d..ff7a1f6af 100644
--- a/learn/monitoring/monitoring-as-code.mdx
+++ b/learn/monitoring/monitoring-as-code.mdx
@@ -1,5 +1,5 @@
---
-title: Monitoring as Code - A Practical Guide from Checkly
+title: Monitoring as Code - A practical guide from Checkly
displayTitle: What is monitoring as code?
description: >-
Learn how to implement monitoring as code with Checkly's guide. Bring transparency, scalability, and efficiency to your cloud infrastructure management.
@@ -23,7 +23,7 @@ Monitoring as Code (MaC) addresses these pain points by automating and integrati
Let’s explore MaC, its benefits, and how you can use it to level up your monitoring.
-## What Is Monitoring as Code?
+## What is Monitoring as Code?
Monitoring as Code involves defining monitoring configurations and operations as code, enabling automated setups, real-time observability across DevOps lifecycles, and seamless integration with development workflows.
@@ -49,7 +49,7 @@ Operations teams have traditionally owned monitoring tools within organizations
Traditional synthetic monitoring tools work at the surface level of an application, unable to give detailed explanations of the root cause of the alert.
-### Growing Costs
+### Growing costs
Whenever we discuss the ideal setup for synthetic monitoring, experienced DevOps and SRE engineers will respond: "Sure, that would be great, if we had the budget for it." While it would be nice to simulate a complex user behavior every 30 seconds from 5 different geographic regions, the cost of most synthetic tools makes that cost-prohibitive.
@@ -57,7 +57,7 @@ Whenever we discuss the ideal setup for synthetic monitoring, experienced DevOps
Here are the most important benefits of adopting Monitoring as Code:
-### **Codified & Programmable**
+### **Codified & programmable**
Monitoring as Code transforms your monitoring setup into code that is stored, managed, and versioned alongside your application code. This approach brings significant advantages over traditional monitoring tools:
@@ -69,7 +69,7 @@ With MaC, your monitoring evolves alongside your codebase, enabling precision, f

-### **Reusability Enforces Consistency**
+### **Reusability enforces consistency**
Reusability in Monitoring as Code (MaC) goes beyond efficiency—it ensures consistent, reliable, and scalable monitoring across environments and teams. By reusing existing assets like Playwright tests and API definitions, MaC streamlines setup and eliminates redundancy.
@@ -80,7 +80,7 @@ Reusability in Monitoring as Code (MaC) goes beyond efficiency—it ensures cons
By reusing existing assets and creating modular configurations, MaC ensures monitoring is efficient, consistent, and adaptable to changing needs.
-### **Increased Collaboration**
+### **Increased collaboration**
MaC breaks down silos by embedding monitoring into the development lifecycle, fostering collaboration across teams:
@@ -90,31 +90,31 @@ MaC breaks down silos by embedding monitoring into the development lifecycle, fo
By embedding collaboration into the monitoring process, MaC drives alignment, reduces friction, and creates a culture of shared accountability.
-## Monitoring as Code Use Cases
+## Monitoring as Code use cases
-### **Continuous Monitoring Throughout the SDLC**
+### **Continuous monitoring throughout the SDLC**
To maintain high-quality deployments, monitoring should span every stage of the Software Development Life Cycle (SDLC)—from local development to staging and production. Monitoring as Code (MaC) integrates directly into CI/CD pipelines, enabling automatic and consistent observability across environments. This ensures that issues are detected and addressed before they reach production, significantly reducing downtime and errors.
For instance, commercetools, a leader in headless commerce, [adopted MaC](https://www.checklyhq.com/case-study/commercetools/) to implement continuous monitoring throughout their SDLC. By codifying their monitoring setup, they ensured every stage of their pipeline was equipped with accurate, automated checks. This approach caught issues early in development, reduced production incidents, and provided end-to-end visibility into their systems without adding extra operational overhead.
-### **Automating Monitoring for Rapidly Changing Systems**
+### **Automating monitoring for rapidly changing systems**
Monitoring APIs and UIs in fast-paced environments is a complex challenge, especially when new endpoints are constantly being added or updated. Traditional approaches often involve manually setting up and maintaining checks, which is time-consuming and prone to errors. As systems scale, gaps in monitoring coverage or misconfigured alerts can lead to missed issues and delayed responses, impacting the reliability of your services. Monitoring as Code solves this by automating the creation and deployment of monitoring configurations, ensuring every API is consistently and comprehensively monitored from staging to production. By integrating monitoring into your development pipelines, you can keep up with rapid changes without sacrificing reliability.
For example, TrueLayer, a leading open banking platform, [adopted Monitoring as Code to address these challenges](https://www.checklyhq.com/case-study/truelayer/). By codifying their API monitoring configurations and automating their setup with Checkly, they reduced manual effort by 60%. This allowed their team to scale monitoring as they introduced new endpoints, ensuring complete coverage and faster issue detection, all while focusing more on innovation rather than operational tasks.
-### **Enhancing Monitoring Ownership Across Teams**
+### **Enhancing monitoring ownership across teams**
In large organizations, monitoring is often centralized under SRE teams, creating bottlenecks and slowing down response times. This approach limits the ability of engineering teams to adapt and manage monitoring for their own services. Monitoring as Code (MaC) decentralizes this process, empowering teams to define and control their monitoring setups directly within their workflows. This fosters greater accountability and enables faster detection and resolution of issues.
[LinkedIn leveraged MaC](https://www.checklyhq.com/case-study/modernizing-linkedins-monitoring-infrastructure/) to transition from an SRE-managed model to one where engineering teams took full ownership of their monitoring. Using Checkly, they streamlined the process, allowing teams to tailor monitoring configurations to their specific needs. This shift reduced time to detection, improved system reliability, and gave teams the autonomy to innovate without relying on a central authority.
-## What Can You Monitor Using Monitoring as Code?
+## What can you monitor using Monitoring as Code?
Monitoring as Code (MaC) enables you to test key aspects of your application and infrastructure with precision and automation. Here are some of the areas where it excels:
-### Application Uptime
+### Application uptime
Application uptime reflects how reliably your application is available to users, and even a few minutes of downtime can lead to user frustration, loss of revenue, and damage to your reputation.
@@ -122,7 +122,7 @@ MaC allows you to define uptime checks programmatically, ensuring these checks a
MaC also simplifies scaling uptime monitoring across multiple regions. By deploying checks from different geographic locations, you can ensure your application is accessible worldwide and identify regional connectivity issues. Additionally, codified monitoring enables you to keep pace with application changes—new services and endpoints are automatically incorporated into your monitoring setup, reducing the risk of missed coverage.
-### **UI Functionality**
+### **UI functionality**
MaC allows you to simulate and test user interactions with your web application. For example, you can create Browser checks to validate critical workflows like logging in, completing a checkout, or performing a search.
@@ -148,7 +148,7 @@ test('Login to Checkly', async ({ page }) => { // 2
```
-### **API Health**
+### **API health**
APIs power modern applications, and MaC ensures their availability, performance, and correctness. You can automate checks to validate response status codes, measure latency, and verify payloads.
@@ -199,7 +199,7 @@ new ApiCheck('update-inventory-item', {
```
-### Application Performance
+### Application performance
Slow app load times or high latency can drive users away and impact revenue. Monitoring as Code provides a streamlined way to track performance metrics like page load times, API response times, and latency, ensuring your application consistently meets expectations.
@@ -209,7 +209,7 @@ MaC also excels at monitoring deployments by running performance checks automati
MaC makes it easy to monitor performance across regions, simulating user experiences in different locations. This helps identify latency caused by network issues, server configurations, or CDNs, ensuring fast, consistent performance worldwide. By codifying performance monitoring, MaC standardizes and automates the process, allowing your team to maintain a responsive, reliable web app at scale.
-### **Scheduled Jobs or Cron Jobs**
+### **Scheduled jobs or cron jobs**
Scheduled jobs or cron jobs are crucial for automating tasks, but failures can lead to major problems if undetected. MaC enables [heartbeat monitoring](https://www.checklyhq.com/blog/heartbeat-monitoring-with-checkly/) to ensure these jobs run on schedule.
@@ -217,7 +217,7 @@ A Heartbeat monitor verifies that a job reports back within the expected timefra
This proactive approach ensures your critical automation workflows are reliable and resilient.
-### **Infrastructure Reliability**
+### **Infrastructure reliability**
MaC also tests the health and reliability of your infrastructure. This includes uptime monitoring for servers, latency checks for databases, and validating metrics like CPU or memory usage.
@@ -227,7 +227,7 @@ By codifying these checks, you create an automated system that detects potential
Monitoring as Code (MaC) with Checkly empowers you to streamline, automate, and scale your monitoring strategy by leveraging advanced tools and integrations. With native Playwright support, Terraform and Pulumi integrations, and seamless CI/CD pipeline compatibility, Checkly simplifies complex monitoring setups and enables dynamic, code-driven observability.
-### **CI/CD Pipeline Integration**
+### **CI/CD pipeline integration**
Checkly’s compatibility with CI/CD pipelines ensures monitoring is embedded into your development workflow. You can configure performance, uptime, and functional checks to run automatically during deployments, catching issues early and maintaining system reliability. This tight integration helps teams:
@@ -235,13 +235,13 @@ Checkly’s compatibility with CI/CD pipelines ensures monitoring is embedded in
- Monitor deployments in real-time to detect regressions or failures.
- Streamline troubleshooting by aligning monitoring data with code changes.
-### Native Playwright Support
+### Native Playwright support
With native Playwright support, Checkly enables you to directly use existing Playwright scripts as Browser checks. This integration allows you to monitor complex user workflows—such as logins, form submissions, or multi-step transactions—without needing to rewrite tests.
Your monitoring aligns with your application logic, offering precise, actionable insights into the user experience.
-### **Alert Management via Code**
+### **Alert management via code**
A strong alerting strategy ensures critical issues are addressed promptly while minimizing noise for your team. With Checkly, you can configure alerting integrations like [PagerDuty](/integrations/incident-management/pagerduty) or [Opsgenie](/integrations/incident-management/opsgenie) directly in your codebase. This approach allows you to:
@@ -258,7 +258,7 @@ A strong alerting strategy ensures critical issues are addressed promptly while
- Share consistent, reliable dashboards across teams or environments.
- Communicate app and API availability to your customers.
-### **Performance Benchmarking**
+### **Performance benchmarking**
Performance benchmarking helps you understand your application’s limits and track improvements over time. MaC allows you to automate performance tests and benchmark configurations, ensuring consistent measurement across deployments. You can:
@@ -268,7 +268,7 @@ Performance benchmarking helps you understand your application’s limits and tr
Codified benchmarks keep your team aligned and make it easier to identify potential bottlenecks before they impact users.
-### **Incident Postmortems and Continuous Improvement**
+### **Incident postmortems and continuous improvement**
Postmortems are crucial for learning from incidents, and MaC ensures these lessons are integrated directly into your monitoring setup. After identifying root causes, you can:
@@ -278,7 +278,7 @@ Postmortems are crucial for learning from incidents, and MaC ensures these lesso
This approach turns every incident into an opportunity for growth, building resilience into your application with each iteration.
-### **Regional or Multi-Environment Testing**
+### **Regional or multi-environment testing**
Modern applications often run across multiple regions or environments, and ensuring consistent performance everywhere is a major challenge. MaC allows you to:
@@ -288,7 +288,7 @@ Modern applications often run across multiple regions or environments, and ensur
This granular, automated approach ensures your application delivers a seamless experience to users regardless of their location or environment.
-### **Infrastructure as Code (IaC) Support**
+### **Infrastructure as Code (IaC) support**
Checkly integrates seamlessly with popular IaC tools like Terraform and Pulumi. This means you can define monitoring configurations alongside your infrastructure code, ensuring monitoring setups are automatically deployed with your infrastructure updates. These integrations enable:
@@ -296,7 +296,7 @@ Checkly integrates seamlessly with popular IaC tools like Terraform and Pulumi.
- Simplified updates to monitors as your infrastructure evolves.
- Centralized version control, ensuring your monitoring is always aligned with your application and infrastructure.
-## Best Practices for Monitoring as Code
+## Best practices for Monitoring as Code
Implementing monitoring as code effectively requires following best practices to ensure reliability, scalability, and maintainability.
diff --git a/learn/monitoring/overview.mdx b/learn/monitoring/overview.mdx
index ca1489215..8bdf66fd1 100644
--- a/learn/monitoring/overview.mdx
+++ b/learn/monitoring/overview.mdx
@@ -1,5 +1,5 @@
---
-title: Monitoring Resources - Tools, Metrics & Best Practices
+title: Monitoring resources - Tools, metrics & best practices
sidebarTitle: Monitoring
description: Browse essential monitoring resources from Checkly. Learn key metrics, performance tools, and best practices to optimize your systems and user experience.
date: 2024-10-17
@@ -10,7 +10,7 @@ canonical: 'https://www.checklyhq.com/docs/learn/monitoring/overview/'
---
Monitoring your production services is a key part of a good user experience. Traditional stopgaps like 'pingers' or simply waiting for user reported issues are insufficient. These guides are an introduction to the basic concepts of monitoring.
-## Getting Started
+## Getting started
How does software get made? Breaking down the basic phases of software development.
@@ -32,36 +32,36 @@ Monitoring your production services is a key part of a good user experience. Tra
Learn all about web application monitoring, performance and reliability and discover top tools.
Discover the benefits and top tools for frontend monitoring. Track performance and optimize user experience.
-## On the Checkly Blog
+## On the Checkly blog
Learn seven best practices to fight alert fatigue.
Traditional monitoring has become insufficient for managing complex systems.
Five best practices to help you deploy your software more securely and reliably.
diff --git a/learn/monitoring/real-user-monitoring.mdx b/learn/monitoring/real-user-monitoring.mdx
index 577ce0a04..f51e3ece4 100644
--- a/learn/monitoring/real-user-monitoring.mdx
+++ b/learn/monitoring/real-user-monitoring.mdx
@@ -1,7 +1,7 @@
---
-title: Real User Monitoring (RUM) - Benefits, Challenges, and Alternatives
+title: Real user monitoring (RUM) - Benefits, challenges, and alternatives
displayTitle: Real User Monitoring (RUM) - A Practical Guide
-sidebarTitle: Real User Monitoring
+sidebarTitle: Real user monitoring
description: Discover the benefits, challenges, and top tools for frontend monitoring. Learn how to track performance, detect issues, and optimize user experience.
date: 2024-12-15
author: Nocnica Mellifera
@@ -14,11 +14,11 @@ weight: 50
canonical: 'https://www.checklyhq.com/docs/learn/monitoring/real-user-monitoring/'
---
-## **Why Real User Monitoring Matters**
+## **Why real user monitoring matters**
Real User Monitoring (RUM) gives you actual performance data from real people using your website or app. Unlike synthetic tests (which simulate users), RUM shows you exactly what your customers experience—the promise is that if even one of your users encounters an error, you’ll know about it.
-### **Key Benefits:**
+### **Key benefits:**
- **Pinpoint Performance Issues** – Discover which pages load slowly or behave poorly on specific devices (e.g., mobile vs. desktop).
- **Reduce User Frustration** – Catch errors before they drive users away.
@@ -30,9 +30,9 @@ Real User Monitoring (RUM) gives you actual performance data from real people us
If checkout pages take 8 seconds to load on mobile, but only 2 seconds on desktop, RUM helps you find and fix the bottleneck. RUM monitoring shows exactly which users are encountering slow load times, and you can look at historical trends to see if a recent change may have been the cause.
-## **How RUM Works: From Data to Insights**
+## **How RUM works: From data to insights**
-### **1. Data Collection (The "What")**
+### **1. Data collection (the "What")**
A lightweight JavaScript snippet (or mobile SDK) tracks:
@@ -43,12 +43,12 @@ A lightweight JavaScript snippet (or mobile SDK) tracks:
All of this data is collected, generally as a trace with annotations for events and errors, for tramsission by the lightweight RUM code.
-### **2. Data Transmission (The "How")**
+### **2. Data transmission (the "How")**
- Data is sent to a monitoring backend
- **Sampling** (optional) reduces cost by sending only a % of sessions.
-### **3. Analysis & Action (The "Why")**
+### **3. Analysis & action (the "Why")**
- **Dashboards** show performance trends (e.g., "Mobile users in Europe are 40% slower").
- **Alerts** notify you when error rates spike.
@@ -60,13 +60,13 @@ Start with core metrics (load time, error rate), then expand to track business g
---
-## **Sampling & Storage: Balancing Cost and Detail**
+## **Sampling & storage: Balancing cost and detail**
-### **The Data Fire Hose Problem**
+### **The data fire hose problem**
RUM generates **massive** amounts of data. If you track every click, scroll, and page load for millions of users, costs can spiral. Storing RUM data isn’t just expensive for your storage solutions, it also means incredibly slow queries for trying to see historical performance.
-### **Solution: Tiered Storage (Like a "Data Lake")**
+### **Solution: Tiered storage (like a "Data Lake")**
1. **Raw Bucket** – Store *everything* (for rare deep dives).
- Example: Keep 100% of data for 7 days, then archive.
diff --git a/learn/monitoring/synthetic-monitoring.mdx b/learn/monitoring/synthetic-monitoring.mdx
index fbd227b25..a46c7e95f 100644
--- a/learn/monitoring/synthetic-monitoring.mdx
+++ b/learn/monitoring/synthetic-monitoring.mdx
@@ -1,7 +1,7 @@
---
-title: Synthetic Monitoring - Concepts, Benefits & Challenges
+title: Synthetic monitoring - Concepts, benefits & challenges
displayTitle: What is Synthetic Monitoring?
-sidebarTitle: Synthetic Monitoring
+sidebarTitle: Synthetic monitoring
description: Explore the what and why of synthetic monitoring.
date: 2025-04-15
author: Nocnica Mellifera
@@ -18,7 +18,7 @@ Synthetic monitoring enables software teams to better understand the performance
Just as automated testing is essential for high-velocity development teams, enabling them to catch bugs and defects by simulating real user flows in testing and preview environments, synthetic monitoring enables teams to continuously monitor for optimal user experiences. Some synthetic monitoring tools, like Checkly, allow engineers to reuse entire end-to-end tests as production monitors. This enables true continuous quality to be practiced by organizations.
-## How does Synthetic Monitoring work?
+## How does synthetic monitoring work?
At its core, synthetic monitoring is about simulating user interactions with an application to preemptively identify issues before they impact real users. Synthetic monitoring gives developers and operations engineers the confidence that they are one step ahead, ensuring that potential problems are identified and resolved swiftly.
In practice, synthetic monitoring works a lot like automated testing in production. Teams constantly run “tests” against a production environment from global locations. Using a Monitoring as Code workflow, its easy to even reuse real end-to-end tests as monitors, simply by deploying them to infrastructure such as Checkly.
@@ -27,7 +27,7 @@ Synthetic monitors can measure uptime, transactions, status response performance
This enables continuous confidence when making rapid changes to mission-critical services and applications by allowing you to notice issues before your customers do.
-## Benefits of Synthetic Monitoring
+## Benefits of synthetic monitoring
Synthetic monitoring plays a pivotal role in understanding an application's behavior under various scenarios. It allows teams to test how their application performs in different geographical locations, under various network conditions, and during peak load times. This insight is critical for applications that cater to a global audience, where performance can vary significantly based on a user's location and the time of day. Here are some other benefits of synthetic monitoring:
### Proactive error detection
@@ -49,7 +49,7 @@ Many things can cause performance degradation, but synthetic monitoring will unv
### Controlled environments
Monitors are run from controlled environments with consistent browser properties and network connections to make root-cause analysis efficient and accurate.
-## Synthetic monitoring vs Real User Monitoring (RUM)
+## Synthetic monitoring vs real user monitoring (RUM)
Real user monitoring, also called RUM or passive monitoring, is another way to analyze and monitor your application. RUM monitoring offers insights into user interactions, performance statistics, and your users' devices and locations in a way that differs greatly from synthetic monitoring.
Unlike synthetic monitoring tools, RUM monitoring tools don't simulate user interactions, but rather record real user interactions. There's nothing for you to script or define. With RUM, an embedded JavaScript snippet records and reports the behavior of actual users back to you so that you can monitor and analyze your applications' performance and health. Your users are the data source! This sounds great, but there are a few challenges with RUM.
@@ -66,50 +66,50 @@ Unlike synthetic monitoring tools, RUM monitoring tools don't simulate user inte
A comparison of RUM vs. Synthetics
-## Types of Synthetic Monitoring
+## Types of synthetic monitoring
There are a number of terms used around synthetic monitoring; everything from "Synthetic User Monitoring" to "Heartbeat Monitors" can refer to the same test! However, in general, there are four types of monitoring that are most critical for monitoring your production services:
-### Uptime or Availability Monitoring
+### Uptime or availability monitoring
Availability Monitoring is fundamental. Its primary objective is to verify whether a web service or application is accessible at any given time. This type of monitoring simulates user interactions to check the availability of websites, APIs, and servers. It's not just about confirming that a server is up and returning "200 OK" status messages; it's about ensuring that the application is operational and responding as expected.
-### Transaction Monitoring
+### Transaction monitoring
Transaction Monitoring takes a step further. To know that every part is really working as expected, Transaction Monitoring means simulating complex user transactions or workflows to verify that critical processes, like checkout or login, are working as intended.
Scripts are designed to mimic the path a user would take through the application. This can be as simple as logging in or as complex as completing a multi-step transaction. The goal is to identify performance issues or bugs that might not be evident in other forms of testing. For example, this will reveal whether third-party services have failed, resulting in degraded performance on our own site.
-### Performance Monitoring
+### Performance monitoring
Web Performance Monitoring is all about speed and efficiency. It evaluates how quickly and smoothly your web application loads and operates from the user's perspective. This is a more analog measurement than the Availability or Transaction Monitoring, as exact loading times will vary and won't give simple "up or down" feedback. Web Performance Monitoring can identify technical debt, as small changes to your experience can add up to degraded (or improved!) performance for your end users.
-### Keyword Monitoring
+### Keyword monitoring
Keyword monitoring entails monitoring for content that is expected to appear in an API response or within a UI. [Keyword monitoring](/guides/monitoring-ecommerce-apps-using-playwright) can be extremely helpful for commerce sites or other content-driven websites like news publishers and blogs.
-## Synthetic Monitoring Best Practices
+## Synthetic monitoring best practices
Implementing synthetic monitoring effectively ensures you maximize its value in identifying and resolving performance issues. Here are key best practices to follow:
-### 1. Define Key User Journeys
+### 1. Define key user journeys
Before you implement synthetic monitoring, identify the most critical user interactions, such as login flows, checkout processes, or API endpoints that drive your business. These are the flows you want to be setting synthetic monitors for. Simulating these core pathways ensures that issues affecting customer satisfaction are detected early.
-### 2. Test From Multiple Locations
+### 2. Test from multiple locations
Set up monitors across geographically distributed data centers to simulate user access from various regions. This practice helps uncover location-specific latency or connectivity issues and ensures a consistent experience for global users.
-### 3. Use Realistic Scenarios
+### 3. Use realistic scenarios
Craft test scripts that mimic real user behaviors, including complex interactions like multi-step forms or dynamic content loading. Ensure these scripts reflect typical device types, browsers, and network conditions to emulate authentic experiences.
-### 4. Monitor Continuously and Strategically
+### 4. Monitor continuously and strategically
Schedule monitoring at frequent intervals to capture real-time performance data. Combine this with strategic off-peak monitoring to identify time-sensitive bottlenecks, such as overnight updates or backups affecting availability.
-### 5. Set Up Meaningful Alerts
+### 5. Set up meaningful alerts
Configure alerts to balance urgency and relevance. Alerts should only trigger for significant issues, avoiding noise from false positives or minor deviations, to ensure your team focuses on critical problems.
-### 6. Regularly Update Scripts
+### 6. Regularly update scripts
Keep monitoring scripts updated to align with application changes. Regular maintenance prevents outdated tests from providing inaccurate results or missing new vulnerabilities.
-### 7. Integrate Synthetic Monitoring with Your CI/CD Pipeline
+### 7. Integrate synthetic monitoring with your CI/CD pipeline
Incorporate synthetic monitoring checks into your deployment workflows to catch issues before they reach production. Automated tests can act as gatekeepers for performance and functionality.
By following these best practices, you can leverage synthetic monitoring to proactively enhance performance and deliver seamless user experiences.
-## Synthetic Monitoring Use Cases
+## Synthetic monitoring use cases
Here are key use cases where synthetic monitoring shines:
* Website Performance Monitoring: Simulate user interactions to measure load times, responsiveness, and overall performance of web pages.
@@ -128,13 +128,13 @@ Here are key use cases where synthetic monitoring shines:
These use cases make synthetic monitoring essential for delivering reliable and high-performing applications.
-## Common Synthetic Monitoring tools
+## Common synthetic monitoring tools
To do synthetic monitoring right, you'll either need to run a service totally independently of your existing tech stack or use a SaaS tool. A system to monitor your production services shouldn't go down when your own system does! You'll also need a tool to store past performance data and present it within a dashboard.
### Playwright - The leader in browser automation
Backed by Microsoft, Playwright quickly became one of the leaders in synthetic and [end-to-end testing](/learn/monitoring/end-to-end-monitoring). Its ability to control headless browsers while providing a stellar developer experience convinced the developers, quality assurance, and DevOps communities. And we at Checkly believe it's the best tool for synthetic monitoring.
-### Checkly - The best platform for running Synthetic Tests
+### Checkly - The best platform for running synthetic tests
While multiple Observability vendors offer limited site pings as part of a larger toolset, Checkly offers the best experience for users focused on synthetics testing. While other teams use Playwright only for the occasional end-to-end checks, Checkly lets you run these detailed checks with complex scripted behavior at any cadence you need to maintain your SLA. And Checkly can cost less than [half of what our competitors charge](https://www.checklyhq.com/blog/how-to-spend-ten-grand-12-bucks-at-a-time/).
Checkly offers rich options for scheduling tests on a cadence, including [scheduling checks from multiple regions](https://www.checklyhq.com/blog/parallel-scheduling/), and offers the most complete answer to ‘how is our service performing for all our users?
@@ -148,7 +148,7 @@ Synthetic monitoring and Monitoring as Code anticipate and resolve issues before
Because you have to remember you can only fix issues you know about.
-## Frequently Asked questions about Synthetic Monitoring
+## Frequently asked questions about synthetic monitoring
### What is the difference between observability and synthetic monitoring?
diff --git a/learn/monitoring/tcp-and-ssl.mdx b/learn/monitoring/tcp-and-ssl.mdx
index fe3a8b51d..c868991fc 100644
--- a/learn/monitoring/tcp-and-ssl.mdx
+++ b/learn/monitoring/tcp-and-ssl.mdx
@@ -36,7 +36,7 @@ One senior developer shared a story of why it's important to understand the netw
As an application developer, you need to know how TCP and SSL/TLS work together to establish secure connections, authenticate parties, and ensure data integrity. This article will explain the relationship between TCP and SSL/TLS, focusing on authentication and how it impacts your application.
-## How TCP and SSL/TLS Work Together
+## How TCP and SSL/TLS work together
TCP provides the underlying communication channel for SSL/TLS. Here’s how they work together:
@@ -47,11 +47,11 @@ TCP provides the underlying communication channel for SSL/TLS. Here’s how they
The SSL/TLS handshake is critical for authentication, ensuring that the client is communicating with the intended server and not an imposter.
-## SSL/TLS Authentication
+## SSL/TLS authentication
Authentication in SSL/TLS ensures that the parties involved in the communication are who they claim to be. This is typically done using digital certificates and public-key cryptography.
-### Server Authentication
+### Server authentication
In most cases, SSL/TLS is used to authenticate the server to the client. Here’s how it works:
@@ -64,7 +64,7 @@ In most cases, SSL/TLS is used to authenticate the server to the client. Here’
This process ensures that the client is communicating with the legitimate server and not a man-in-the-middle attacker.
-### Client Authentication (Optional)
+### Client authentication (optional)
In some cases, the server may also require the client to authenticate itself. This is less common but is used in scenarios where mutual trust is required (e.g., enterprise applications, APIs). Here’s how it works:
@@ -76,7 +76,7 @@ Client authentication adds an extra layer of security but requires managing clie
---
-## SSL/TLS Handshake in Detail
+## SSL/TLS handshake in detail
The SSL/TLS handshake is a multi-step process that establishes a secure connection. Here’s a simplified overview:
@@ -96,7 +96,7 @@ Once the handshake is complete, the secure connection is established, and encryp
---
-## What Application Developers Need to Know
+## What application developers need to know
Certificate Management
- Server Certificates: Ensure your server has a valid certificate signed by a trusted CA. Self-signed certificates are not trusted by default and may cause errors in clients.
@@ -118,7 +118,7 @@ Once the handshake is complete, the secure connection is established, and encryp
---
-## Common Issues and Troubleshooting
+## Common issues and troubleshooting
Certificate Expiry
- Certificates have a limited validity period. If a certificate expires, the SSL/TLS handshake will fail. Monitor certificate expiration dates and renew them before they expire.
@@ -137,7 +137,7 @@ Once the handshake is complete, the secure connection is established, and encryp
---
-## Best Practices for SSL/TLS Authentication
+## Best practices for SSL/TLS authentication
* Use Strong Certificates:
- Use certificates with a key length of at least 2048 bits (RSA) or 256 bits (ECDSA).
diff --git a/learn/monitoring/transaction-monitoring.mdx b/learn/monitoring/transaction-monitoring.mdx
index 61d87202a..f9971c53a 100644
--- a/learn/monitoring/transaction-monitoring.mdx
+++ b/learn/monitoring/transaction-monitoring.mdx
@@ -1,7 +1,7 @@
---
-title: Transaction Monitoring - Components, Benefits & Challenges
+title: Transaction monitoring - Components, benefits & challenges
displayTitle: What is Transaction Monitoring?
-sidebarTitle: Transaction Monitoring
+sidebarTitle: Transaction monitoring
description: Explore transaction monitoring for application developers and SREs.
date: 2024-12-15
author: Nocnica Mellifera
@@ -22,11 +22,11 @@ Unlike traditional monitoring of a site or service, which relies on observing re
---
-## Synthetic Monitoring vs. Synthetic Transaction Monitoring
+## Synthetic monitoring vs. Synthetic transaction monitoring
First some language confusion: ‘Synthetic Monitoring’ isn’t a particularly widely used term, what’s with the addition of ‘transaction?’ [Synthetic monitoring](https://www.checklyhq.com/blog/what-is-synthetic-monitoring/) broadly refers to any monitoring that uses automated tests to emulate users, sometimes a simple as a page load. Synthetic transaction monitoring is a subset focused on multi-step workflows or transactions, such as filling out forms, completing e-commerce purchases, or using APIs. While synthetic monitoring may involve simple checks like testing website uptime, synthetic transaction monitoring goes deeper into the user experience by validating the performance and functionality of complex processes.
-## How Does Synthetic Transaction Monitoring Work?
+## How does synthetic transaction monitoring work?
Synthetic transaction monitoring involves several key steps:
@@ -37,7 +37,7 @@ Synthetic transaction monitoring involves several key steps:
5. **Analysis and Reporting**: Results are analyzed to identify anomalies, trends, or potential bottlenecks.
6. **Alerting**: If thresholds are breached, alerts notify relevant teams for investigation and resolution. For almost all monitoring, alerts should wait on at least one retry, so as not to cause alert fatigue.
-## Why Synthetic Transaction Monitoring Matters
+## Why synthetic transaction monitoring matters
Synthetic transaction monitoring offers several advantages, especially over real user monitoring.
@@ -48,7 +48,7 @@ Synthetic transaction monitoring offers several advantages, especially over real
However, challenges include maintaining up-to-date scripts as applications evolve and ensuring synthetic tests accurately reflect real-world usage.
-## Components of Synthetic Transaction Monitoring
+## Components of synthetic transaction monitoring
Effective synthetic transaction monitoring relies on several core components:
@@ -76,7 +76,7 @@ An alerting system notifies teams when performance thresholds are breached. Aler
Synthetic transaction monitoring tools often integrate with observability platforms, incident management systems, and CI/CD pipelines, enabling streamlined workflows and comprehensive insights. At Checkly, the results of synthetics checks can integrate with your OpenTelemetry data via [Checkly Traces](/resolve/traces/how-it-works).
-## Synthetic Transaction Monitoring Use Cases with Examples
+## Synthetic transaction monitoring use cases with examples
1. **E-Commerce Checkout Process**
A retailer uses synthetic transaction monitoring to simulate a user adding items to a cart, entering payment details, and completing a purchase. This ensures the checkout process remains functional, even as the underlying datastores and visual polish on the e-commrce experience change.
@@ -93,7 +93,7 @@ A video streaming service tests its platform from multiple regions to ensure vid
Synthetic transaction monitoring is an essential tool for organizations aiming to ensure optimal performance and reliability of their digital services. By proactively addressing issues and gaining insights into user workflows, businesses can deliver superior experiences to their customers.
-## Benefits of Synthetic Transaction Monitoring
+## Benefits of synthetic transaction monitoring
**Early Detection of Issues**
@@ -121,7 +121,7 @@ While it’s nice to imagine our service or website as self-contained, albeit wi
Synthetic transaction monitoring can aid in compliance with service-level agreements (SLAs) by consistently measuring uptime and performance against defined benchmarks. This ensures businesses meet contractual obligations and regulatory requirements. You can also use synthetic transaction monitoring to make sure you’re compliant with accessibility requirements, [in Playwright you can use the Axe testing engine to automatically check your pages for accessibility issues](https://www.checklyhq.com/blog/integrating-accessibility-checks-in-playwright-tes/).
-## Challenges of Synthetic Transaction Monitoring
+## Challenges of synthetic transaction monitoring
**Need for Validation**
@@ -142,7 +142,7 @@ Integrating synthetic monitoring tools with existing systems can pose challenges
By understanding these benefits and challenges, organizations can better implement synthetic transaction monitoring as part of a balanced observability strategy.
-## Best Practices for Synthetic Transaction Monitoring
+## Best practices for synthetic transaction monitoring
**Defining Clear Objectives**
@@ -176,7 +176,7 @@ Integrate synthetic monitoring with broader observability platforms to enhance t
Synthetic monitoring is a powerful tool for validating Service Level Agreements (SLAs). By continuously testing key metrics, you can provide objective evidence of SLA adherence to stakeholders.
-## Synthetic Transaction Monitoring Tools
+## Synthetic transaction monitoring tools
Numerous tools are available to implement synthetic transaction monitoring effectively. Solutions like Catchpoint and Dynatrace offer advanced features such as global test locations, detailed reporting, and integration with other observability tools. Open-source options, such as those leveraging CNCF projects, can provide flexibility and customization for Kubernetes-based environments.
@@ -184,7 +184,7 @@ Numerous tools are available to implement synthetic transaction monitoring effec
[Checkly](https://www.checklyhq.com/product/synthetic-monitoring/) is a purpose-built platform for synthetic monitoring that simplifies the creation and management of test scripts. With features like a developer-friendly CLI, seamless integration with CI/CD pipelines, and out-of-the-box support for the multi-language Playwright automation framework. Checkly enables teams to monitor critical user journeys effectively. Its dashboards and alerting systems ensure you’re always aware of issues before they impact customers.
-## How Checkly Can Help with Synthetic Transaction Monitoring
+## How Checkly can help with synthetic transaction monitoring
Checkly provides a robust set of tools to implement synthetic monitoring seamlessly. Its scripting capabilities allow you to craft realistic user scenarios while its cloud-based infrastructure ensures consistent monitoring from multiple geographies. Integration with observability platforms and APIs enables you to incorporate Checkly into your existing workflows, making it an efficient choice for synthetic monitoring needs.
diff --git a/learn/monitoring/web-application-monitoring.mdx b/learn/monitoring/web-application-monitoring.mdx
index 53948fe55..05c347cdc 100644
--- a/learn/monitoring/web-application-monitoring.mdx
+++ b/learn/monitoring/web-application-monitoring.mdx
@@ -1,7 +1,7 @@
---
-title: Web Application Monitoring - Types, Benefits & Top 10 Tools
+title: Web application monitoring - Types, benefits & top 10 tools
displayTitle: What is Web Application Monitoring?
-sidebarTitle: Web Application Monitoring
+sidebarTitle: Web application monitoring
description: Explore web application monitoring to boost performance and reliability with real user insights, performance tracking, and top tools.
date: 2024-12-15
author: Nocnica Mellifera
@@ -22,11 +22,11 @@ Web application monitoring refers to the practice of observing, tracking, and ma
Web application monitoring is a highly generalized term, and distinctions between, for example, ‘metrics’ and ‘monitoring;’ and ‘error tracking’ versus ‘performance monitoring’ are often distinctions without a difference. The question we’re trying to answer with Web Application Monitoring is: “how well is our application performing for users?” Observations that don’t relate to this question, for example the popularity of a single post on our social media site, or how well our live-generated site follows brand standards, are outside the scope of web application monitoring.
-## How Web Application Monitoring Works
+## How web application monitoring works
Monitoring tools collect data from your web application, servers, and user interactions. They process this data to generate insights about application health, performance, and user behavior. Alerts, dashboards, and reports provide actionable insights for resolving issues and optimizing performance.
-## Types of Web Application Monitoring
+## Types of web application monitoring
Monitoring a web application requires understanding various dimensions of performance, usability, and security. Each type of monitoring addresses specific aspects of the application to ensure seamless operation. Let’s explore these types in greater detail.
@@ -89,14 +89,14 @@ Server and infrastructure monitoring tracks the health of the hardware, virtual
---
-## Key Metrics to Monitor
+## Key metrics to monitor
- Response Time: Time taken by the application to respond to requests.
- Error Rate: Frequency of errors in the application.
- Throughput: Number of requests processed over a time frame.
- Uptime and Availability: Percentage of time the application is operational.
-## Benefits of Web Application Monitoring
+## Benefits of web application monitoring
* Instant Downtime Alerts
@@ -106,7 +106,7 @@ By monitoring your web application directly, you have a better chance of knowing
Often, poor performance doesn’t happen all at once. For every user who gets in touch complaining of slow response times, dozens or hundreds will have simply abandoned your service, and written off the quality of your site. Without web application monitoring, you’ll use users for some time before you’re even aware of a problem.
-## Limitations of Web Application Monitoring
+## Limitations of web application monitoring
* Dynamic Content
@@ -116,7 +116,7 @@ Monitoring tools may struggle with rapidly changing, personalized content. A rob
As mentioned in the introduction, Web Application Monitoring has a specific use: finding how well a service performs for users. Once the use case expands into security monitoring or business analytics, mission creep can kill your efficiency.
-## Best Practices for Monitoring Web Applications
+## Best practices for monitoring web applications
Effective monitoring is essential to maintaining the performance, availability, and security of web applications. However, monitoring is more than just collecting data; it’s a strategic process of learning and acting based on insights. By following these best practices, organizations can ensure their monitoring efforts are both meaningful and actionable.
@@ -219,7 +219,7 @@ Periodic audits ensure that your monitoring strategy remains effective and that
Effective monitoring isn’t just about data collection—it’s about using data to improve your application and achieve your organization’s goals. By integrating these best practices into your strategy, you ensure that monitoring becomes a driver of growth, user satisfaction, and operational excellence.
-## Top 9 Web Application Monitoring Tools
+## Top 9 web application monitoring tools
* 1. Datadog
@@ -291,7 +291,7 @@ Instana promises AI-driven insights and automatic monitoring for dynamic applica
Personal Experience: During an initiative to modernize a legacy application, Instana was pitched to us as the “next-generation AI observability solution.” While it delivered on automated dependency mapping, the AI insights often felt like little more than a repackaging of existing metrics with an added buzzword. It was helpful for identifying sudden resource spikes, but I often found myself relying on other tools for detailed root-cause analysis. The promises of “AI-driven” observability didn’t live up to the hype.
-## Open Source Monitoring: a key part of web application monitoring
+## Open source monitoring: a key part of web application monitoring
Open source monitoring plays a pivotal role in modern cloud-native web application monitoring by leveraging community-driven tools to provide robust, scalable, and accessible monitoring solutions. These tools empower organizations to manage the complexity of distributed systems without being locked into proprietary solutions.
@@ -323,7 +323,7 @@ Cloud-native applications, by design, introduce new complexities:
Open source monitoring is not just a viable alternative to proprietary solutions—it is the backbone of modern observability. With tools like Prometheus, Loki, Jaeger, and eBPF, organizations can effectively monitor cloud-native applications, dynamically adjust to changing workloads, and achieve operational excellence. By embracing these technologies, teams can focus on delivering exceptional user experiences while keeping operational costs in check.
-## How Can Checkly Help with Web Application Monitoring
+## How can Checkly help with web application monitoring
[Checkly](https://www.checklyhq.com/) offers an integrated platform for synthetic monitoring and API testing, ensuring applications are functional and performant. For simulating user requests to perform synthetic monitoring, Checkly harnesses the power of the open source automation tool Playwright. With [Checkly and Playwright](/detect/synthetic-monitoring/browser-checks/playwright-support), there’s no user behavior that you can’t test, and no critical path you can’t monitor continually.
diff --git a/learn/monitoring/what-is-tcp.mdx b/learn/monitoring/what-is-tcp.mdx
index 77387a7c7..81e55ef8c 100644
--- a/learn/monitoring/what-is-tcp.mdx
+++ b/learn/monitoring/what-is-tcp.mdx
@@ -20,7 +20,7 @@ As an application developer, you might think that Transmission Control Protocol
TCP stands for Transmission Control Protocol. It is one of the main protocols used in the Internet Protocol (IP) suite. TCP is responsible for ensuring that data sent from one device to another arrives correctly and in the right order. TCP connections underlie the application-layer connections like HTTP connections that we're more familiar with as app developers. It is a connection-oriented protocol, which means it establishes a connection between the sender and receiver before data is sent.
-## Why Should Application Developers Care About TCP?
+## Why should application developers care about TCP?
Even though TCP operates at a lower level than your application code, it directly impacts how your application performs. Here are a few reasons why you should care about TCP:
@@ -30,9 +30,9 @@ Even though TCP operates at a lower level than your application code, it directl
Understanding these aspects can help you optimize your application's performance and troubleshoot issues more effectively.
-## How TCP Works
+## How TCP works
-### TCP Connection Establishment
+### TCP connection establishment
Before data can be sent, a TCP connection must be established between the sender (client) and the receiver (server). This process is known as the **three-way handshake**:
@@ -44,19 +44,19 @@ Before data can be sent, a TCP connection must be established between the sender
Once the three-way handshake is complete, the connection is established, and data can be transmitted.
-### Data Transmission
+### Data transmission
After the connection is established, data is sent in segments. Each segment contains a sequence number that helps the receiver reassemble the data in the correct order. The receiver sends an acknowledgment (ACK) for each segment received. If the sender does not receive an ACK within a certain time, it will retransmit the segment.
-### Flow Control
+### Flow control
TCP uses a mechanism called **flow control** to ensure that the sender does not overwhelm the receiver with too much data. The receiver advertises a window size, which indicates how much data it can accept. The sender adjusts the amount of data it sends based on this window size.
-### Congestion Control
+### Congestion control
TCP also implements **congestion control** to prevent network congestion. If the network is congested, TCP will reduce the rate at which it sends data. This is done using algorithms like **Slow Start**, **Congestion Avoidance**, and **Fast Retransmit**.
-### Connection Termination
+### Connection termination
When the data transfer is complete, the TCP connection is terminated using a four-step process:
@@ -67,9 +67,9 @@ When the data transfer is complete, the TCP connection is terminated using a fou
After this process, the connection is closed.
-## Key TCP Concepts for Application Developers
+## Key TCP concepts for application developers
-### Ports and Sockets
+### Ports and sockets
In TCP, communication is identified by a pair of **sockets**. A socket is a combination of an IP address and a port number. The IP address identifies the device, and the port number identifies the specific application or service on that device.
@@ -79,7 +79,7 @@ As an application developer, you need to be aware of the ports your application
TCP uses buffers to store data before it is sent or after it is received. As a developer, you can control the size of these buffers, which can impact performance. Larger buffers can improve throughput but may increase latenc.
-### Keep-Alive
+### Keep-alive
TCP connections can be kept alive even when no data is being transmitted. This is useful for applications that need to maintain a connection for a long time. However, keep-alive packets can consume network resources, so you should use them judiciously.
@@ -87,11 +87,11 @@ TCP connections can be kept alive even when no data is being transmitted. This i
TCP uses timeouts to detect when a connection is no longer active. If no data is received within a certain time, the connection may be closed. As a developer, you can configure these timeouts to suit your application's needs.
-### Error Handling
+### Error handling
TCP handles most errors automatically, but you should still be aware of potential issues. For example, if a connection is lost, TCP will attempt to retransmit data, but if the connection cannot be reestablished, your application may need to handle the error.
-## TCP and Application Performance
+## TCP and application performance
### Latency
@@ -105,63 +105,63 @@ Throughput is the amount of data that can be transmitted in a given time. TCP's
TCP connections consume resources on both the client and server. If your application needs to handle many simultaneous connections, you should consider how TCP's connection management affects scalability. Techniques like connection pooling and load balancing can help.
-## Common TCP Issues and How to Troubleshoot Them
+## Common TCP issues and how to troubleshoot them
-### Packet Loss
+### Packet loss
Packet loss can occur due to network congestion or hardware issues. TCP will retransmit lost packets, but frequent packet loss can degrade performance. Use tools like `ping` or `traceroute` to diagnose network issues.
-### Slow Performance
+### Slow performance
Slow performance can be caused by many factors, including high latency, low throughput, or network congestion. Use tools like `netstat` or `tcpdump` to analyze TCP connections and identify bottlenecks.
-## Best Practices for Application Developers
+## Best practices for application developers
-### Use Persistent Connections
+### Use persistent connections
Persistent connections reduce the overhead of establishing and tearing down TCP connections. This can improve performance, especially for applications that make many small requests.
-### Optimize Buffer Sizes
+### Optimize buffer sizes
Adjusting the size of TCP buffers can improve performance. Larger buffers can increase throughput, while smaller buffers can reduce latency. Experiment with different buffer sizes to find the optimal configuration for your application.
-### Monitor TCP Metrics
+### Monitor TCP metrics
Monitoring TCP metrics like latency, throughput, and packet loss can help you identify performance issues. Use monitoring tools to track these metrics and make adjustments as needed.
-### Handle Errors Gracefully
+### Handle errors gracefully
Even though TCP handles most errors automatically, your application should still handle errors gracefully. For example, if a connection is lost, your application should attempt to reconnect or notify the user.
-### Test Under Realistic Conditions
+### Test under realistic conditions
Test your application under realistic network conditions to ensure it performs well. Use tools that simulate network latency, packet loss, and congestion to identify potential issues. Essentially, once you're trying to test the integration between multiple dependencies connecting via multiple protocols, consider testing in a production environment with [synthetic monitoring](https://www.checklyhq.com/blog/what-is-synthetic-monitoring/) rather than trying to simulate the scenario with mocks.
## TCP and HTTP
As mentioned above HTTP connections are application-level connections with TCP handling the network-layer connection. A few key concepts for those familiar with HTTP:
-### 1. **Persistent Connections (HTTP Keep-Alive)**
+### 1. **Persistent connections (HTTP keep-alive)**
- By default, HTTP/1.1 uses **persistent connections**, meaning the same TCP connection can be reused for multiple HTTP requests and responses.
- This reduces the overhead of establishing and closing TCP connections, improving performance.
- The `Connection: keep-alive` header is used to enable persistent connections.
-### 2. **Connection Pooling**
+### 2. **Connection pooling**
- To further optimize performance, applications often use [**connection pooling**](https://node-postgres.com/features/pooling), where a pool of TCP connections is maintained and reused for multiple HTTP requests.
- This is especially useful for applications that make many HTTP requests to the same server (e.g., APIs, microservices).
-### 3. **Latency and the Three-Way Handshake**
+### 3. **Latency and the three-way handshake**
- The TCP three-way handshake introduces latency, especially for short-lived HTTP requests.
- Techniques like **HTTP/2 multiplexing** and **HTTP/3** (which uses QUIC instead of TCP) can reduce this latency.
- Applications using many short lived requests (e.g. streaming a game to a browser) will want to switch from HTTP/1 connections.
-### 4. **Error Handling**
+### 4. **Error handling**
- TCP handles most network-level errors (e.g., packet loss, retransmission), but your application should still handle HTTP-level errors (e.g., `4xx` and `5xx` status codes).
### 5. **SSL/TLS and HTTPS**
- When using HTTPS, the SSL/TLS handshake occurs after the TCP connection is established but before the HTTP request is sent.
- This adds additional latency but ensures the connection is secure.
-### 6. How HTTP/2 and HTTP/3 Change the Relationship
+### 6. How HTTP/2 and HTTP/3 change the relationship
**HTTP/2**
- HTTP/2 introduces **multiplexing**, allowing multiple HTTP requests and responses to be sent concurrently over a single TCP connection.
@@ -178,7 +178,7 @@ As mentioned above HTTP connections are application-level connections with TCP h
While TCP is often considered the domain of network engineers, understanding its basics is crucial for application developers. By understanding how TCP works, you can optimize your application's performance, troubleshoot issues more effectively, and build more reliable applications. Remember to monitor TCP metrics, optimize buffer sizes, and handle errors gracefully to ensure your application performs well under all conditions.
-## Additional Resources
+## Additional resources
- [**RFC 793**](https://www.rfc-editor.org/info/rfc793): The official specification for TCP.
- [**Wireshark**](https://www.wireshark.org/): A network protocol analyzer that can help you inspect TCP traffic.
diff --git a/learn/opentelemetry/context-propagation.mdx b/learn/opentelemetry/context-propagation.mdx
index 8fff0672b..17f2b3d44 100644
--- a/learn/opentelemetry/context-propagation.mdx
+++ b/learn/opentelemetry/context-propagation.mdx
@@ -1,6 +1,6 @@
---
-title: Fundamentals of Context Propagation in OpenTelemetry
-sidebarTitle: Context Propagation
+title: Fundamentals of context propagation in OpenTelemetry
+sidebarTitle: Context propagation
description: One of the most basic features of almost any OpenTelemetry tool, is support for context propagation, a fundamental component that sends information from one service to another and allows traces to cover multiple services. Context propagation turns separate service logs into complete traces. It's what makes modern observability possible.
date: 2025-04-15
author: Nocnica Mellifera
@@ -17,7 +17,7 @@ Imagine the impossibility of diagnosing problems found during end-to-end testing
In pursuit of this lofty goal, one of the most basic features of almost any OpenTelemetry tool, is support for context propagation, a fundamental component that sends information from one service to another and allows traces to cover multiple services.
-### What is Context?
+### What is context?
In OpenTelemetry, context is the information that flows through your system with each request. It carries important details like:
@@ -27,7 +27,7 @@ In OpenTelemetry, context is the information that flows through your system with
Context standards are not defined by the OpenTelemetry project but rather are baced on the [W3C Trace Context](https://www.w3.org/TR/trace-context/) standards.
-### Why Context Matters
+### Why context matters
As mentioned above, modern architectures are complicated. Many outages and other incidents end with engineers examining the logs from a single service, but to get real insight into how requests are processed by your system as a whole, you need context.
@@ -37,7 +37,7 @@ Without context:
- You lose visibility in distributed systems
- Debugging becomes much harder
-### How Propagation Works
+### How propagation works
1. **Injection**: When a request starts, the context (trace ID, etc.) gets added to headers
2. **Extraction**: When another service receives the request, it pulls the context from headers
@@ -45,7 +45,7 @@ Without context:
Note that while most OpenTelemetry SDKs and tools propagate context automatically, there’s also the [propagation API](https://opentelemetry.io/docs/specs/otel/context/api-propagators/) if you need to manually propagate context. For example, if you are able to see that two time spans should be part of one trace via an unusual method like examining the messages body with a regex, you’d want to work with the propagation API.
-### The Standards Behind It
+### The standards behind it
OpenTelemetry uses the W3C Trace Context standard (traceparent header) for compatibility. This means:
@@ -53,7 +53,7 @@ OpenTelemetry uses the W3C Trace Context standard (traceparent header) for compa
- Supported by many observability tools
- Ensures consistent behavior everywhere
-### Key Components
+### Key components
- **Context API**: Stores and manages the current context
- **Propagators**: Handle injecting/extracting context (usually from HTTP headers)
@@ -61,7 +61,7 @@ OpenTelemetry uses the W3C Trace Context standard (traceparent header) for compa
Baggage is worth a pointer since it’s important to know that you can add operational information beyond observability data, and thereby piggyback off the great work done for context propagation within the OTel project. This might be used to do something like marking test requests sent by [synthetic monitoring](https://www.checklyhq.com/docs/), so that your datastore knows to route these requests to a test DB.
-### In Practice
+### In practice
When Service A calls Service B:
@@ -69,7 +69,7 @@ When Service A calls Service B:
2. Service B reads those headers to continue the trace
3. All spans from both services connect automatically
-### Why This is Powerful
+### Why this is powerful
- No manual correlation needed
- Works across any protocol (HTTP, gRPC, queues, etc.)
@@ -77,11 +77,11 @@ When Service A calls Service B:
Context propagation turns separate operations into connected stories - making complex systems much easier to understand and troubleshoot.
-## How Context Propagation Unlocks Efficient Monitoring: Checkly Traces
+## How context propagation unlocks efficient monitoring: Checkly Traces
At Checkly, we had a problem. We wanted to let our users connect data on the backend performance of their application when handling requests sent by Checkly as part of synthetic user monitoring. For example, if a single postgres query was taking a long time and slowing down one type of user request, we wanted to see what request had taken so long. But we didn’t want to send large amounts of unnecessary data, using up user’s bandwidth and resources. To continue the analogy, we only wanted to send the postgres query data for our specific test request, not all postgres query performance from everywhere. With OpenTelemetry context propagation, this proved feature was easy to implement, and performs well.
-### How it works: Context Propagation and Checkly Traces
+### How it works: Context propagation and Checkly Traces
1. A user configures their Checkly test service to send requests with an additional header, marking this request as coming from Checkly
2. The user adds a few lines of configuration to their OTel Collector, to send on relevant traces
@@ -95,7 +95,7 @@ At Checkly, we had a problem. We wanted to let our users connect data on the bac
This is just one example of how context propagation is a key superpower for OpenTelemetry.
-## Conclusions: OpenTelemetry Context Propagation is Fundamental to Observability
+## Conclusions: OpenTelemetry context propagation is fundamental to observability
Context propagation turns separate service logs into complete traces. It's what makes modern observability possible. As systems grow more complex, this simple way of connecting services becomes essential for:
diff --git a/learn/opentelemetry/getting-started-with-observability.mdx b/learn/opentelemetry/getting-started-with-observability.mdx
index 779b69b17..0d0b08fce 100644
--- a/learn/opentelemetry/getting-started-with-observability.mdx
+++ b/learn/opentelemetry/getting-started-with-observability.mdx
@@ -1,7 +1,7 @@
---
-title: Getting Started with Observability
+title: Getting started with observability
displayTitle: Getting started with Observability
-sidebarTitle: What is Observability?
+sidebarTitle: What is observability?
description: Learn OpenTelemetry with Checkly. Add monitoring to every piece of your stack with the open standards and open-source tools.
date: 2024-10-17
author: Nocnica Mellifera
@@ -18,7 +18,7 @@ canonical: 'https://www.checklyhq.com/docs/learn/opentelemetry/getting-started-w
**Observability** is the practice of understanding the internal state of a system by examining the outputs it generates—such as logs, metrics, and traces. OpenTelemetry (OTel) plays a key role in modern observability by offering open standards for instrumenting code, gathering telemetry data, and managing this data through centralized collectors.
-### Why Observability Matters
+### Why observability matters
In systems that adopt **microservices** architecture, tracking system health becomes challenging. Unlike monolithic systems, where a few experts can oversee the whole system, microservices distribute responsibilities across many independent services. This fragmentation makes it difficult to pinpoint issues and monitor end-to-end system behavior. Observability addresses these gaps by enabling better monitoring and faster resolution of incidents.
@@ -47,7 +47,7 @@ Often you'll see a question posted to the effect of 'how can the OpenTelemetry c
Often in these guides, we'll mention open source tools like Prometheus and Grafana for storing and displaying OpenTelemetry data. However OpenTelemetry is not preferential to these tools, and with a unified standard for transmitting data, any vendor that supports the OTLP standard should work to receive OpenTelemetry data.
-### The Three Pillars of Observability
+### The three pillars of observability
OpenTelemetry enables observability through three core data types:
@@ -64,11 +64,11 @@ OpenTelemetry enables observability through three core data types:
- Tracing helps identify the components involved in a request and their performance (e.g., through waterfall charts).
- Distributed tracing extends this concept to microservices, ensuring that spans from different services are correlated correctly.
-### Distributed Tracing with OpenTelemetry
+### Distributed tracing with OpenTelemetry
Distributed tracing relies on propagating a **trace context** across services. Each service contributes spans to the trace, which are visualized in sequence to understand the request's journey. OpenTelemetry makes this possible by defining trace headers that are passed across service boundaries.
-### Getting Started with OpenTelemetry
+### Getting started with OpenTelemetry
To begin using OpenTelemetry, you will follow three general steps:
@@ -80,7 +80,7 @@ The flexibility of the collector enables smooth transitions between direct repor
-### Relevant Resources on OpenTelemetry
+### Relevant resources on OpenTelemetry
- **Metrics Overview**: [Learn how OpenTelemetry handles metrics to provide high-level insights into your system's performance](/learn/opentelemetry/metrics).
- **Logging with OpenTelemetry**: [Discover how OpenTelemetry integrates with existing logging libraries and enhances log data correlation across microservices](https://opentelemetry.io/docs/specs/otel/logs/).
diff --git a/learn/opentelemetry/how-to-instrument.mdx b/learn/opentelemetry/how-to-instrument.mdx
index 475c2891a..67782f7e4 100644
--- a/learn/opentelemetry/how-to-instrument.mdx
+++ b/learn/opentelemetry/how-to-instrument.mdx
@@ -12,7 +12,7 @@ OpenTelemetry offers two main strategies for adding observability to your applic
---
-### Direct Instrumentation
+### Direct instrumentation
Direct instrumentation involves **manually adding code** to your application to generate telemetry data. This requires developers to use the OpenTelemetry SDK specific to their programming language, explicitly invoking functions to create traces, metrics, or logs.
@@ -24,7 +24,7 @@ Direct instrumentation involves **manually adding code** to your application to
This approach ensures deeper insights but requires more engineering effort upfront and ongoing maintenance to ensure proper coverage and updates as the code evolves. There are of course 1,001 ways that a clever developer could ensure that the intervention needed even for direct instrumentation was miniman. For example, by wrapping the function that first receives a request, and the function class to ensure that future function calls are reported to a tracer. Direct instrumentation doesn't mean modifying n+1 lines of code, but it does require a fair amount of effort to get launched the first time, no matter how clever your developers are.
-### Auto-Instrumentation
+### Auto-instrumentation
Auto-instrumentation eliminates the need for manual code changes by **injecting telemetry at runtime**. This is often achieved through agents or middleware that modify existing code dynamically. For example, Java or Python applications can use agents to hook into libraries and frameworks they rely on.
@@ -39,7 +39,7 @@ Auto-instrumentation eliminates the need for manual code changes by **injecting
Finally, auto-instrumentation won’t generally produce useful results if something really unusual is happening inside your application. At base, automatic instrumentation assumes that your service is some kind of online application handling requests and sending responses. If that’s not the case, for example if your application is a machine learning system processing through a database and taking over 48 hours to produce results, you may get less useful information. In these cases, you may want to look into manually reporting [OpenTelemetry metrics](/learn/opentelemetry/metrics).
-### When to Use Each
+### When to use each
- **Direct instrumentation** is ideal for teams seeking maximum flexibility, particularly for custom workflows or applications with unique behavior.
- **Auto-instrumentation** is better suited for scenarios where rapid observability is needed, or when standard libraries provide sufficient coverage.
diff --git a/learn/opentelemetry/logs.mdx b/learn/opentelemetry/logs.mdx
index 4a31363bb..e230e1484 100644
--- a/learn/opentelemetry/logs.mdx
+++ b/learn/opentelemetry/logs.mdx
@@ -1,5 +1,5 @@
---
-title: Logging in OpenTelemetry, an Engineer’s Guide
+title: Logging in OpenTelemetry, an engineer’s guide
sidebarTitle: Logging
description: This article will go over the basics, and answer common questions for those getting started with logging in OpenTelemetry. OpenTelemetry elevates logging from isolated text snippets to fully contextualized observability data that integrates seamlessly with traces and metrics.
date: 2025-04-18
@@ -21,24 +21,24 @@ Taking a look at the ‘Language APIs and SDKs’ section of the OpenTelemetry d
In fact only a handful of languages, such as Java, C++ and PHP, had ‘stable’ logs support at the time. See the [current status table](https://opentelemetry.io/docs/languages/) for the latest. Is this a cause for concern? In a word ‘no’, this table covers whether, when using the OpenTelemetry SDK, you can make a call to this SDK to emit logging. It is true that in many SDKs this isn’t yet fully supported, but this shouldn’t be a great concern to you because **you are already emitting logging just fine** in your production environment. There are lots of ways to add logging to the signals being handled by the OpenTelemetry collector and your OpenTelemetry datastore, which hook in to your current logging streams.
-## OpenTelemetry and Structured Logging
+## OpenTelemetry and structured logging
When you send logs from traces or events, you could just write raw text. But raw logs are hard to read and parse later. OpenTelemetry prefers **structured logging** instead. Structured logging is a best practice recommended by AWS and other cloud providers as well, since even a simple search of past logs can become prohibitively expensive if you’re
-### What is Structured Logging?
+### What is structured logging?
Structured logging means logs are saved in a clear, machine-readable format—like JSON—instead of plain text. Each log has:
- **Fields** (key-value pairs) for details like timestamps, severity, and context.
- **Consistent formatting**, making logs easier to search, filter, and analyze.
-### Why OpenTelemetry Uses Structured Logs
+### Why OpenTelemetry uses structured logs
1. **Better for Machines** – Tools can automatically process logs without messy parsing.
2. **Connects to Traces** – Logs can link to traces and spans, helping debug issues faster.
3. **Standardized** – OTel defines a common schema so logs work across different systems.
-### How OTel Handles Logs
+### How OTel handles logs
- **Log Records** include:
- Timestamp
@@ -47,7 +47,7 @@ Structured logging means logs are saved in a clear, machine-readable format—li
- Attributes (extra context like `user_id`)
- **Integration** with traces and metrics for full observability.
-### Example (Structured vs. Raw)
+### Example (structured vs. Raw)
**Raw (Hard to Parse):**
@@ -88,9 +88,9 @@ If you turn high-cardinality fields (like `user_ip`) into metric labels, you’
Logging, then, should be seen as similar to event data, and be the storehouse for aggregate, specific information like IP addresses and specific page routes.
-## The Promise of OpenTelemetry Logging: Full Context on Every Line
+## The promise of OpenTelemetry logging: Full context on every line
-### The Problem with Traditional Logging
+### The problem with traditional logging
Today, logs, traces, and metrics live in separate worlds. They use different tools, formats, and collection methods, making it hard to connect them.
@@ -100,7 +100,7 @@ Today, logs, traces, and metrics live in separate worlds. They use different too
This leads to **fragile observability**—logs tell part of the story, but not the whole picture.
-### OpenTelemetry’s Solution: Built-in Context
+### OpenTelemetry’s solution: Built-in context
OpenTelemetry (OTel) fixes this by **propagating full context in every log line**.
@@ -108,25 +108,25 @@ OpenTelemetry (OTel) fixes this by **propagating full context in every log line*
- **Consistent metadata** – Kubernetes pod info, service names, and other attributes are added *automatically* by the OTel Collector—no manual tagging needed.
- **Distributed systems just work** – Logs from different services share the same context, so you can follow a request across your entire system.
-### How It Works
+### How it works
1. **Structured logs** – Logs follow OTel’s data model (like JSON with clear fields).
2. **Automatic enrichment** – The OTel Collector adds context (e.g., `k8s.pod.name`) to logs, traces, and metrics *the same way*.
3. **No re-engineering of existing libraries** – Works with existing logging libraries (Log4j, Logback, etc.) via bridges.
-### Why This Matters
+### Why this matters
- **No more guessing** – Every log line knows exactly where it came from and how it fits into the bigger picture.
- **Better debugging** – Jump from a log error directly to the trace, metrics, and related logs—no manual searching.
- **Future-proof** – Even legacy apps can join the OTel ecosystem via the Collector.
-### The Promise, not yet fulfilled
+### The promise, not yet fulfilled
OpenTelemetry promises to turn logs from isolated snippets into **fully connected observability data**. As noted above, not every language SDK has full logging support, meaning this isn’t completely possible now. And the addition of enrichment data isn’t an easy or automatic process at the collector level (the collector is stateless and can only enrich logs based on what it’s processing at that moment). However, logging with OpenTelemetry has a bright future, and adopting now means you’re likely to be producing highly valuable logs in the next few years that prove worth the effort.
-## The Collector: OpenTelemetry’s Super-Powered Logging Proxy
+## The Collector: OpenTelemetry’s super-powered logging proxy
-### The Problem with Legacy Log Collection
+### The problem with legacy log collection
Most apps today log to files or stdout—simple, but messy. To get those logs into observability tools, you need:
@@ -146,21 +146,21 @@ The Collector acts as a **universal log processor**. It can:
**Bonus:** It does the same for traces and metrics—enriching all signals consistently.
-### Two Ways to Use It
+### Two ways to use it
-### Option 1: File/Stdout → Collector (No Code Changes)
+### Option 1: File/stdout → Collector (no code changes)
- **How it works**: The Collector tails log files, parses them, and adds context.
- **Good for**: Legacy apps, third-party software.
- **Tradeoff**: Parsing can be tricky if log formats are inconsistent.
-### Option 2: App → Collector (Direct OTLP)
+### Option 2: App → Collector (direct OTLP)
- **How it works**: Use an OTel "log appender" (e.g., for Log4j) to send logs directly to the Collector.
- **Good for**: New apps or those you control.
- **Why?** No file parsing, no lost logs on crashes, full structured data.
-### The Best Part: Zero Manual Enrichment
+### The best part: Zero manual enrichment
No more editing every `log.info()` call! The Collector handles:
@@ -168,7 +168,7 @@ No more editing every `log.info()` call! The Collector handles:
- **Resource attributes** (like `k8s.pod.name`)
- **Routing** (send logs to Loki, Splunk, etc.)
-### Why This Wins
+### Why this wins
- **No more "log soup"** – Every log line has rich, queryable fields.
- **Easier correlation** – Logs that carry a trace ID link to their traces.
@@ -176,7 +176,7 @@ No more editing every `log.info()` call! The Collector handles:
How to get started? Start with file collection, then phase in direct OTLP for critical apps.
-## Conclusions: OpenTelemetry is Critical to Logging
+## Conclusions: OpenTelemetry is critical to logging
Logging has always been a fundamental part of understanding software behavior, but in modern distributed systems, traditional logging approaches fall short. OpenTelemetry elevates logging from isolated text snippets to fully contextualized observability data that integrates seamlessly with traces and metrics.
diff --git a/learn/opentelemetry/metrics.mdx b/learn/opentelemetry/metrics.mdx
index 64c165bba..743b82d97 100644
--- a/learn/opentelemetry/metrics.mdx
+++ b/learn/opentelemetry/metrics.mdx
@@ -1,5 +1,5 @@
---
-title: What are OpenTelemetry Metrics?
+title: What are OpenTelemetry metrics?
sidebarTitle: Metrics
description: OpenTelemetry Metrics play a critical role in monitoring applications by offering a way to capture and analyze key metrics in a standardized, scalable manner. Whether you're managing a complex microservices architecture or a simpler system, OpenTelemetry helps track essential statistics that reveal the health and performance of your services. Learn more about OpenTelemetry & Monitoring with Checkly. Explore metrics, one of the three pillars of observability.
date: 2024-10-18
@@ -10,7 +10,7 @@ canonical: 'https://www.checklyhq.com/docs/learn/opentelemetry/metrics/'
---
-## What are Metrics?
+## What are metrics?
Metrics represent **quantitative measurements** of your system’s health and behavior. They provide insights into performance trends, such as:
@@ -21,7 +21,7 @@ Metrics represent **quantitative measurements** of your system’s health and be
Metrics are lightweight and highly efficient to collect, aggregate, and query. They help identify patterns and anomalies without burdening storage, making them suitable for continuous monitoring at scale.
-### Types of Metrics in OpenTelemetry:
+### Types of metrics in OpenTelemetry:
- **Counter**: Measures occurrences or events, such as the number of requests handled.
- **Gauge**: Captures values that fluctuate, like memory usage.
@@ -30,7 +30,7 @@ Metrics are lightweight and highly efficient to collect, aggregate, and query. T
Explore further in the [OpenTelemetry Metrics Documentation](https://opentelemetry.io/docs/concepts/signals/metrics/).
-## Why Metrics Matter
+## Why metrics matter
In a **microservices** environment, metrics are indispensable for:
@@ -46,16 +46,16 @@ Metrics have a number of advantages over tracing. Metrics are much more data eff
Should you use metrics instead of traces to monitor your service? Absolutely not. Metrics will always present average performance, and the specific information needed to really understand root causes will be elusive. Further, even with high resolution timeseries metrics it’s very hard to go from worrying metrics to find matching log data of a problem. Finally, modern traces can effectively show information about asynchronous requests as they contribute to overall request time, something that’s very hard to tease out of bare metrics.
-## Setting up OpenTelemetry Metrics
+## Setting up OpenTelemetry metrics
-### Auto-Instrumentation vs. Manual Instrumentation
+### Auto-instrumentation vs. Manual instrumentation
1. **Auto-Instrumentation**: Many popular frameworks and libraries come with automatic OpenTelemetry instrumentation, requiring minimal setup.
2. **Manual Instrumentation**: Developers can manually add metrics within the application code by using SDKs to track specific business metrics (e.g., purchases per hour).
Learn more about instrumentation options in the [OpenTelemetry SDK Guide](https://opentelemetry.io/docs/instrumentation/).
-## Example Metric Pipeline
+## Example metric pipeline
With OpenTelemetry, you can collect, process, and export metrics using **Collectors**. Here’s a high-level example of a typical metric pipeline:
@@ -67,7 +67,7 @@ Learn how to configure a collector in the [OpenTelemetry Collector Guide](/learn
-## Best Practices for Metrics in OpenTelemetry
+## Best practices for metrics in OpenTelemetry
- **Optimize cardinality**: Avoid creating too many distinct labels, as this can overwhelm storage and query systems.
- **Set appropriate aggregation intervals**: Batch data intelligently to balance between real-time insights and system load.
diff --git a/learn/opentelemetry/otel-agent-management-protocol.mdx b/learn/opentelemetry/otel-agent-management-protocol.mdx
index e330f2263..15099dbda 100644
--- a/learn/opentelemetry/otel-agent-management-protocol.mdx
+++ b/learn/opentelemetry/otel-agent-management-protocol.mdx
@@ -16,7 +16,7 @@ The OpenTelemetry Open Agent Management Protocol (OpAMP) is an emerging standard
OpAMP provides a standard framework for remotely managing telemetry agents. Although current implementations primarily focus on the OpenTelemetry Collector, the protocol is flexible enough to manage various telemetry-related components, including instrumentation agents or future SDK-level integrations. The primary goal is to allow real-time configuration changes, package updates, and secure connection management without manual intervention.
-### Key Features of OpAMP
+### Key features of OpAMP
1. **Dynamic Configuration Management:**
@@ -35,7 +35,7 @@ OpAMP provides a standard framework for remotely managing telemetry agents. Alth
Tail-based sampling, a feature OpAMP aims to support, allows agents to decide which traces to retain after they are fully captured, rather than at the start. This strategy helps reduce the amount of irrelevant telemetry data, though it requires specialized architectures to handle sampling decisions across distributed collectors.
-### Deployment Models for OpAMP
+### Deployment models for OpAMP
OpAMP supports multiple deployment models to fit different environments, including:
@@ -48,7 +48,7 @@ OpAMP supports multiple deployment models to fit different environments, includi
The supervisor approach runs the OpAMP client as a separate process alongside the collector. It monitors the collector’s health, applies configuration changes, and ensures that the collector restarts if it crashes or fails to start after updates. This model provides greater fault tolerance, especially in Kubernetes environments where the client and collector can run as sidecars in the same pod.
-### Use Cases for OpAMP
+### Use cases for OpAMP
- **Remote Configuration and Management:**
@@ -63,13 +63,13 @@ OpAMP supports multiple deployment models to fit different environments, includi
TLS certificates and other credentials can be dynamically rotated, ensuring secure and compliant communication between agents and backends.
-### Challenges and Future Developments
+### Challenges and future developments
Some advanced use cases, such as tail-based sampling, present challenges due to the need for stateful processing and coordinated decision-making across multiple collectors. While the protocol provides a foundation for such features, implementing them in a distributed environment requires careful architectural design.
OpAMP is still evolving, with many features in beta or under active development. In the coming quarters, more user-facing tools are expected, including graphical interfaces for managing collector configurations. As vendors begin to adopt the protocol, end-users can expect smoother agent management and the ability to make configuration changes in real-time.
-### The Current State of OpAMP Development
+### The current state of OpAMP development
The Open Agent Management Protocol (OpAMP) is evolving as a key component for managing fleets of telemetry agents, such as the OpenTelemetry Collector, at scale. As of late 2023, the protocol is still in its **beta phase**, with development focused on enabling dynamic configuration, remote updates, and secure credential management across distributed agents.
@@ -80,7 +80,7 @@ OpAMP is being implemented in two modes for the OpenTelemetry Collector:
1. **Collector Extension**: A lightweight client-side implementation embedded within the collector to support essential OpAMP operations.
2. **Supervisor Process**: An external process that works alongside the collector to handle more advanced features, such as reverting failed configurations and coordinating updates. This supervisor ensures the collector remains operational by restarting or rolling back if new configurations cause issues.
-### **Challenges and Outlook**
+### **Challenges and outlook**
One key development area is **tail-based sampling**, which requires careful architectural design to coordinate sampling decisions across multiple agents and avoid bottlenecks. The protocol’s potential for dynamic configuration management is also expanding, with planned improvements for user-facing tools, including a graphical interface for managing collector settings.
diff --git a/learn/opentelemetry/otel-filtering.mdx b/learn/opentelemetry/otel-filtering.mdx
index 9d33a4439..9816b50b0 100644
--- a/learn/opentelemetry/otel-filtering.mdx
+++ b/learn/opentelemetry/otel-filtering.mdx
@@ -1,5 +1,5 @@
---
-title: Advanced Data Filtering with the OpenTelemetry Collector
+title: Advanced data filtering with the OpenTelemetry Collector
sidebarTitle: Filtering
description: The OpenTelemetry Collector is a stand-alone service designed to collect, process, and export telemetry data such as logs, metrics, and traces. You can filter this data with the collector. An advanced guide to filtering data with processors and the OpenTelemetry Transform Language.
date: 2024-10-18
@@ -11,7 +11,7 @@ The **OpenTelemetry Collector** is a powerful tool for managing telemetry data f
---
-## Why Filtering Matters
+## Why filtering matters
Instrumentation often generates **noisy or redundant data**. Some metrics or traces may include unnecessary information—like personal data or debug logs—leading to bloated dashboards, higher storage costs, and privacy risks. Filtering data within the OpenTelemetry Collector allows you to:
@@ -22,7 +22,7 @@ Instrumentation often generates **noisy or redundant data**. Some metrics or tra
---
-## How the OpenTelemetry Collector Filters Data
+## How the OpenTelemetry Collector filters data
The Collector consists of **receivers, processors, and exporters**. Each plays a role in data filtering:
@@ -30,7 +30,7 @@ The Collector consists of **receivers, processors, and exporters**. Each plays a
2. **Processors**: Modify, filter, or batch data before it is exported.
3. **Exporters**: Send the processed data to observability backends, such as **Prometheus** or **Grafana**.
-### Processor-based Filtering
+### Processor-based filtering
Processors allow transformations and data filtering mid-pipeline. Processors offer inherently limited transformation configuration to do the most common tasks like:
@@ -52,7 +52,7 @@ processors:
---
-## Transformations Using OpenTelemetry Transform Language (OTTL)
+## Transformations using OpenTelemetry transform language (OTTL)
The **OpenTelemetry Transform Language (OTTL)** provides enhanced flexibility for complex transformations. OTTL allows for:
@@ -77,7 +77,7 @@ processors:
Since OTTL allows functional changes of your data, this is really the simplest possible example of a use case: a gate that goes just beyond simple filtering.
-## Stateful Operations and Their Limitations
+## Stateful operations and their limitations
While the collector excels at real-time data transformations, it is **stateless by design** to ensure high performance. Stateful operations—such as aggregating historical data—are not natively supported. This ensures the collector remains lightweight and efficient.
@@ -88,7 +88,7 @@ Common limitations include:
Note: if you are reading this section trying to figure out how to add stateful filtering, e.g. forwarding only the longest trace seen in a 24-hour period I recommend that you *stop* pursuing this within the OTel collector. The limitations of the collector exist for performance reasons, and adding state to the tool will cause unexpected downstream effects as, for example, the collector becomes too burdened to always be ready to accept OTLP data from your services.
-## Filtering Use Cases
+## Filtering use cases
1. **PII Masking**: Remove personal data before sending traces to public dashboards.
2. **Debug Data Suppression**: Drop debug-level logs from production pipelines.
diff --git a/learn/opentelemetry/overview.mdx b/learn/opentelemetry/overview.mdx
index ad47ff5bc..7c2c2759b 100644
--- a/learn/opentelemetry/overview.mdx
+++ b/learn/opentelemetry/overview.mdx
@@ -1,5 +1,5 @@
---
-title: Learn How to Observe and Monitor your Software with OpenTelemetry
+title: Learn how to observe and monitor your software with OpenTelemetry
displayTitle: Getting started with OpenTelemetry and Observability
sidebarTitle: Overview
description: Learn OpenTelemetry with Checkly. Add monitoring to every piece of your stack with the open standards and open-source tools.
@@ -13,11 +13,11 @@ canonical: 'https://www.checklyhq.com/docs/learn/opentelemetry/overview/'
Learn Observability and OpenTelemetry with Checkly. Add monitoring to every piece of your stack with the open standards
and open-source tools.
-## Getting Started
+## Getting started
Learn the basics of observability and how to get started with OpenTelemetry.
@@ -30,7 +30,7 @@ and open-source tools.
-## Diving Deeper
+## Diving deeper
@@ -51,11 +51,11 @@ Whether you're just getting started or looking to advance your monitoring skills
**New to monitoring?** Start with [Monitoring fundamentals](/learn/monitoring/) to build a solid foundation, then explore Playwright for browser automation and testing.
-## Popular Posts
+## Popular posts
@@ -63,7 +63,7 @@ Whether you're just getting started or looking to advance your monitoring skills
@@ -71,7 +71,7 @@ Whether you're just getting started or looking to advance your monitoring skills
diff --git a/learn/playwright/assertions.mdx b/learn/playwright/assertions.mdx
index c7db73c6a..da05454d7 100644
--- a/learn/playwright/assertions.mdx
+++ b/learn/playwright/assertions.mdx
@@ -1,5 +1,5 @@
---
-title: Playwright Assertions - Types & Best Practices
+title: Playwright assertions - Types & best practices
displayTitle: Playwright Assertions - Types & Best Practices
metatags:
title: Playwright Assertions - Types & Best Practices
@@ -17,17 +17,17 @@ import SignUpCta from "/snippets/sign-up-cta.mdx"
-### What are Playwright Assertions?
+### What are Playwright assertions?
Playwright is more than a testing framework. With its generalized tool at simulating user behavior in a browser (or via an API), Playwright is better defined as a web automation framework. You can use Playwright to scrape websites, automate form submissions, or any other time it would be helpful to replace a human web user with a robot. For most users, Playwright is intimately associated with end-to-end tests, and for these we must stop our automated actions and check to see if everything is working right.
To make an automation into a test, we have assertions. When a hard assertion fails, the execution of a Playwright test stops, and following steps are not run.
-### Types of Playwright Assertions
+### Types of Playwright assertions
Playwright offers a variety of assertion types to accommodate different testing scenarios, and there are two broad categories for flexible, Web-first assertions and rigid, brittle, non-retrying assertions. Web-first assertions return promises, since they will return when they are successful or time out, where as non-retrying assertions throw their response immediately.
-### Auto-retrying, Web-first Assertions
+### Auto-retrying, web-first assertions
Auto-retrying assertions automatically recheck conditions until they pass or a timeout is reached. They both make a test more stable, and can make tests execute more quickly, and in the language of game theory should be 'strictly better' than non-retrying assertions.
@@ -64,7 +64,7 @@ Auto-retrying assertions automatically recheck conditions until they pass or a t
| `expect(locator).toBeFocused()` | element is focused. |
| `expect(locator).not.toBeFocused()` | element is not focused. |
-### Non-retrying Assertions
+### Non-retrying assertions
Non-retrying assertions evaluate conditions only once. They are used when you expect a condition to be deterministic and want to avoid any retry logic.
@@ -92,11 +92,11 @@ Non-retrying assertions evaluate conditions only once. They are used when you ex
This makes the most sense when using Playwright to run single end-to-end tests in a controlled environment. If you're using Playwright to run on a cadence and monitor a production system, for example, with [Checkly](/detect/synthetic-monitoring/browser-checks/playwright-support), you generally want to stick with the auto-retrying assertions to avoid unnecessary alerts.
-### Negating Assertions
+### Negating assertions
Negating matchers allow you to assert that a condition does not hold. For example, you can use `toBeFalsy` or `not.toContain` to make negative assertions on a value. If you're checking an element directly, use a locator assertion such as `expect(locator).not.toContainText()` instead, as it implements Playwright's auto-retries.
-### Soft Assertions
+### Soft assertions
Soft assertions won't fail your test immediately, but rather allow the test to continue running after a failure. Using soft assertions is useful for gathering more complete information during test runs. Soft assertions are a critical component of production monitoring, as when measuring things like load times, a failing response time may not mean that we want to stop the check entirely. Any Playwright test with failing soft assertions will still be listed as failed, but the test will still run to completion (or the next hard assertion that fails).
@@ -144,7 +144,7 @@ test("SpaceX-API Dragon Capsules & Next Launch", async ({ request }) => {
In this case if the response has a `200` status code but the API response time is more than 200 milliseconds, the status of this check will be degraded and the slow API response time will be included as a failed step. If the response came back as a non-200 status (indicating an error) then the check would be 'failed,' whether or not `markCheckAsDegraded` was called. You can [configure alert channels](https://www.checklyhq.com/docs/communicate/alerts/channels#managing-alert-channels) to notify you when a check has degraded.
-### Custom Assertions
+### Custom assertions
While Playwright has almost every scenario for testing supported in its core methods, it remains quite customizable, even [allowing custom assertions](https://www.youtube.com/watch?v=Fs-nM747TY4).
@@ -152,7 +152,7 @@ While Playwright has almost every scenario for testing supported in its core met
- `expect.poll`: Polls a condition until it passes or a timeout is reached, useful for dynamic content.
- `expect.toPass`: Runs a block of assertions until all pass, [often used for testing flaky or complex scenarios.](https://www.youtube.com/watch?v=8g7FvoRToGo)
-### When to Use Soft vs Hard Assertions
+### When to use soft vs hard assertions
Soft assertions are helpful for tests where understanding multiple failures is beneficial, such as end-to-end tests with a wide range of checks. Hard assertions are more suitable for critical conditions where a single failure should immediately terminate the test.
@@ -169,18 +169,18 @@ Soft assertions are helpful for tests where understanding multiple failures is b
| **Form field validations** | Yes. Allows collecting errors on multiple fields at once, providing more detailed feedback. | No. Stopping at the first validation failure can hinder broader test coverage. |
| **Verifying the presence of essential elements before action** | No. If the element must exist for the test to continue, a hard assertion ensures reliability. | Yes, if the element's presence is not critical and you want the test to proceed. |
-### How to Get Started with Playwright Assertions in Simple Steps
+### How to get started with Playwright assertions in simple steps
Follow these steps to get up and running with Playwright Assertions:
1. Install Playwright:`npm init playwright@latest`.
2. Start writing tests with various assertion types to validate application behavior.
-### How to Add Custom Matchers Using `expect.extend`
+### How to add custom matchers using `expect.extend`
Custom matchers can be added using `expect.extend`, allowing developers to define more readable or application-specific assertions.
-### Playwright Custom Matchers with Example
+### Playwright custom matchers with example
Here's a quick example of how to create a custom matcher for checking specific conditions:
@@ -208,7 +208,7 @@ expect(100).toBeWithinRange(90, 110)
This can be especially useful if we're doing complex assertions, or specialized parsing of responses.
-## Common Assertion Errors and How to Debug Them
+## Common assertion errors and how to debug them
Understanding how to diagnose assertion failures can save significant debugging time.
@@ -224,7 +224,7 @@ When you have page components you want to ensure are loading quickly, or you hav
After that fixed period, if the next step doesn't work, the test will fail. Hard waits are the most common cause of unreliable or 'flaky' tests with Playwright. They're also inefficient, if the element we're checking for becomes available *before* the hard wait time has elapsed, the test runner still has to wait to the end of the wait time. Read more about this in our page on [waiting in Playwright](https://www.checklyhq.com/learn/playwright/waits-and-timeouts/).
-### Manual Assertions
+### Manual assertions
While a hard wait is problematic since it doesn't benefit from Playwright's auto-waiting, an improperly structured assertion doesn't include waiting at all. By wrapping the `await` inside the `expect()` instead of vice versa, and by using a non-web-first assertion, we get no waiting. In this case we're checking that there is some text inside an element.
@@ -240,15 +240,15 @@ Use web-first assertions such as `toBeEmpty()` instead.
await expect(targetPage.locatorToSomeElement).not.toBeEmpty();
```
-### Debugging Assertion Errors
+### Debugging assertion errors
Playwright provides debug tools such as `page.pause()` and verbose logging to inspect what happens when a test fails. You might also consider a visual like the Playwright VS Code extension to add a visual debugger when writing or debugging tests. [Read more about debugging Playwright scripts](https://www.checklyhq.com/learn/playwright/debugging/).
-### Identifying Flaky Tests
+### Identifying flaky tests
Flaky tests are those that fail intermittently, often due to timing issues or unpredictable environment factors. You can use `expect.poll` and `.toPass` adjust timeouts to [stabilize flaky tests](https://www.youtube.com/watch?v=8g7FvoRToGo). To identify flaky tests you can use `--repeat-each=100` to really hammer a test and see if it passes constantly.
-### Best Practices for Using Playwright Assertions
+### Best practices for using Playwright assertions
Implementing best practices can make your tests more reliable and easier to maintain.
diff --git a/learn/playwright/authentication.mdx b/learn/playwright/authentication.mdx
index 4a3fbb6ba..88df96549 100644
--- a/learn/playwright/authentication.mdx
+++ b/learn/playwright/authentication.mdx
@@ -1,5 +1,5 @@
---
-title: How to Manage Authentication in Playwright
+title: How to manage authentication in Playwright
subTitle: Speeding up tests by skipping login, and more
description: Learn how to handle authentication in Playwright, including SSO, 2FA, Passkeys and more. Reuse authentication state across tests with storageState.
displayDescription: Learn how to handle authentication in Playwright, including SSO, 2FA, Passkeys and more. Reuse authentication state across tests with storageState.
@@ -39,7 +39,7 @@ For web and applications and APIs, you will typically have to run through some i
> Use Playwright’s built-in [code generator](https://playwright.dev/docs/codegen-intro#running-codegen) to quickly get a script of your login steps. It will do the right thing in 90% of the cases. Just run `npx playwright codegen `
-## Basic Auth / Username & Password
+## Basic auth / username & password
Any flow that relies on the Basic Authentication standard or typing in a username and password will tend to look
very similar to example test below.
@@ -64,7 +64,7 @@ Notice the following:
3. At the end, we assert that the login actually worked, by checking for a user specific piece of content on the page.
4. All handling of cookies, hashing of username and password and other things your browser typically takes care of are handled here transparently.
-## SSO & Social Login
+## SSO & social login
Any SSO or social login — think Google, GitHub, Microsoft, SAML-based solutions or any 3rd party auth provider
like Okta— works pretty much the same as basic authentication / username & password from the perspective of the test
@@ -93,7 +93,7 @@ test('Google login', async ({ page }) => {
[Check the full article on Google Login.](https://www.checklyhq.com/learn/playwright/google-login-automation/)
-## Two-Factor Authentication / TOTP
+## Two-factor authentication / TOTP
Things get a little harder when using Two-Factor Authentication (2FA) and / or Time Based One Time Passwords (TOTP).
You will probably be familiar with providing an extra “factor” like a code from an SMS message, a authenticator app
diff --git a/learn/playwright/bypass-totp.mdx b/learn/playwright/bypass-totp.mdx
index eb2b3699b..ec7b41d33 100644
--- a/learn/playwright/bypass-totp.mdx
+++ b/learn/playwright/bypass-totp.mdx
@@ -1,5 +1,5 @@
---
-title: How to Bypass Time-Based 2FA Login Flows With Playwright
+title: How to bypass time-based 2FA login flows with Playwright
description: "Automate logins protected by time-based one-time password (TOTP) two-factor authentication in Playwright by generating valid passcodes inside your test."
subTitle: Playwright for complex authentication tasks
date: 2024-10-30
@@ -9,7 +9,7 @@ tags:
- testing
weight: 5
-sidebarTitle: TOTP Authentication
+sidebarTitle: TOTP authentication
learn_playwright:
parent: "E2E examples"
canonical: 'https://www.checklyhq.com/docs/learn/playwright/bypass-totp/'
diff --git a/learn/playwright/challenging-flows.mdx b/learn/playwright/challenging-flows.mdx
index 4d5c9adbc..91e282036 100644
--- a/learn/playwright/challenging-flows.mdx
+++ b/learn/playwright/challenging-flows.mdx
@@ -1,5 +1,5 @@
---
-title: How to Handle Challenging Automation Flows in Playwright
+title: How to handle challenging automation flows in Playwright
description: "Automate hard-to-test flows like signup, social login, and password reset in Playwright, and get past captchas and bot detection in test environments."
subTitle: Automation countermeasures and shortcomings
date: 2020-07-23
diff --git a/learn/playwright/checkout-testing-guide.mdx b/learn/playwright/checkout-testing-guide.mdx
index 7bb3fd726..122bbfd7b 100644
--- a/learn/playwright/checkout-testing-guide.mdx
+++ b/learn/playwright/checkout-testing-guide.mdx
@@ -1,5 +1,5 @@
---
-title: Mastering E2E Checkout Testing Using Playwright
+title: Mastering E2E checkout testing using Playwright
description: "Write end-to-end checkout tests with Playwright, adding products to a cart, entering billing details, and confirming the purchase completes successfully."
subTitle: Filling a basket and completing the transaction
date: 2020-07-02
diff --git a/learn/playwright/clicking-typing-hovering.mdx b/learn/playwright/clicking-typing-hovering.mdx
index 20b038f40..5e2adcd07 100644
--- a/learn/playwright/clicking-typing-hovering.mdx
+++ b/learn/playwright/clicking-typing-hovering.mdx
@@ -1,5 +1,5 @@
---
-title: How to Click, Type, and Hover with Playwright
+title: How to click, type, and hover with Playwright
description: "Replicate real user interactions in Playwright, clicking buttons, typing into fields, and hovering over elements using user-first selectors."
subTitle: Basic page interactions
date: 2020-06-15
diff --git a/learn/playwright/codegen.mdx b/learn/playwright/codegen.mdx
index 632d165a7..ddf02fcda 100644
--- a/learn/playwright/codegen.mdx
+++ b/learn/playwright/codegen.mdx
@@ -1,5 +1,5 @@
---
-title: Record Automation Scripts Using Playwright Codegen
+title: Record automation scripts using Playwright codegen
description: "Generate Playwright scripts automatically with the codegen command, recording your browser interactions into editable test code with user-first locators."
subTitle: Automatically record Playwright tests with codegen
date: 2025-02-20
@@ -23,7 +23,7 @@ import { YoutubeEmbed } from "/snippets/youtube-embed.jsx"
Did you know that you can use Playwright to generate your automation scripts automatically? Let's dive into how you can leverage Playwright's `codegen` feature to record scripts effortlessly.
-### Step 1: Launch Playwright Codegen
+### Step 1: Launch Playwright codegen
To get started, you'll use the `codegen` command from the Playwright executable. Let's say you want to create a script for interacting with [Checkly](https://checklyhq.com/). You would run the following command in your terminal:
@@ -39,7 +39,7 @@ Note that the inspector will populate with the basic code needed for a Playwrigh
Also, the browser will automatically highlight elements, and show you a locator for them in Playwright’s preferred [user-first selector](https://www.checklyhq.com/blog/playwright-user-first-selectors/) format.
-### Step 2: Interact with the Website
+### Step 2: Interact with the website
Now, you can start interacting with the website as you normally would. For example:
@@ -63,7 +63,7 @@ test('test', async ({ page }) => {
Note that codegen will make a ‘best effort’ at emulating your actions and writing ‘best practice’ code, so you should always review it before deploying.
-### Step 3: Add Assertions to your tests
+### Step 3: Add assertions to your tests
Every action in the script above has implicit assertions about the elements we interact with. Playwright will expect these elements are stable, visible, and enabled; and if one isn’t then the test will fail we could call this done, but we generally want our tests to contain assertions beyond just navigating. There are a few reasons why you should have assertions in your test: It makes it clearer to future coders what your test was checking for, and the error message is more useful from a failed assertion rather than just failing to find an element. Right now all we’ll get if the test above fails is a timeout and a line which failed.
@@ -84,23 +84,23 @@ this will generate a `.toContainText(` assertion in the inspector
Note that the assertions created by codegen are fairly basic, and while they could be the whole basis for a test suite, it’s a great idea to learn about [Playwright assertions](https://www.checklyhq.com/learn/playwright/assertions/) and write more complex ones yourself. You can write any calculable value into an assertion, so the sky is the limit.
-### Step 4: Write tests in Java, Python, .Net or JavaScript - Choose Your Target Environment
+### Step 4: Write tests in Java, Python, .Net or JavaScript - Choose your target environment
After you're done interacting with the website, you can choose the target environment for your script. Playwright allows you to generate scripts in various languages, such as JavaScript, Python, or Playwright's own test framework.
For this example, let's pick JavaScript. You can copy the generated script from the inspector.
-### Step 5: Save and Run Your Script
+### Step 5: Save and run your script
With your script copied, you can drop the test into a Playwright `spec` file, and run it with `npx playwright test` to see the results. Note that the script as generated contains no comments or further explanations. If you want to be considerate of your next coder, who let’s be honest is probably you in 6 months having forgotten everything about this test, add some comments, give the test a more helpful name than `'test'` and [divide the test into steps for readability](https://www.checklyhq.com/blog/improve-your-playwright-documentation-with-steps/).
-### Step 6: Run Your Script in the Cloud
+### Step 6: Run your script in the cloud
If you want to take it a step further, use [Playwright Check Suites](/detect/synthetic-monitoring/playwright-checks/overview) to run your Playwright tests in the Checkly infrastructure as synthetic monitoring.
-### Bonus Step 1: Add Playwright to Visual Studio Code
+### Bonus step 1: Add Playwright to Visual Studio Code
Many developers are now comfortable using Microsoft’s Visual Studio Code as their IDE, and Playwright has a great plugin for Visual Studio Code. Install the [VS Code extension from the marketplace](https://marketplace.visualstudio.com/items?itemName=ms-playwright.playwright) or from the extensions tab in VS Code.
@@ -110,7 +110,7 @@ With the plugin installed, you can record a new test directly into your script f
The plugin has a lot of other neat features including being able to run your tests right from the code editor, and show a browser running your tests. If you’re already using Visual Studio Code, or thinking about adopting it as an IDE, the Playwright plugin is worth checking out!
-### Bonus Step 2: Simulate a Mobile Browser Viewport with `--viewport`
+### Bonus step 2: Simulate a mobile browser viewport with `--viewport`
Playwright can’t perfectly emulate a particular build of Mobile Opera running on a 10-year-old Android, but a good start is simulating a mobile viewport, to see if things render correctly and buttons are still visible. Start by setting your viewport size when you start up codegen:
@@ -125,7 +125,7 @@ Your browser will start up showing the new, narrow viewport
You’ll also notice in the screenshot that the inspector automatically adds a `test.use` command to set the viewport. You can go quite a bit further with these settings, altering the user-agent for your test as needed to [emulate](https://playwright.dev/docs/emulation) different devices.
-## See Codegen in action
+## See codegen in action
To see the highly visual codegen tool in action, check out Stefan’s video below:
diff --git a/learn/playwright/debugging-errors.mdx b/learn/playwright/debugging-errors.mdx
index 543543a5e..c399101e6 100644
--- a/learn/playwright/debugging-errors.mdx
+++ b/learn/playwright/debugging-errors.mdx
@@ -1,5 +1,5 @@
---
-title: Playwright Debugging Errors - Common Issues and Solutions
+title: Playwright debugging errors - Common issues and solutions
description: "Recognize common categories of Playwright errors and their obvious and non-obvious root causes, with links to fixes for the most frequent failures."
subTitle: Recurring non-trivial debugging situations and how to solve them
date: 2021-08-05
diff --git a/learn/playwright/debugging-with-ai-agents.mdx b/learn/playwright/debugging-with-ai-agents.mdx
index 31ca0d514..3df5e0e6e 100644
--- a/learn/playwright/debugging-with-ai-agents.mdx
+++ b/learn/playwright/debugging-with-ai-agents.mdx
@@ -1,5 +1,5 @@
---
-title: Debugging Playwright Tests with AI Agents
+title: Debugging Playwright tests with AI agents
description: "Let your coding agent debug failing Playwright tests: read the error-context.md attachment, analyze traces in the terminal with npx playwright trace, and step through live tests with --debug=cli."
subTitle: Playwright's debugging tools went text-first
tags:
diff --git a/learn/playwright/debugging.mdx b/learn/playwright/debugging.mdx
index 1cd0467bc..55488649e 100644
--- a/learn/playwright/debugging.mdx
+++ b/learn/playwright/debugging.mdx
@@ -1,5 +1,5 @@
---
-title: Playwright Debugging - Techniques for Script Troubleshooting
+title: Playwright debugging - Techniques for script troubleshooting
description: "Troubleshoot failing Playwright scripts by reading error messages in context, understanding expected behavior, and using the right tools to gain visibility."
subTitle: How to go about fixing what is not working
date: 2021-07-26
diff --git a/learn/playwright/error-click-not-executed.mdx b/learn/playwright/error-click-not-executed.mdx
index eb6cef207..db253969a 100644
--- a/learn/playwright/error-click-not-executed.mdx
+++ b/learn/playwright/error-click-not-executed.mdx
@@ -1,5 +1,5 @@
---
-title: How to Fix the "Click Not Executed" Error in Playwright
+title: How to fix the "Click Not Executed" error in Playwright
description: "Diagnose why a Playwright click seems to be ignored, from duplicate element IDs to the wrong element receiving the click, and use strict mode to catch it."
date: 2021-11-18
author: Giovanni Rago
diff --git a/learn/playwright/error-element-not-found.mdx b/learn/playwright/error-element-not-found.mdx
index 7956e891b..233526585 100644
--- a/learn/playwright/error-element-not-found.mdx
+++ b/learn/playwright/error-element-not-found.mdx
@@ -1,5 +1,5 @@
---
-title: How to Fix 'Element Not Found' Errors in Playwright
+title: How to fix 'Element Not Found' errors in Playwright
description: "Fix Playwright's element not found error, from wrong selectors and missing waits to a previous click that silently left you on the wrong page."
date: 2021-08-05
author: Giovanni Rago
diff --git a/learn/playwright/error-element-not-visible.mdx b/learn/playwright/error-element-not-visible.mdx
index 239549e2a..77b4dd651 100644
--- a/learn/playwright/error-element-not-visible.mdx
+++ b/learn/playwright/error-element-not-visible.mdx
@@ -1,5 +1,5 @@
---
-title: How to Fix "Element Not Visible" Error in Playwright
+title: How to fix "Element Not Visible" error in Playwright
description: "Fix Playwright's element not visible error by checking whether an element is hidden or covered by another, using headful mode and screenshots to confirm state."
date: 2021-08-05
author: Giovanni Rago
diff --git a/learn/playwright/error-target-closed.mdx b/learn/playwright/error-target-closed.mdx
index 73ba01b91..f023ac2a8 100644
--- a/learn/playwright/error-target-closed.mdx
+++ b/learn/playwright/error-target-closed.mdx
@@ -1,5 +1,5 @@
---
-title: How to Fix "Target Closed" Error in Playwright
+title: How to fix "Target Closed" error in Playwright
description: "Understand and fix Playwright's Target closed error, usually caused by a browser, context, or tab closing too early or a missing await on a promise."
date: 2021-08-05
author: Giovanni Rago
diff --git a/learn/playwright/error-wait-not-respected.mdx b/learn/playwright/error-wait-not-respected.mdx
index 2c0e60563..25ca4f0df 100644
--- a/learn/playwright/error-wait-not-respected.mdx
+++ b/learn/playwright/error-wait-not-respected.mdx
@@ -1,5 +1,5 @@
---
-title: How to Fix "Wait Not Respected" Error in Playwright
+title: How to fix "Wait Not Respected" error in Playwright
description: "Fix Playwright waits that seem ignored, usually because the element already matches your state requirement, and confirm element state in the browser console."
date: 2021-08-05
author: Giovanni Rago
diff --git a/learn/playwright/file-download.mdx b/learn/playwright/file-download.mdx
index f65988b05..a5046a590 100644
--- a/learn/playwright/file-download.mdx
+++ b/learn/playwright/file-download.mdx
@@ -1,5 +1,5 @@
---
-title: How to Download Files with Playwright
+title: How to download files with Playwright
description: "Download files with Playwright and verify them against a fixture, using either the download event or extracting the href and fetching it with an HTTP request."
subTitle: Different ways of handling downloads
date: 2020-09-09
diff --git a/learn/playwright/generating-pdfs.mdx b/learn/playwright/generating-pdfs.mdx
index 50417981d..b0545c472 100644
--- a/learn/playwright/generating-pdfs.mdx
+++ b/learn/playwright/generating-pdfs.mdx
@@ -1,5 +1,5 @@
---
-title: How to Generate PDFs with Playwright
+title: How to generate PDFs with Playwright
description: "Generate PDFs from web pages with Playwright's page.pdf() command and customize the output for archiving, invoices, and other document automation."
subTitle: Creating invoices, books and more from a web page
date: 2020-11-19
diff --git a/learn/playwright/google-login-automation.mdx b/learn/playwright/google-login-automation.mdx
index f77c70e29..cbd81f7a7 100644
--- a/learn/playwright/google-login-automation.mdx
+++ b/learn/playwright/google-login-automation.mdx
@@ -1,5 +1,5 @@
---
-title: How to Automate Google Login with Playwright
+title: How to automate Google login with Playwright
description: "Automate social login with a Google account in Playwright, injecting credentials through environment variables to sign in via an OAuth provider flow."
subTitle: Dealing with Google authentication
date: 2020-06-22
@@ -8,7 +8,7 @@ githubUser: tnolet
tags:
- login
- e2e
-sidebarTitle: Google Auth
+sidebarTitle: Google auth
weight: 9
learn_playwright:
parent: "E2E examples"
diff --git a/learn/playwright/handling-test-data.mdx b/learn/playwright/handling-test-data.mdx
index 2e8a1fcc5..e5d3db2dc 100644
--- a/learn/playwright/handling-test-data.mdx
+++ b/learn/playwright/handling-test-data.mdx
@@ -1,5 +1,5 @@
---
-title: How to Handle Test Data with Playwright
+title: How to handle test data with Playwright
description: "Keep Playwright tests DRY by factoring out test data and fixtures into dedicated files, so complex end-to-end scenarios stay readable and maintainable."
subTitle: Introduction to fixture handling
date: 2020-07-16
diff --git a/learn/playwright/how-to-parameterize-playwright-projects.mdx b/learn/playwright/how-to-parameterize-playwright-projects.mdx
index 90cfb90fa..29209d32d 100644
--- a/learn/playwright/how-to-parameterize-playwright-projects.mdx
+++ b/learn/playwright/how-to-parameterize-playwright-projects.mdx
@@ -9,7 +9,7 @@ tags:
- e2e
- assertions
weight: 3
-sidebarTitle: Parameterizing Projects
+sidebarTitle: Parameterizing projects
learn_playwright:
parent: "Best practices"
canonical: 'https://www.checklyhq.com/docs/learn/playwright/how-to-parameterize-playwright-projects/'
diff --git a/learn/playwright/how-to-set-up-locally.mdx b/learn/playwright/how-to-set-up-locally.mdx
index 7695001e7..f5fae4081 100644
--- a/learn/playwright/how-to-set-up-locally.mdx
+++ b/learn/playwright/how-to-set-up-locally.mdx
@@ -1,5 +1,5 @@
---
-title: How to Set Up Playwright Locally
+title: How to set up Playwright locally
description: "Install Playwright locally with a single npm command and run your first browser automation script, using Node.js and the bundled browser."
date: 2020-06-20
author: Giovanni Rago
diff --git a/learn/playwright/iframe-interaction.mdx b/learn/playwright/iframe-interaction.mdx
index f2c07b099..06b54d7b3 100644
--- a/learn/playwright/iframe-interaction.mdx
+++ b/learn/playwright/iframe-interaction.mdx
@@ -1,5 +1,5 @@
---
-title: How to Handle iFrames in Playwright
+title: How to handle iFrames in Playwright
description: "Access and interact with iframe content in Playwright using frameLocator to query elements inside a frame as if you were in the page context."
subTitle: Accessing and interacting with iframes
date: 2022-08-25
diff --git a/learn/playwright/intercept-requests.mdx b/learn/playwright/intercept-requests.mdx
index 4f512c657..69bacdc9c 100644
--- a/learn/playwright/intercept-requests.mdx
+++ b/learn/playwright/intercept-requests.mdx
@@ -1,5 +1,5 @@
---
-title: How to Intercept Requests in Playwright
+title: How to intercept requests in Playwright
description: "Observe and manipulate network traffic in Playwright by intercepting requests and responses, logging them or modifying them during a test."
subTitle: Monitoring and manipulating web traffic
date: 2020-09-03
@@ -128,7 +128,7 @@ npx playwright test interception
1. Playwright gives us control over outgoing HTTP requests.
2. Playwright can easily stub HTTP responses.
-## Avoid Network Interception in Synthetic Monitoring
+## Avoid network interception in synthetic monitoring
Network interception is valuable if your primary goal is to test a frontend application in isolation. However, if you want to test your application end-to-end or [use Playwright for synthetic production monitoring with Checkly](/detect/synthetic-monitoring/playwright-checks/overview) you should avoid network interception as much as possible.
diff --git a/learn/playwright/login-automation.mdx b/learn/playwright/login-automation.mdx
index 84a78b570..c28c6a3d1 100644
--- a/learn/playwright/login-automation.mdx
+++ b/learn/playwright/login-automation.mdx
@@ -1,5 +1,5 @@
---
-title: How to Automate Login with Playwright
+title: How to automate login with Playwright
description: "Automate a standard username-and-password login flow with Playwright and assert it succeeded by checking for an element only visible to logged-in users."
subTitle: Automating one of the most common scenarios
date: 2020-06-25
diff --git a/learn/playwright/microsoft-login-automation.mdx b/learn/playwright/microsoft-login-automation.mdx
index c3c44c7c2..fc926dc7d 100644
--- a/learn/playwright/microsoft-login-automation.mdx
+++ b/learn/playwright/microsoft-login-automation.mdx
@@ -1,5 +1,5 @@
---
-title: How to Automate Microsoft Live Login with Playwright
+title: How to automate Microsoft Live login with Playwright
description: "Automate signing in to a Microsoft Live account with Playwright, injecting credentials through environment variables to reach the account page."
subTitle: Dealing with Microsoft authentication
date: 2020-06-22
@@ -8,7 +8,7 @@ githubUser: tnolet
tags:
- login
- e2e
-sidebarTitle: Microsoft Live Auth
+sidebarTitle: Microsoft Live auth
weight: 8
learn_playwright:
parent: "E2E examples"
diff --git a/learn/playwright/mock-api.mdx b/learn/playwright/mock-api.mdx
index 3a52e61bd..b60ad1c91 100644
--- a/learn/playwright/mock-api.mdx
+++ b/learn/playwright/mock-api.mdx
@@ -1,5 +1,5 @@
---
-title: Test Dynamic Content by Mocking API Responses
+title: Test dynamic content by mocking API responses
description: "Stabilize tests for dynamic pages by mocking API responses in Playwright, fixing unpredictable data like stock counts while leaving the rest of the page live."
subTitle: Manipulating and mocking API responses
date: 2025-03-12
@@ -10,7 +10,7 @@ githubUser:
tags:
- network
weight: 125
-sidebarTitle: Mocking API Responses
+sidebarTitle: Mocking API responses
learn_playwright:
parent: "Basics"
canonical: 'https://www.checklyhq.com/docs/learn/playwright/mock-api/'
@@ -65,7 +65,7 @@ Here are some of the paths we could take with dynamic information like a book’
- Not everything is particularly easy to test with regex, for example the `rating` api response here comes back as Unicode stars like “★★★★☆,” which isn’t as straightforward to test with regex as a digit.
4. Modify the API response - Finally the option that gives us high consistency in what we’re testing and what we expect in response. By modifying the API response we can set only the key value pairs that concern us to fixed values, letting the others remain dynamic. We test how the page renders with fixed data, *and* we’re still testing that the API is available.
-## The Solution: Modify an API response with `await *page*.route()`
+## The solution: Modify an API response with `await *page*.route()`
Let’s start by looking at the API response in full, from the network tab of either our browser or the Playwright UI mode. The body looks as follows
@@ -111,7 +111,7 @@ Note that, if you’re using the Playwright UI, this mocking behavior will show
The ‘fulfilled’ listing will show the patched version of your response that went to the page.
-## Going Further: Mocking Whole APIs
+## Going further: Mocking whole APIs
If we’re able to intercept a request and change a single key/value pair, can we replace an entire payload from an API request? Sure, in fact we don’t need to wait for the real API to respond. the new version would look something like this:
@@ -145,7 +145,7 @@ Now we no longer wait for this API response to come back and supply the whole re
The distinct disadvantage is that we’re no longer checking that this API is available. If we’re [testing against production](https://www.checklyhq.com/guides/playwright-testing-to-monitoring/) it would be a good idea to still check that this API is returning data.
-## Going Further: Replacing API responses to stress test our page
+## Going further: Replacing API responses to stress test our page
The last use case for API mocking and response editing is simulating an unusual circumstance on a live page. For example, on our page we expect that a book with zero remaining stock should show up as sold out.
@@ -190,13 +190,13 @@ As we find ourselves testing correct rendering of a page under unusual condition
To go further, see our full documentation on [visual regression checks in Playwright and Checkly](/detect/synthetic-monitoring/browser-checks/visual-regressions#visual-regression-testing).
-## Results and Conclusions: Playwright Mocking and Testing in Production
+## Results and conclusions: Playwright mocking and testing in production
With Playwright mocking you can remain tightly in control of API responses your page is using to render pages for users. This tool can help you in testing against production by ensuring that even with your production pages and data sources, your testing always sees consistent results. The result is more in-depth testing with higher reliability and fewer false alarms. And when a feature isn’t working correctly for users, you can find out before they complain.
With Playwright's powerful API mocking capabilities, you gain precise control over the responses your web pages use to render content for users. This functionality is particularly valuable when testing against production environments, as it ensures consistent results even when dealing with dynamic data sources. By leveraging tools like `page.route()`, you can simulate various scenarios—such as out-of-stock items, unusual data inputs, or edge cases—without needing to alter your production database or backend systems.
-### Key Takeaways:
+### Key takeaways:
1. **Consistency in Testing**: By mocking API responses, you can create stable and reliable tests that are not affected by fluctuating data, such as stock numbers or ratings. This reduces false positives and ensures your tests are always accurate.
2. **Flexibility**: Playwright allows you to modify specific parts of an API response or replace the entire payload, giving you the flexibility to test a wide range of scenarios, from stress testing to edge cases.
@@ -204,14 +204,14 @@ With Playwright's powerful API mocking capabilities, you gain precise control ov
4. **Improved Debugging**: By controlling API responses, you can isolate and test specific UI behaviors, making it easier to identify and fix issues in your application.
5. **Visual Regression Testing**: Mocking dynamic content ensures that visual regression tests are consistent, allowing you to create reliable "golden files" for comparison.
-### When to Use API Mocking:
+### When to use API mocking:
- **Testing Dynamic Content**: Use mocking to stabilize tests for elements that frequently change, such as stock levels, prices, or ratings.
- **Stress Testing**: Simulate unusual or extreme conditions (e.g., zero stock, large numbers, or long text) to ensure your UI handles them gracefully.
- **Edge Case Testing**: Test how your application behaves under rare or unexpected conditions without needing to replicate those conditions in your production environment.
- **Visual Regression Testing**: Ensure consistent screenshots for visual comparisons by fixing dynamic content in place.
-### Limitations and Considerations:
+### Limitations and considerations:
- **Real API Availability**: While mocking is powerful, it’s important to occasionally test against real API responses to ensure your production APIs are functioning correctly.
- **Maintenance**: Mocked responses need to be updated if the structure of your API changes, so keep your mocks in sync with your API contracts.
diff --git a/learn/playwright/multitab-flows.mdx b/learn/playwright/multitab-flows.mdx
index d2dd8c436..b5b5a66f7 100644
--- a/learn/playwright/multitab-flows.mdx
+++ b/learn/playwright/multitab-flows.mdx
@@ -1,5 +1,5 @@
---
-title: Handling Multiple Tabs with Playwright
+title: Handling multiple tabs with Playwright
description: "Control multiple browser tabs in Playwright, opening new pages in a context and interacting with each independently within a single test."
subTitle: Controlling multiple tabs
date: 2021-08-29
diff --git a/learn/playwright/navigation.mdx b/learn/playwright/navigation.mdx
index 3c21feff8..20ce9f051 100644
--- a/learn/playwright/navigation.mdx
+++ b/learn/playwright/navigation.mdx
@@ -1,5 +1,5 @@
---
-title: How to Use Playwright to Navigate and Interact with Web Pages
+title: How to use Playwright to navigate and interact with web pages
displayTitle: How to Use Playwright for Navigation and Interaction
metatags:
title: Navigation & Waiting Strategies in Playwright
diff --git a/learn/playwright/overview.mdx b/learn/playwright/overview.mdx
index 5607b1914..1ab6a469f 100644
--- a/learn/playwright/overview.mdx
+++ b/learn/playwright/overview.mdx
@@ -1,5 +1,5 @@
---
-title: Learn How to Test, Monitor, and Automate with Playwright
+title: Learn how to test, monitor, and automate with Playwright
displayTitle: Learn How to Test, Monitor, and Automate with Playwright
description: Learn more about Playwright automation & monitoring with Checkly. Explore how to automate your web with a reliable, programmable monitoring workflow.
metatags:
@@ -14,7 +14,7 @@ import PlaywrightCheckSuiteTryOut from "/snippets/playwright-check-suite-tryout.
Playwright serves as the foundation for Checkly's synthetic [*Monitoring as Code*](/concepts/monitoring-as-code). To get the most from Checkly, we put together a series of guides and examples to help you get started with Playwright.
-## Getting Started
+## Getting started
-## Check our Playwright Tips YouTube channel
+## Check our Playwright tips YouTube channel
[The Checkly YouTube channel](https://www.youtube.com/@ChecklyHQ) includes over a hundred videos covering synthetic monitoring, Monitoring as Code and Playwright automation. Check out our [Playwright Tips playlist](https://www.youtube.com/playlist?list=PLMZDRUOi3a8NtMq3PUS5iJc2pee38rurc) for bite-sized videos on Playwright best practices, tips and tricks.
-## Diving Deeper
+## Diving deeper
Playwright is extremely powerful and serves a wide range of use cases. We have collected in-depth articles for important scenarios and challenging automation flows.
@@ -69,7 +69,7 @@ Playwright is extremely powerful and serves a wide range of use cases. We have c
-## Popular Posts
+## Popular posts
Learn how to control HTTP requests and responses.
Working with selectors is key for writing high quality scripts.
diff --git a/learn/playwright/performance.mdx b/learn/playwright/performance.mdx
index aae5a2df8..73c92d5bd 100644
--- a/learn/playwright/performance.mdx
+++ b/learn/playwright/performance.mdx
@@ -1,5 +1,5 @@
---
-title: Measuring Page Performance Using Playwright - Best Practices
+title: Measuring page performance using Playwright - Best practices
description: "Measure web page performance with Playwright, understand why speed affects users and revenue, and track browser performance metrics over time."
subTitle: Explaining why it matters and how to assess it
date: 2020-09-30
@@ -62,7 +62,7 @@ Not all of Google's Web Vitals are suitable for synthetic monitoring and perform
**Interaction to Next Paint** relies on user interactions, and it's best measured using real user monitoring. Use **Total Blocking Time** as an interactivity metric in a lab setting instead.
-## Web Performance evaluation with headless tools
+## Web performance evaluation with headless tools
As much as we should be striving to build performant applications, we should commit to monitoring and testing performance to enable continuous feedback and rapid intervention in case of degradation. Playwright provides a great toolkit to power synthetic monitoring and performance testing.
@@ -70,7 +70,7 @@ As much as we should be striving to build performant applications, we should com
2. Whenever testing against Chromium, access to the Chrome DevTools Protocol for traffic inspection, network emulation and more.
3. Easy interoperability with performance libraries from the Node.js ecosystem.
-### Web Performance APIs
+### Web performance APIs
Modern browsers support many APIs to gather web performance metrics and web vitals.
diff --git a/learn/playwright/scraping-behind-login.mdx b/learn/playwright/scraping-behind-login.mdx
index 7d1e17524..1efd87ef4 100644
--- a/learn/playwright/scraping-behind-login.mdx
+++ b/learn/playwright/scraping-behind-login.mdx
@@ -1,5 +1,5 @@
---
-title: How to Scrape Data Behind a Login with Playwright
+title: How to scrape data behind a login with Playwright
description: "Scrape data that sits behind a login wall with Playwright by combining UI automation and scraping, illustrated by totalling Amazon order history."
subTitle: An example in accessing account-specific information
date: 2020-12-23
diff --git a/learn/playwright/script-recorders.mdx b/learn/playwright/script-recorders.mdx
index 4b48de6af..9f961b1ad 100644
--- a/learn/playwright/script-recorders.mdx
+++ b/learn/playwright/script-recorders.mdx
@@ -1,5 +1,5 @@
---
-title: Using Script Recorders with Playwright
+title: Using script recorders with Playwright
description: "Speed up script creation with Playwright recorders like codegen and the VS Code extension, then refine the generated selectors and waits for reliability."
subTitle: Generating scripts for beginners and pros
date: 2020-09-16
diff --git a/learn/playwright/selectors.mdx b/learn/playwright/selectors.mdx
index 9b7b442bd..7f60826e1 100644
--- a/learn/playwright/selectors.mdx
+++ b/learn/playwright/selectors.mdx
@@ -1,5 +1,5 @@
---
-title: How to Work with Selectors in Playwright
+title: How to work with selectors in Playwright
displayTitle: How to Work with Selectors in Playwright
description:
Learn to write solid scripts using Playwright. Discover how to choose stable selectors and start enhancing your skills today.
@@ -25,7 +25,7 @@ import { YoutubeEmbed } from "/snippets/youtube-embed.jsx"
When testing and monitoring websites end to end with Playwright, choosing the right locators is crucial. Proper locators help create tests that are less flaky and more reliable. Let's explore user-first locators and how to filter locators for more robust tests.
-## Example Scenario
+## Example scenario
Consider a simple web page with a headline, a button, and a status update box. Clicking the button updates the status and throws confetti. Here's how we can test this.
@@ -45,10 +45,10 @@ If a frontend engineer changes the class for style reasons to read `button-hero-
If our button text is coming from a CMS, and it breaks, the button text could change to "HEROBUTTON_TXT" and our test would still pass, despite the UI being broken for the user, a false negative.
Due to the reasons above, the Playwright project encourages you to not use CSS locators, and it's a good idea to follow the standards set down in the project!
-### Instead of CSS selectors, try User-First Locators
+### Instead of CSS selectors, try user-first locators
Playwright offers a number of locators that are based on page role, a more functional view of the page than finding by CSS or HTML. Use [the recommended built-in locators](https://playwright.dev/docs/locators#quick-guide) like `getByRole`, `getByText`, and `getByLabel`, which will all work the same in the test that they will for the user, even if the user is using an unusual browser build, mobile device, or even a screen reader!
-## User-First Locators in Action
+## User-first locators in action
Let's replace `page.locator` with `getByRole` to locate the button by its role and accessible name:
```ts
@@ -73,7 +73,7 @@ After all, if nothing has unique labels it means that screen readers and keyboar
In the short term, take a look at all of Playwright's locators, as there are definitely techniques that will find any element on your page, but I encourage you to use this as a jumping off point for tech debt conversations in the future.
-### Handling Multiple Matching Elements
+### Handling multiple matching elements
If a locator matches multiple elements, Playwright's strict mode will fail. For example, using `getByRole('button')` might match several buttons. You'll get an error that reads something like:
```
@@ -85,7 +85,7 @@ Error: locator.click: Error: strict mode violation:
Note that in strict mode this test will fail even if the first result, or all the results, passes the rest of the test. Resolve this by specifying the position or filtering elements.
-#### Position-Based Selection
+#### Position-based selection
When we first run into this error, the easiest solution is just to specify a position in a list. The simplest being to take the first result:
```ts
@@ -106,7 +106,7 @@ await page.getByRole('button').nth(3).click()
The .nth() function is zero-indexed, so .nth(3) will select the fourth item in the results. Positional selectors work, but they can be brittle, if we have dynamic page content, selecting anything but the first result may present a false positive. To be really sure that we're pointing to the correct element in a dynamic list, do a bit of element filtering.
-#### Element Filtering in Playwright
+#### Element filtering in Playwright
If we imagine an e-store interface, with a number of results only some of which are available, we can see that a position selector isn't going to test reliably.

@@ -123,7 +123,7 @@ await button.click()
This test would now fail about when the user would expect it to: when they see a list of items, all marked as sold out.
-## Best Practices for Page Locators
+## Best practices for page locators
There is no one-size-fits-all solution for locators. Here are some tips:
diff --git a/learn/playwright/steps-decorators.mdx b/learn/playwright/steps-decorators.mdx
index dce16c9af..f08f4e87c 100644
--- a/learn/playwright/steps-decorators.mdx
+++ b/learn/playwright/steps-decorators.mdx
@@ -1,5 +1,5 @@
---
-title: Self-documenting tests - add automatic Playwright steps with TypeScript Decorators
+title: Self-documenting tests - add automatic Playwright steps with TypeScript decorators
description: "Structure complex Playwright tests with a single @step TypeScript decorator, replacing repetitive test.step calls to make reports easier to scan."
subTitle: Understand tests better with steps
date: 2024-11-15
@@ -9,7 +9,7 @@ tags:
- typescript
weight: 7
-sidebarTitle: Automatic Steps
+sidebarTitle: Automatic steps
learn_playwright:
parent: "Best practices"
canonical: 'https://www.checklyhq.com/docs/learn/playwright/steps-decorators/'
@@ -156,7 +156,7 @@ In practice this means, that you can use modern JavaScript features in TypeScrip
One of these modern JavaScript features is decorators. JavaScript Decorators aren't supported anywhere but work if you use TypeScript.
-### JavaScript Decorators — a proposal that's been in the making forever.
+### JavaScript decorators — a proposal that's been in the making forever.
[The JavaScript decorator spec proposal](https://github.com/tc39/proposal-decorators) saw the light of day eight years ago and reached ECMAScript proposal stage three. Proposals on stage three are considered "ready to implement".
diff --git a/learn/playwright/taking-screenshots.mdx b/learn/playwright/taking-screenshots.mdx
index 0492174a8..5cf72ab6d 100644
--- a/learn/playwright/taking-screenshots.mdx
+++ b/learn/playwright/taking-screenshots.mdx
@@ -1,5 +1,5 @@
---
-title: Playwright Screenshots - How to Take and Automate Screenshots
+title: Playwright screenshots - How to take and automate screenshots
description: "Capture screenshots with Playwright's page.screenshot command, take full-page images, and automate visual comparisons to catch regressions."
subTitle: Leveraging images for troubleshooting and more
date: 2020-06-23
diff --git a/learn/playwright/test-fixtures.mdx b/learn/playwright/test-fixtures.mdx
index d100bd8f3..37df435e8 100644
--- a/learn/playwright/test-fixtures.mdx
+++ b/learn/playwright/test-fixtures.mdx
@@ -11,7 +11,7 @@ tags:
- assertions
weight: 7
-sidebarTitle: Test Fixtures
+sidebarTitle: Test fixtures
learn_playwright:
parent: "Best practices"
canonical: 'https://www.checklyhq.com/docs/learn/playwright/test-fixtures/'
@@ -25,7 +25,7 @@ import { YoutubeEmbed } from "/snippets/youtube-embed.jsx"
Playwright's test fixtures are a powerful feature for sharing setup and logic across tests, promoting code reuse and maintainability. With custom fixtures, you can share code across multiple tests, resulting in a test base that is easier to expand and easier to maintain.
-## Understanding Playwright Test Fixtures
+## Understanding Playwright Test fixtures
At their core, fixtures in Playwright are predefined components like `page`, `context`, `browser`, and `browserName` that you can use across different test cases. They encapsulate functionality into modular blocks, simplifying test code.
@@ -51,11 +51,11 @@ test('test', async ({ page }) => {
This is a fine practice for a single test, but if we have dozens that all require login as a first step, we'll find ourself copying and pasting this code several times. This means a lot of copied code, such that if we ever tweak the login process, we'll have to update this copied code in dozens of places, not good!
-## Playwright and Fixtures
+## Playwright and fixtures
Playwright and its test runner Playwright Test, were designed with a broader testing scope and includes first-class support for fixtures. This design choice streamlines the setup and teardown process, making tests cleaner and reducing redundancy.
-### Built-in Support
+### Built-in support
Playwright's test runner provides a rich set of predefined fixtures, such as `browser`, `context`, `page`, and `request`, and allows for easy customization and extension of these fixtures. This built-in support enables more structured and maintainable tests, with less manual setup required.
@@ -73,13 +73,13 @@ test('My authenticated test', async ({ page }) => {
The ability to extend and customize fixtures in Playwright not only reduces boilerplate but also enhances test isolation and reusability across your test suite.
-## Create a Custom Test Fixture in Playwright Test
+## Create a custom test fixture in Playwright Test
Imagine testing a web application where multiple tests require logging in. Repeating login logic in every test is inefficient and violates the DRY (Don't Repeat Yourself) principle.
Let's implement __a fixture to reuse and share code across Playwright test cases__.
-### Step 1: Extend the Test Object
+### Step 1: Extend the test object
First, create a new test file or use an existing one. Here, we're testing a web application with Playwright, accessing environment variables, and performing UI interactions.
@@ -111,7 +111,7 @@ const test = baseTest.extend({
By using custom fixtures, test cases can reuse code defined in the `test.extend` call. In this case, all tests using the extended `test` method can rely on the `webApp` fixture.
-### Step 2: Use the Custom Fixture
+### Step 2: Use the custom fixture
With the `webApp` fixture defined, you can use it in your tests. The fixture code will only run when a test "requests" to use it. For example, the custom `webApp` fixture will only be executed if a test case uses it.
@@ -125,11 +125,11 @@ test('My webApp test', async ({ webApp }) => {
The `webApp` fixture encapsulates the login logic, making it accessible to any test that requires it.
-### Step 3: Debugging and Validation
+### Step 3: Debugging and validation
Debugging is crucial to ensure your fixture works as expected. Playwright's inspector is invaluable here, allowing you to step through test execution and verify the setup and teardown processes.
-### Step 4: Sharing Across Tests
+### Step 4: Sharing across tests
To share your custom fixture across different test files, encapsulate it in a separate module:
@@ -151,13 +151,13 @@ This approach keeps your tests clean and focused, with shared logic abstracted i
-## Replace `beforeEach` / `afterEach` Hooks with Automatic Fixtures
+## Replace `beforeEach` / `afterEach` hooks with automatic fixtures
As explained in the previous section, fixtures enable the sharing and distributing of code across Playwright tests. By default, fixture code is only executed when a test case accesses a fixture. But there are scenarios in which you always want to run your fixture code, like global `beforeEach` and `afterEach` hooks.
Let's implement __an automatic fixture to log the current time before and after every test case__.
-### Define an Automatic Fixture
+### Define an automatic fixture
If you want to run code before and after each test case, you can reach for the commonly known `beforeEach` and `afterEach` hooks.
@@ -231,7 +231,7 @@ import { expect } from '@playwright/test';
Custom test fixtures in Playwright streamline test setup and teardown, fostering code reuse and reducing boilerplate. Encapsulating common functionality, such as user logins or global setups, into fixtures ensures your tests are cleaner, more maintainable, and easier to read.
-### Playwright Fixtures Explained on YouTube
+### Playwright fixtures explained on YouTube
To discover more practical fixture examples, check out our [YouTube playlist](https://www.youtube.com/watch?v=hegZS46J0rA&list=PLMZDRUOi3a8N067UNvkxXEThKlTII_OJ-), which covers fixtures in even more depth.
diff --git a/learn/playwright/testing-apis.mdx b/learn/playwright/testing-apis.mdx
index 4c1e5ac8d..40b3eb95e 100644
--- a/learn/playwright/testing-apis.mdx
+++ b/learn/playwright/testing-apis.mdx
@@ -33,7 +33,7 @@ In this API, you might request a list of countries along with their codes and la
This is a GraphQL api, which is supported in Playwright. GraphQL works by sending a POST request with a query in the request body. Let’s see how to write a Playwright test for this API.
-## The Test Case
+## The test case
To get started, let’s look at a basic test using Playwright. Below is an api.ts file that defines a test case doing little more than ensuring that our GraphQL API is responding with expected data.
```ts api.spec.ts
@@ -142,7 +142,7 @@ test('the GraphQL API works for one country', async ({ request }) => {
This test now validates a filtered response, all within the same Playwright test case.
-## Continuous Monitoring with Playwright and Checkly
+## Continuous monitoring with Playwright and Checkly
By running multiple small API requests from within Playwright, you can verify the underlying APIs you need for your pages. If you want to monitor all your API endpoints continually, check out Checkly’s API monitors. Checkly API monitors let you run on a schedule with dynamic [notification settings](/communicate/alerts/configuration) and [retries](/communicate/alerts/retries), run from multiple geographies, and even [run setup and teardown scripts](/detect/synthetic-monitoring/api-checks/setup-and-teardown) to add logic for your test, and clean up after your test.
diff --git a/learn/playwright/testing-coupons.mdx b/learn/playwright/testing-coupons.mdx
index 7681dd383..3b6cfe5d9 100644
--- a/learn/playwright/testing-coupons.mdx
+++ b/learn/playwright/testing-coupons.mdx
@@ -1,5 +1,5 @@
---
-title: How to Test Coupons and Discounts with Playwright
+title: How to test coupons and discounts with Playwright
description: "Verify coupon and discount codes with Playwright by adding items to a cart and asserting the total price changes by the expected amount after applying the code."
subTitle: Applying and verifying a discount
date: 2020-07-13
diff --git a/learn/playwright/testing-file-uploads.mdx b/learn/playwright/testing-file-uploads.mdx
index 2c7042401..9ce9c83b3 100644
--- a/learn/playwright/testing-file-uploads.mdx
+++ b/learn/playwright/testing-file-uploads.mdx
@@ -1,5 +1,5 @@
---
-title: How to Test File Uploads with Playwright
+title: How to test file uploads with Playwright
description: "Test file upload functionality with Playwright by logging in and attaching a file, using a profile-image upload as a worked example."
subTitle: Modifying account settings with a file upload
date: 2020-07-22
diff --git a/learn/playwright/testing-in-parallel.mdx b/learn/playwright/testing-in-parallel.mdx
index 6934d0ce9..d84d014e8 100644
--- a/learn/playwright/testing-in-parallel.mdx
+++ b/learn/playwright/testing-in-parallel.mdx
@@ -25,7 +25,7 @@ Playwright offers robust capabilities for automating browser tests. However, a c
This post describes strategies for running Playwright tests in parallel, sequence, or both while optimizing your testing workflow for efficiency and reliability.
-## Understanding Test Types: stateful vs stateless
+## Understanding test types: stateful vs stateless
Before getting into the technicalities of test execution, you must categorize your tests into two main types: stateless and stateful.
@@ -36,7 +36,7 @@ Before getting into the technicalities of test execution, you must categorize yo
Tests that start and rely on a state created by a previous test are typically considered antipatterns. Tests should create and clean up their own state to avoid cluttering test environments and enable parallelization.
-## Playwright's Default Test Execution
+## Playwright's default test execution
Before you start wondering how to parallelize all your Playwright tests, be aware that you probably run some of your tests in parallel already.
@@ -54,7 +54,7 @@ The execution model can be changed in multiple ways if you want to parallelize m
Let's look at common execution scenarios and their required configuration.
-## Running Tests Sequentially
+## Running tests sequentially
While parallel execution is efficient, specific scenarios require running tests sequentially. This is especially true for destructive and stateful tests, where ensuring a predictable and unaltered environment state is crucial for test accuracy.
@@ -93,7 +93,7 @@ npx playwright test --workers=1 --project=sequential
You can run a subset of test files, grep for specific test tags, or define a separate project to run tests sequentially. None of these approaches is better; you must decide what fits your project best.
-## Running Tests in Parallel
+## Running tests in parallel
Thanks to Playwright's automatic encapsulation and easy-to-use worker functionality, the test runner naturally excels at executing tests in parallel, significantly reducing the time it takes to execute your entire test suite.
@@ -174,11 +174,11 @@ test('One', async () => { /* ... */ });
test('Two', async () => { /* ... */ });
```
-## Leveraging Playwright's Flexibility
+## Leveraging Playwright's flexibility
Playwright's design accommodates various testing strategies, allowing developers to tailor test execution to their project's needs. Whether running tests in parallel to save time or sequentially to ensure environment stability, Playwright provides the tools necessary to configure your testing environment effectively.
-### Tips for Organizing Tests
+### Tips for organizing tests
- Use directories, tags or projects to separate stateful and stateless tests and apply appropriate parallel or sequential execution modes.
- Name your test files strategically if relying on alphabetical execution order for sequencing.
diff --git a/learn/playwright/testing-pyramid.mdx b/learn/playwright/testing-pyramid.mdx
index cf3ccff15..f8fd3f40b 100644
--- a/learn/playwright/testing-pyramid.mdx
+++ b/learn/playwright/testing-pyramid.mdx
@@ -1,5 +1,5 @@
---
-title: The Layers of the Testing Pyramid
+title: The layers of the testing pyramid
description:
This article gives a tour of the testing pyramid’s layers with examples, and shows you how each part is required for a complete picture of system performance.
date: 2025-04-01
@@ -26,7 +26,7 @@ When you begin your journey in QA, SRE, Development, or Operations, you’ll ask
We know our app is working by testing, but this begs the question: who should test what, when? Let’s take the tiniest possible failure: trailing whitespace in user data. Should the React frontend refuse to submit form fields with extra whitespace, should the application automatically remove whitespace before sending database requests, or should the DB controller automatically remove whitespace? The question: “in what layer should these checks happen?” brings us to the testing pyramid.
-## The Testing Pyramid in Full
+## The testing pyramid in full
Originally conceived by Mike Cohn, and then popularized by Martin Fowler, the testing pyramid shows categories of tests, with the slowest on top and the fastest on the bottom.
@@ -39,7 +39,7 @@ The pyramid shape refers to the ideal distribution of tests: you should have doz
Next let’s briefly describe the layers, along with how they work in a modern cloud native architecture.
-## Unit Tests - with examples
+## Unit tests - with examples
A unit test is a highly isolated test that only works with a tiny chunk of code, possibly the code in a single file, or even a single function. A unit test is by its nature extremely high performance, and can run as frequently as the developer saves her work (or even with every entered newline).
@@ -184,7 +184,7 @@ await page.locator('#item-to-be-dragged').dragTo(page.locator('#item-to-drop-at'
At base, the advantage of end-to-end testing is that it answers the real question of testing: ‘will this work for users or not?’ the other phases of testing answer questions more akin to: ‘does this code function without throwing errors?’ or ‘is this service fulfilling its contract to other services?’ Those are important questions for earlier phases of the SDLC. But once our tests are going into the hands of users, we must simulate that real user behavior and record if everything works.
-### From E2E Testing to E2E Monitoring
+### From E2E testing to E2E monitoring
If we agree on the importance of end-to-end testing, it begs the question if testing should stop after deploy time. Thousands of unforseen interactions can break a production service even after the code is tested post-deployment, and our users are certainly using the service all the time. Shouldn’t our testing also continue after the code is out? For end-to-end testing on a cadence, there’s Checkly, which uses the power of Playwright to test your sites, services, and APIs around the clock. [Get started today](https://www.checklyhq.com/docs/)!
@@ -192,7 +192,7 @@ If we agree on the importance of end-to-end testing, it begs the question if tes
While it sadly causes many arguments about which tests belong where or which layer is most important, the testing pyramid is meant to acknowledge that each test type has a role to play, and the differences in performance is natural.
-## Conclusions: Every Layer of Testing Matters
+## Conclusions: Every layer of testing matters
We care about testing because ultimately there’s one layer of testing that no one wants to use: our users. If there’s a bug, they’ll find it, if there’s holes in a data flow, their data will fall into it. If there’s an edge case our users will find it. And every time a user is the first one to detect a problem, it hurts their trust in our service.
@@ -205,7 +205,7 @@ While the boundaries between these layers can sometimes blur, their collective p
Ultimately, the goal is not to rigidly categorize tests but to ensure comprehensive validation at every stage. Whether you're writing unit tests for a utility function, mocking service interactions in integration tests, or automating user journeys with Playwright, each layer contributes to a more robust, resilient application. The testing pyramid isn’t just a model—it’s a reminder that quality is built step by step, from the smallest unit to the full user experience.
-## Dive Deeper into the Testing Pyramid with Real World Applications
+## Dive deeper into the testing pyramid with real world applications
In a recent Webinar, the Checkly team got to talk about how the Testing Pyramid affects testing strategies for real world applications like React apps. Watch the whole session here:
diff --git a/learn/playwright/user-signup-automation.mdx b/learn/playwright/user-signup-automation.mdx
index 0fda0d98c..a6d37341a 100644
--- a/learn/playwright/user-signup-automation.mdx
+++ b/learn/playwright/user-signup-automation.mdx
@@ -1,5 +1,5 @@
---
-title: Automating User Signup with Playwright
+title: Automating user signup with Playwright
description: "Automate user signup flows with Playwright by filling registration forms, submitting them, and confirming the account was created through a UI change."
subTitle: Handling signups flows
date: 2020-06-30
diff --git a/learn/playwright/web-scraping.mdx b/learn/playwright/web-scraping.mdx
index 324d2d8d7..f7c9f6f47 100644
--- a/learn/playwright/web-scraping.mdx
+++ b/learn/playwright/web-scraping.mdx
@@ -1,5 +1,5 @@
---
-title: Playwright Web Scraping - How to Extract Data from Websites
+title: Playwright web scraping - How to extract data from websites
description: "Extract data from web pages with Playwright, reading element attributes and properties for testing assertions or general-purpose scraping."
subTitle: Extracting valuable information through automation
date: 2020-08-26
diff --git a/learn/playwright/what-is-playwright.mdx b/learn/playwright/what-is-playwright.mdx
index 9ea879eae..1861ec16d 100644
--- a/learn/playwright/what-is-playwright.mdx
+++ b/learn/playwright/what-is-playwright.mdx
@@ -1,5 +1,5 @@
---
-title: Beginner’s Guide to Playwright Automation
+title: Beginner’s guide to Playwright automation
description:
Learn how Playwright, a browser automation tool, simplifies testing across Chrome, Firefox, and WebKit. Start building more reliable web applications today.
date: 2020-06-29
@@ -36,7 +36,7 @@ End-to-end tests have the reputation of being flaky and slow, while also requiri
Playwright overcomes flaky and slow tests by communicating with rendering engines via the WebSocket protocol, instead of through multiple HTTP requests, as is done with other web automation testing tools like Selenium. Playwright communicates all requests through a single web socket connection that remains active until all tests have been completed. This reduces points of test failure during test execution, providing a stable and fast solution.
-## Playwright Features
+## Playwright features
While taking a simplified approach to its design, Playwright offers many features that make it unique, but competitive with several other leading test automation tools, like Cypress and Puppeteer. While we’ve discussed some of the key features in more detail above, some additional noteworthy features include:
@@ -61,7 +61,7 @@ While taking a simplified approach to its design, Playwright offers many feature
4. **Scraping web sites for data:** extracting data from websites for later retrieval or analysis.
5. **Automating interaction of web pages:** speed up and scale any sort of sequence of actions we would like to perform on a website automatically.
-## Growth and Adoption
+## Growth and adoption
Since its release in January 2020 by Microsoft, Playwright has experienced a surge in usage and popularity. As of January 2026, its GitHub repository has received 80k stars and 5k forks, and is currently averaging more than 32 million NPM downloads per week. Playwright is used by enterprise and open-source development projects alike, including Adobe Spectrum, Visual Studio Code, and React Navigation.
diff --git a/learn/playwright/writing-tests.mdx b/learn/playwright/writing-tests.mdx
index 785c3678f..c6c2448a5 100644
--- a/learn/playwright/writing-tests.mdx
+++ b/learn/playwright/writing-tests.mdx
@@ -1,5 +1,5 @@
---
-title: Best Practices for Writing Tests in Playwright
+title: Best practices for writing tests in Playwright
description: "Write valuable, maintainable Playwright tests by keeping scripts short, simple, and readable, so they keep telling the truth about your system as it evolves."
subTitle: Principles for sustainable automated testing
date: 2020-07-16
diff --git a/platform/allowlisting-traffic.mdx b/platform/allowlisting-traffic.mdx
index efc7d65e1..c5d4f580d 100644
--- a/platform/allowlisting-traffic.mdx
+++ b/platform/allowlisting-traffic.mdx
@@ -1,7 +1,7 @@
---
-title: 'Allowlisting Traffic'
+title: 'Allowlisting traffic'
description: 'Allowlisting traffic to Checkly'
-sidebarTitle: 'Allowlisting Traffic'
+sidebarTitle: 'Allowlisting traffic'
canonical: 'https://www.checklyhq.com/docs/platform/allowlisting-traffic/'
---
@@ -192,7 +192,7 @@ await page.goto('https://app.checklyhq.com/login?utm_source=monitoring')
For detailed instructions, see [the Google Analytics docs on custom filters](https://support.google.com/analytics/answer/1033162#CustomFilters).
Note that this will take some hours for this to take effect.
-## CloudFlare Verified Bot
+## CloudFlare verified bot
Checkly is also registered with CloudFlare as a [verified bot](https://developers.cloudflare.com/bots/concepts/bot/verified-bots/). If you are using CloudFlare's Web Application Firewall (WAF) to protect your site, you can also allow traffic from Checkly by adding a [custom WAF rule](https://developers.cloudflare.com/waf/custom-rules/) to enable traffic from verified bots.
diff --git a/platform/data-storage.mdx b/platform/data-storage.mdx
index 491ae379d..5bd7c2d86 100644
--- a/platform/data-storage.mdx
+++ b/platform/data-storage.mdx
@@ -1,7 +1,7 @@
---
title: 'How we store data'
description: 'Learn about how Checkly stores check run data'
-sidebarTitle: 'Data Storage'
+sidebarTitle: 'Data storage'
canonical: 'https://www.checklyhq.com/docs/platform/data-storage/'
mode: "wide"
---
@@ -14,7 +14,7 @@ Every check we run generates a certain amount of data. We call these the "result
- Screenshot files
- Run logs with debug or `console.log` statements.
-## Data Retention
+## Data retention
Depending on your plan we keep the results data according to the following retention policy:
diff --git a/platform/dynamic-secret-scrubbing.mdx b/platform/dynamic-secret-scrubbing.mdx
index b022b8ffa..dcd4ec222 100644
--- a/platform/dynamic-secret-scrubbing.mdx
+++ b/platform/dynamic-secret-scrubbing.mdx
@@ -1,6 +1,6 @@
---
-title: 'Dynamic Secret Scrubbing'
-sidebarTitle: 'Secret Scrubbing'
+title: 'Dynamic secret scrubbing'
+sidebarTitle: 'Secret scrubbing'
description: 'Scrub sensitive data from check results'
canonical: 'https://www.checklyhq.com/docs/platform/dynamic-secret-scrubbing/'
---
diff --git a/platform/filters.mdx b/platform/filters.mdx
index 18df3d605..a7dd17ac0 100644
--- a/platform/filters.mdx
+++ b/platform/filters.mdx
@@ -83,7 +83,7 @@ Text without a field searches the project name.
| Tags | The tags of a check that ran in the session, and of its group. |
| File | The Playwright test file of a check that ran in the session. |
-### Error Groups
+### Error groups
The **Error Groups** tab has its own filters. Switching between it and the **Test Sessions** tab clears them. Text without a field searches the error message. The time range keeps the error groups last seen within it.
diff --git a/platform/groups.mdx b/platform/groups.mdx
index 7836f9697..4fe91cf70 100644
--- a/platform/groups.mdx
+++ b/platform/groups.mdx
@@ -24,7 +24,7 @@ By default, newly created check groups behave like folders, with no group-level
Groups let you apply shared configuration to standardize how checks behave. Depending on the setting, group-level configuration either overrides check-level settings or is merged with them.
-### Check Membership
+### Check membership
**Moving a check into a group:** If the group has group-level configuration defined, adding a check may change how it runs. Settings like API defaults, locations & scheduling, or retries & alerting can override the check's configuration.
**Removing check from group:** Any group-level configuration will no longer apply, and the check will use its own configuration going forward.
@@ -68,7 +68,7 @@ An example:
2. At the API check level, you define the same header `X-Custom` just with the value `abc`
3. Checkly will call your API with the `X-Custom: abc` header
-#### Basic Auth
+#### Basic auth
Use the basic auth username and password to inject it into each API check in the group.
@@ -116,12 +116,12 @@ Or, in other words: **check** variables trump **group** variables trump **global
You can make use of this by providing a default value for a specific variable at the global or group level, but allow
that variable to be overridden at the group level or check level.
-### Scheduling & Locations
+### Scheduling & locations
- **Locations:** Override location settings for all checks in the group with selected public or private locations
- **Scheduling strategy:** Override scheduling strategy (parallel, round-robin) for all checks in the group
- **Frequency:** Each check runs at its own frequency. When you use the CLI, the `frequency` property of a group sets a default for the checks you define in that group.
-### Retries & Alerting
+### Retries & alerting
- **Retries:** Configure retry strategy for failed checks (fixed, single, linear, exponential)
- **Alert settings:** Set up alert channels for the group - email, SMS, Slack, webhooks, etc. When you enable the group override, these settings replace the alert settings of every check in the group.
@@ -130,7 +130,7 @@ Turning on **Group override for alert settings** selects **Use the global accoun
-### Testing & Runtimes
+### Testing & runtimes
- **Testing:** Run checks in this group as E2E tests locally or from CI/CD pipelines
- **Runtimes:** Set the JavaScript runtime environment for Browser checks and scripts if different from account default
@@ -138,7 +138,7 @@ Turning on **Group override for alert settings** selects **Use the global accoun
-## How Grouped Checks Execute
+## How grouped checks execute
Understanding how grouped checks run is important for sophisticated monitoring setups:
@@ -150,7 +150,7 @@ Understanding how grouped checks run is important for sophisticated monitoring s
Groups are primarily configuration containers that provide shared settings and organizational structure. This approach ensures flexibility while enabling powerful configuration management at scale.
-## Flexible Configuration Strategy
+## Flexible configuration strategy
Groups can serve different organizational needs:
@@ -160,7 +160,7 @@ Groups can serve different organizational needs:
- **Scaling mechanism:** Manage complexity through logical decomposition as your infrastructure grows
-## Mixing Checks and Monitors in a Group
+## Mixing checks and monitors in a group
When you purchase a plan in Checkly, it includes access to specific monitoring features. As shown on our [pricing page](https://www.checklyhq.com/pricing), feature availability can differ between:
diff --git a/platform/ip-information.mdx b/platform/ip-information.mdx
index afdd59143..30657fc8b 100644
--- a/platform/ip-information.mdx
+++ b/platform/ip-information.mdx
@@ -1,7 +1,7 @@
---
-title: IP Information & Versions
+title: IP information & versions
description: "Understand Checkly's dual-stack IPv4 and IPv6 support, how address resolution is prioritized, and where to find the static IP ranges for allowlisting."
-sidebarTitle: IP Information
+sidebarTitle: IP information
tags: ['ip-information']
canonical: 'https://www.checklyhq.com/docs/platform/ip-information/'
---
diff --git a/platform/managing-false-positives.mdx b/platform/managing-false-positives.mdx
index fdbe0b31c..168ca6159 100644
--- a/platform/managing-false-positives.mdx
+++ b/platform/managing-false-positives.mdx
@@ -1,7 +1,7 @@
---
-title: 'Managing False Positives'
+title: 'Managing false positives'
description: 'Managing False Positives in Checkly'
-sidebarTitle: 'Managing False Positives'
+sidebarTitle: 'Managing false positives'
canonical: 'https://www.checklyhq.com/docs/platform/managing-false-positives/'
---
@@ -13,7 +13,7 @@ At Checkly, we aim to help you achieve the lowest false positive rate in the mar
Read on to learn more about common causes of performance variations and strategies to minimize the false positives they can cause.
-## Common Causes of Performance Variations
+## Common causes of performance variations
When setting up your monitoring strategy, it's important to consider a few common factors that can affect networking performance:
@@ -25,11 +25,11 @@ When setting up your monitoring strategy, it's important to consider a few commo
While these factors are generally well-managed, they can't be completely avoided. However, you can take steps to make your monitoring setup more resilient.
-## Best Practices to Minimize False Positives
+## Best practices to minimize false positives
False positives caused by network variations can lead to unnecessary alerts, but you can keep them under control by following these best practices:
-### Use Retries
+### Use retries
Retries are your first line of defense against transient issues. By setting up retries, your checks can automatically try again if the first attempt fails because of a temporary glitch. This reduces the impact of brief disruptions and helps prevent false positives.
@@ -37,7 +37,7 @@ While you might want to adjust based on specific use cases, we suggest implement
Learn more about implementing retries: [Retries at Checkly](/communicate/alerts/retries).
-### Optimize Your Regional Monitoring
+### Optimize your regional monitoring
Running checks from a specific region is important when you need to monitor your app’s performance in that area. To identify localized failures, implementing retries can help confirm whether the issue is temporary or persistent. However, if you want to understand whether an issue is more widespread, running checks from multiple regions can help you determine if it’s a broader problem with your app.
@@ -45,7 +45,7 @@ Depending on your use case, we recommend running checks from at least two differ
Learn more about setting up multi-location checks: [Global Location and Scheduling Strategies](/concepts/locations).
-### Fine-Tune Your Alerting
+### Fine-tune your alerting
Adjust your alert settings to avoid unnecessary notifications. For example, you can require failures in multiple regions or after several retries before firing off an alert. This helps you avoid alerts for short-lived, isolated failures that don’t need immediate attention.
@@ -53,7 +53,7 @@ A good starting point is to set alerts to trigger only after a check has failed
Learn more about fine-tuning your alerts: [Alert Settings at Checkly](https://www.checklyhq.com/docs/communicate/alerts/configuration).
-### Allowlist Checkly Traffic
+### Allowlist Checkly traffic
In some cases, firewalls, load balancers, or security solutions might inadvertently block Checkly's monitoring traffic, which could interfere with running checks successfully. This can happen if your system detects Checkly’s requests as suspicious or treats them as unwanted traffic.
@@ -61,6 +61,6 @@ To prevent this, we recommend reviewing your security settings to ensure that Ch
You can find Checkly’s current IP ranges here: [Allowlisting & filtering traffic](/platform/allowlisting-traffic#ip-range-allowlisting).
-## If Issues Persist
+## If issues persist
Use [Checkly's Network Diagnostic Tools](/platform/network-diagnostic-tools) to inspect failed checks for issues like DNS errors, dropped packets, or failed handshakes. If that doesn't reveal the root cause, don't hesitate to reach out to [support@checklyhq.com](mailto:support@checklyhq.com), and our team will help investigate further.
\ No newline at end of file
diff --git a/platform/network-diagnostic-tools.mdx b/platform/network-diagnostic-tools.mdx
index 7406c4d8b..a52195488 100644
--- a/platform/network-diagnostic-tools.mdx
+++ b/platform/network-diagnostic-tools.mdx
@@ -1,7 +1,7 @@
---
-title: 'Network Diagnostic Tools'
+title: 'Network diagnostic tools'
description: 'Network Diagnostic Tools in Checkly'
-sidebarTitle: 'Network Diagnostic Tools'
+sidebarTitle: 'Network diagnostic tools'
canonical: 'https://www.checklyhq.com/docs/platform/network-diagnostic-tools/'
---
diff --git a/platform/private-locations/agent-configuration.mdx b/platform/private-locations/agent-configuration.mdx
index bc9d69e05..bac087453 100644
--- a/platform/private-locations/agent-configuration.mdx
+++ b/platform/private-locations/agent-configuration.mdx
@@ -1,5 +1,5 @@
---
-title: 'Agent Configuration'
+title: 'Agent configuration'
description: "Configure the Checkly Agent for a private location with environment variables for API keys, proxies, job concurrency, log level, dependency caching, and health probes."
canonical: 'https://www.checklyhq.com/docs/platform/private-locations/agent-configuration/'
---
@@ -148,7 +148,7 @@ If you lose track of which agent containers are using the old API key, you can u
9. Click the delete icon next to the old API key (verified by the shown trailing characters) then click the confirmation.
10. Click Save to close the dialog. You will now only see the new API key listed for the private location.
-## Trusting Enterprise TLS Certificates
+## Trusting enterprise TLS certificates
Some enterprise environments may use internal certificates for TLS connections. These certificates need to be trusted by the agent; otherwise, the agent's TLS connection to the Checkly platform will fail.
@@ -164,7 +164,7 @@ docker run -v ~/certificate.pem:/checkly/certificate.pem -e NODE_EXTRA_CA_CERTS=
Alternatively, you can tell the Node.js worker to accept unauthorized certificates with the environment variable `NODE_TLS_REJECT_UNAUTHORIZED=0`. This can be appended to your `docker run ..` command with the `-e` flag.
-## Health Probe Endpoints
+## Health probe endpoints
The Checkly Agent exposes HTTP health probe endpoints and Prometheus metrics on port `8080` by default. You can change this port using the `AGENT_SERVER_PORT` environment variable. Agents before v8.12.0 serve health probes on port `8081` (set with `AGENT_HEALTH_PORT`) and metrics on port `8082`.
@@ -177,7 +177,7 @@ Endpoint|Description
These endpoints are useful for configuring [Kubernetes readiness and liveness probes](https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-startup-probes/) or any other container orchestration health checks.
-## External Observability
+## External observability
The Checkly Agent reports error-level events to Checkly to help detect crashes, bugs, and environment-related issues. This is enabled by default starting with agent v7.0.0.
@@ -189,7 +189,7 @@ To disable external observability, set the `EXTERNAL_OBSERVABILITY` environment
-e EXTERNAL_OBSERVABILITY=off
```
-## Agent Version and Runtimes
+## Agent version and runtimes
Each Checkly Agent only supports specific [runtimes](/platform/runtimes/overview/). This is to keep the container image at an acceptable size. When you change the runtime a check uses, you may also need to change to the corresponding agent version. Similarly, if you update the agent version to one using a different runtime you also need to update your checks to use the same runtime.
@@ -214,7 +214,7 @@ As each agent version only supports specific runtimes, we recommend pinning agen
## Troubleshooting
-
+
Container runtimes drop `NET_RAW` by default. Traceroute and Packet Capture need raw sockets, so the Checkly Agent needs this capability explicitly granted.
**How to fix**:
diff --git a/platform/private-locations/agent-images.mdx b/platform/private-locations/agent-images.mdx
index e938bf7b6..fb6000fa6 100644
--- a/platform/private-locations/agent-images.mdx
+++ b/platform/private-locations/agent-images.mdx
@@ -1,7 +1,7 @@
---
-title: 'Agent Images'
+title: 'Agent images'
description: "Compare the Checkly Agent images, Standard, Dev, and Uptime, and learn the image tag format for pulling the variant and version you need."
-sidebarTitle: 'Agent Images'
+sidebarTitle: 'Agent images'
canonical: 'https://www.checklyhq.com/docs/platform/private-locations/agent-images/'
---
@@ -13,7 +13,7 @@ Checkly provides different agent images:
* [Uptime](#uptime-image): A lightweight image for running uptime monitors only
-## Image Tag Format
+## Image tag format
Image tags define which agent variant and version you run.
@@ -30,7 +30,7 @@ docker pull checkly/agent-uptime:X.Y.Z
Use versioned tags for reproducible deployments. Floating tags (like `:latest`) may change between pulls. Browse available versions on [Docker Hub](https://hub.docker.com/r/checkly/agent/tags).
-## Standard Image
+## Standard image
The standard image (`checkly/agent:X.Y.Z`) is the default and recommended option for most setups.
@@ -41,19 +41,19 @@ It supports the full range of Checkly monitors:
Use the standard image unless you have a specific need for the dev or uptime variants.
-## Uptime Image
+## Uptime image
The uptime image (`checkly/agent-uptime:X.Y.Z`) is a lightweight version of the agent designed for [uptime monitoring](/detect/uptime-monitoring/overview) only.
It supports URL, DNS, TCP and ICMP monitors. Concurrency is controlled by `AGENT_WORKER_COUNT`; `JOB_CONCURRENCY` has no effect on this image. See [agent configuration](/platform/private-locations/agent-configuration).
-## Dev Image
+## Dev image
If any of the checks you run on private locations rely on npm packages with native code, those packages need to be compiled during installation.
The standard agent is optimized for size and doesn’t ship with build tools. In those cases, you’ll need to use the dev image instead.
-#### When to Use the Dev Image
+#### When to use the dev image
Use the dev image (`checkly/agent-dev:X.Y.Z`) when your checks require npm packages with native dependencies that need compilation. Common examples include:
@@ -62,7 +62,7 @@ Use the dev image (`checkly/agent-dev:X.Y.Z`) when your checks require npm packa
If your checks only use pure JavaScript packages, the standard runtime image is recommended for its smaller size and faster startup.
-#### What's Included in the Dev Image
+#### What's included in the dev image
The dev agent works exactly like the standard agent, but includes the build tools required to compile native modules.
diff --git a/platform/private-locations/agent-metrics.mdx b/platform/private-locations/agent-metrics.mdx
index 8918663b6..6f3231c6a 100644
--- a/platform/private-locations/agent-metrics.mdx
+++ b/platform/private-locations/agent-metrics.mdx
@@ -1,7 +1,7 @@
---
-title: 'Agent Metrics'
+title: 'Agent metrics'
description: "Scrape Prometheus metrics from the Checkly Agent: agent capacity, Go and Node.js runtime metrics, and opt-in check-level result and timing metrics."
-sidebarTitle: 'Agent Metrics'
+sidebarTitle: 'Agent metrics'
canonical: 'https://www.checklyhq.com/docs/platform/private-locations/agent-metrics/'
---
diff --git a/platform/private-locations/change-log.mdx b/platform/private-locations/change-log.mdx
index 2a2fa7b92..86c993c17 100644
--- a/platform/private-locations/change-log.mdx
+++ b/platform/private-locations/change-log.mdx
@@ -1,6 +1,6 @@
---
-title: Checkly Agent Changelog
-sidebarTitle: Agent Changelog
+title: Checkly Agent changelog
+sidebarTitle: Agent changelog
description: Release history for the Checkly Agent
rss: true
canonical: 'https://www.checklyhq.com/docs/platform/private-locations/change-log/'
diff --git a/platform/private-locations/kubernetes-deployment.mdx b/platform/private-locations/kubernetes-deployment.mdx
index 263710460..9b666d4aa 100644
--- a/platform/private-locations/kubernetes-deployment.mdx
+++ b/platform/private-locations/kubernetes-deployment.mdx
@@ -1,5 +1,5 @@
---
-title: 'Kubernetes Deployment'
+title: 'Kubernetes deployment'
description: "Deploy the Checkly Agent to a private location on Kubernetes using the official Helm chart for production-grade, orchestrated agent deployments."
canonical: 'https://www.checklyhq.com/docs/platform/private-locations/kubernetes-deployment/'
---
diff --git a/platform/private-locations/overview.mdx b/platform/private-locations/overview.mdx
index 78e45f536..ef927e51d 100644
--- a/platform/private-locations/overview.mdx
+++ b/platform/private-locations/overview.mdx
@@ -97,24 +97,24 @@ We recommend to update the Checkly agent regularly.
Please use a minimum container size of 2 CPU cores and 4 GB of RAM when running Playwright Check Suites.
-## Next Steps
+## Next steps
Once your first agent is running, explore these topics to start using Private Locations in production:
-
+
Detailed agent configuration options, updating your agent, runtime support, and more.
-
+
Run production-grade agent deployments on a container orchestrator like Kubernetes.
-
+
How to calculate the number of agents and amount of resources needed.
-
+
Use the dev agent for npm packages that require compilation.
diff --git a/platform/private-locations/proxy-setup.mdx b/platform/private-locations/proxy-setup.mdx
index 8f6ac5aa1..115949d09 100644
--- a/platform/private-locations/proxy-setup.mdx
+++ b/platform/private-locations/proxy-setup.mdx
@@ -1,5 +1,5 @@
---
-title: 'Proxy Setup'
+title: 'Proxy setup'
description: 'Configure HTTP proxies for Checkly private locations in enterprise environments. Set up proxy routing for both agent management traffic and check execution.'
canonical: 'https://www.checklyhq.com/docs/platform/private-locations/proxy-setup/'
---
diff --git a/platform/private-locations/scaling-redundancy.mdx b/platform/private-locations/scaling-redundancy.mdx
index 9ddde2cab..9e5b8df30 100644
--- a/platform/private-locations/scaling-redundancy.mdx
+++ b/platform/private-locations/scaling-redundancy.mdx
@@ -1,5 +1,5 @@
---
-title: 'Scaling and Redundancy'
+title: 'Scaling and redundancy'
description: 'Plan capacity, implement redundancy, and scale Checkly private locations for production workloads.'
canonical: 'https://www.checklyhq.com/docs/platform/private-locations/scaling-redundancy/'
---
diff --git a/platform/reporting/overview.mdx b/platform/reporting/overview.mdx
index 253170574..b0a3317d2 100644
--- a/platform/reporting/overview.mdx
+++ b/platform/reporting/overview.mdx
@@ -1,5 +1,5 @@
---
-title: 'Reporting Results with Checkly'
+title: 'Reporting results with Checkly'
description: 'Analyze check performance and export monitoring data with Checkly reporting dashboard'
sidebarTitle: 'Overview'
canonical: 'https://www.checklyhq.com/docs/platform/reporting/overview/'
@@ -20,35 +20,35 @@ The reporting dashboard lists your checks, 25 per page, with key performance met
- Compare performance between different check types
- Spot patterns in success ratios and response times
-## Filtering and Sorting
+## Filtering and sorting
Customize your view using the toolbar filters and sorting options:
-
+
Select the time period for your analysis: Today, Last hour, Last 3 hours, Last 24 hours, Last 7 days, Last 30 days, or a custom range. The dashboard adjusts data granularity automatically based on your selection.
-
+
Type a filter into the search bar, for example `tags:is:prod`. You can filter by status, check type, tags, project, location, creator, name, group, URL, logical ID and whether the check ran, and by the Success, Avg, P95 and P99 metrics, and combine filters with `and` and `or`. See [Filters](/platform/filters#reporting) for the syntax and what each field matches. You can save any filter as a [view](/platform/views).
-
+
Type `group by location` in the filter field and press Enter to list one row per check and location. See [Group the rows](/platform/filters#group-the-rows).
-
+
Click a column header to sort by Type, Name, Success, Avg, P95 or P99, in ascending or descending order. When you group by location, you can also sort by Location. Checks without a value come last.
-## Performance Graphs
+## Performance graphs
Use the **Table** and **Chart** toggle in the toolbar to switch between the list and a chart of response times and success ratios over your selected time period. Select up to 12 checks in the table and click **Compare in chart** to chart them together. Without a selection, the chart shows the first 12 checks in the table's order, the 12 with the highest P95 unless you sorted the table.

-### Graph Features
+### Graph features
**Response Time Metrics**: Toggle Avg, P95 and P99 with the Metrics buttons above the chart. P95 is shown by default. Each check keeps its color across the chart, and Avg and P99 use dotted and dashed lines.
@@ -64,18 +64,18 @@ Use the **Table** and **Chart** toggle in the toolbar to switch between the list
| Up to 48 months | Monthly |
| Beyond 48 months | Yearly |
-## Data Export
+## Data export
Export your monitoring data for external analysis, reporting, or archival purposes.
-### CSV Export Process
+### CSV export process
-
+
Choose the time period for your export using the date range picker.
-
+
Use check type, tags, and other filters to narrow your dataset if needed.
@@ -84,7 +84,7 @@ Click **Download CSV** in the toolbar of the Table view to generate your export
-### Export Data Fields
+### Export data fields
The CSV export (`checkly_export.csv`) includes the following columns:
@@ -105,7 +105,7 @@ The CSV export (`checkly_export.csv`) includes the following columns:
All statistics are calculated based on your selected date range. The default range is "Last 24 Hours".
-## Best Practices
+## Best practices
- **Regular exports**: Use the [Reporting API](/api-reference/reporting/generates-a-report-with-aggregate-statistics-for-checks-and-check-groups) to automate periodic exports for long-term trend analysis
- **Filter strategically**: Use tags and groups to create focused reports for different teams
diff --git a/platform/runtimes/overview.mdx b/platform/runtimes/overview.mdx
index 969cf55e2..238f2d7b4 100644
--- a/platform/runtimes/overview.mdx
+++ b/platform/runtimes/overview.mdx
@@ -1,5 +1,5 @@
---
-title: 'Checkly Runtimes'
+title: 'Checkly runtimes'
description: 'How Checkly runtimes work.'
sidebarTitle: 'Overview'
canonical: 'https://www.checklyhq.com/docs/platform/runtimes/overview/'
diff --git a/platform/runtimes/runtime-specification.mdx b/platform/runtimes/runtime-specification.mdx
index 39e3a1243..2a0cdd78f 100644
--- a/platform/runtimes/runtime-specification.mdx
+++ b/platform/runtimes/runtime-specification.mdx
@@ -1,7 +1,7 @@
---
-title: 'Runtime Specification'
+title: 'Runtime specification'
description: 'Detailed information on specific Checkly runtimes.'
-sidebarTitle: 'Runtime Specification'
+sidebarTitle: 'Runtime specification'
canonical: 'https://www.checklyhq.com/docs/platform/runtimes/runtime-specification/'
---
diff --git a/platform/secrets.mdx b/platform/secrets.mdx
index 4308a3621..48dfa5185 100644
--- a/platform/secrets.mdx
+++ b/platform/secrets.mdx
@@ -1,7 +1,7 @@
---
-title: 'Storing Secrets'
+title: 'Storing secrets'
description: 'Storing sensitive data in Checkly'
-sidebarTitle: 'Storing Secrets'
+sidebarTitle: 'Storing secrets'
canonical: 'https://www.checklyhq.com/docs/platform/secrets/'
---
@@ -21,17 +21,17 @@ Both variables and secrets are encrypted at rest and in flight. However, Secrets
-## Secrets in Practice
+## Secrets in practice
Secrets integrate seamlessly into your monitoring workflow while maintaining security. You reference them in your code using the same syntax as regular environment variables, but they remain protected throughout the entire execution pipeline. This means you can write monitoring logic that authenticates with services, accesses protected endpoints, and performs realistic user scenarios without compromising security.
Use secrets in your scripts using standard Node.js syntax: `process.env.MY_SECRET` or by using `{{handlebars}}` syntax in applicable API check fields.
-## Real-World Secrets Examples
+## Real-world secrets examples
Here's how you might use Secrets in real monitoring scenarios:
-### API Authentication Example:
+### API authentication example:
```typescript
import { ApiCheck, AssertionBuilder } from 'checkly/constructs'
@@ -54,7 +54,7 @@ new ApiCheck('authenticated-api-check', {
})
```
-### Browser Login Flow Example:
+### Browser login flow example:
```typescript
import { test, expect } from '@playwright/test'
@@ -73,7 +73,7 @@ test('Login flow', async ({ page }) => {
})
```
-### Database Connection Example:
+### Database connection example:
```typescript
import { ApiCheck } from 'checkly/constructs'
@@ -94,7 +94,7 @@ new ApiCheck('database-health-check', {
})
```
-### Managing Secrets via CLI:
+### Managing secrets via CLI:
```bash
# Create a secret
@@ -110,7 +110,7 @@ npx checkly env ls
npx checkly env update API_SECRET_KEY new_secret_value --secret
```
-### Payment Processing Example:
+### Payment processing example:
```typescript
import { test } from '@playwright/test'
@@ -131,13 +131,13 @@ test('Checkout flow with test payment', async ({ page }) => {
})
```
-## Secrets as Security Foundation
+## Secrets as security foundation
Secrets represent the foundation of secure monitoring practices. They enable you to test and monitor authenticated workflows, private APIs, and sensitive user journeys while maintaining the security posture that modern applications require. By centralizing secret management within your monitoring platform, you eliminate the risk of credentials being scattered across scripts, configuration files, or team communications.
The power of Secrets lies in making security invisible to your monitoring logic—your Checks work exactly the same whether they're using public endpoints or accessing the most sensitive parts of your application, but the security model ensures that sensitive information never leaves the protected environment.
-## Alternative: Dynamic Secret Detection
+## Alternative: Dynamic secret detection
For Browser checks and Multistep checks, you can also use dynamic secret detection. This approach allows you to retrieve secrets at runtime (from external vaults like Azure Key Vault, AWS Secrets Manager, etc.) and have them automatically scrubbed from logs and traces.
@@ -153,7 +153,7 @@ This is particularly useful for organizations that prefer not to store secrets i
Secrets also work in alert-channel configurations — webhook URLs, API keys, PagerDuty service keys, and any other literal-secret field accept the same `{{NAME}}` reference syntax. See [Alert channels](/communicate/alerts/channels) for details and the inline promote-to-secret affordance.
-## Security and Usability Balance
+## Security and usability balance
Use dedicated test users, test cards etc. These test users should have minimal privileges in your app. Do not use your admin or root user. Make sure you can easily disable or block these users without recourse.
diff --git a/platform/variables.mdx b/platform/variables.mdx
index b4a10622e..595db397a 100644
--- a/platform/variables.mdx
+++ b/platform/variables.mdx
@@ -94,6 +94,6 @@ How variables are accessed depends on where you're accessing them from:
Handlebar (double brackets) variables are HTML-escaped: `&`, `<`, `>`, `"`, `'`, `` ` `` and `=` are replaced with HTML entities, for example `&` becomes `&`. To insert the raw value, access your environment variables with triple brackets, i.e. `{{{VARIABLE_NAME}}}`.
-## Playwright Check Suite Variables
+## Playwright Check Suite variables
Checkly provides a set of [built-in environment variables](/detect/synthetic-monitoring/playwright-checks/environment-variables) that you can use in your [Playwright Check Suites](/detect/synthetic-monitoring/playwright-checks/overview) to distinguish between Checkly executions and local runs.
diff --git a/platform/views.mdx b/platform/views.mdx
index 5a6dcb721..ede003ba1 100644
--- a/platform/views.mdx
+++ b/platform/views.mdx
@@ -179,7 +179,7 @@ New views start with no counter. The counter is part of the view. Everyone sees
Test sessions, Reporting and Traces have no counters.
-## Passing, Degraded and Failing on Monitors
+## Passing, degraded and failing on monitors
Every account starts with three shared views on Monitors: **Passing**, **Degraded** and **Failing**. Each one filters on its status and counts those checks.
diff --git a/quickstart.mdx b/quickstart.mdx
index c3f2c170b..016abdbb7 100644
--- a/quickstart.mdx
+++ b/quickstart.mdx
@@ -1,5 +1,5 @@
---
-title: 'Checkly Quickstart'
+title: 'Checkly quickstart'
description: 'Add synthetic monitoring to your existing project in minutes. Let your AI agent set up Checkly, or follow the steps yourself.'
sidebarTitle: 'Quickstart'
canonical: 'https://www.checklyhq.com/docs/quickstart/'
diff --git a/resolve/ai-root-cause-analysis/overview.mdx b/resolve/ai-root-cause-analysis/overview.mdx
index 3246d0f3d..f751bf9ac 100644
--- a/resolve/ai-root-cause-analysis/overview.mdx
+++ b/resolve/ai-root-cause-analysis/overview.mdx
@@ -1,11 +1,11 @@
---
-title: "Rocky AI Root Cause Analysis"
+title: "Rocky AI root cause analysis"
description: "Automatically perform root cause and user impact analysis with Rocky AI"
-sidebarTitle: "AI Root Cause Analysis"
+sidebarTitle: "AI root cause analysis"
canonical: 'https://www.checklyhq.com/docs/resolve/ai-root-cause-analysis/overview/'
---
-## What is Rocky AI Root Cause Analysis?
+## What is Rocky AI root cause analysis?
Rocky AI — Checkly's Agent — can automatically analyze, categorize and summarize any failure or error from one of Checkly's synthetic checks and / or monitoring checks.
@@ -24,7 +24,7 @@ Rocky AI — Checkly's Agent — can automatically analyze, categorize and summa
Using any available artifacts like error message, user code, check description, logs, metrics, trace routes, OpenTelemetry traces, packet captures, Playwright traces, screenshots and other evidence, it will quickly assess what the impact is of a failure and what the underlying (possible) root cause is. It will also provide a suggested code fix for any check based on (Playwright) code.
-## Getting Started with Rocky AI Root Cause Analysis
+## Getting started with Rocky AI root cause analysis
To use Rocky AI Root Cause Analysis, make sure [Rocky AI is enabled on its settings page](https://app.checklyhq.com/accounts/rocky-ai).
@@ -111,7 +111,7 @@ For API, Browser, Multistep, and Playwright Checks, the **Check intent** card be
For Browser and Multistep checks, select **Repair with AI** on a completed analysis to attempt a script fix. See [Start a manual repair](../automatic-check-repair#start-a-manual-repair) for prerequisites, repair history, and restoring the original script.
-## Key Capabilities
+## Key capabilities
- **Categorize**: Rocky AI determines if an error is of a specific category. For example: is it a typo in your code or is it an infrastructure error?
- **Root cause**: Rocky AI analyzes the failure and provides you with a root cause analysis, helping you quickly remediate the issue. It uses any and all available artifacts to come to this analysis and list these artifacts as "evidence".
diff --git a/resolve/automatic-check-repair.mdx b/resolve/automatic-check-repair.mdx
index a3ed8fbd9..eda1fc1e9 100644
--- a/resolve/automatic-check-repair.mdx
+++ b/resolve/automatic-check-repair.mdx
@@ -1,6 +1,6 @@
---
title: 'Automatic check repair'
-sidebarTitle: 'Automatic Repair'
+sidebarTitle: 'Automatic repair'
description: 'Configure automatic repair, start a manual attempt, and restore a Browser or Multistep check script.'
canonical: 'https://www.checklyhq.com/docs/resolve/automatic-check-repair/'
---
diff --git a/resolve/overview.mdx b/resolve/overview.mdx
index 937ce5592..ad62aef3b 100644
--- a/resolve/overview.mdx
+++ b/resolve/overview.mdx
@@ -11,24 +11,24 @@ canonical: 'https://www.checklyhq.com/docs/resolve/overview/'
Analyze request flows with distributed tracing to identify performance bottlenecks and failures
-
+
Let Rocky AI analyze errors, metrics, traces and logs and determine impact and root cause
-## Key Benefits
+## Key benefits
- **Fast Root Cause Analysis** — Identify the exact source of issues with detailed request tracing across your entire application stack.
- **AI-Powered Insights** — Get intelligent analysis and recommendations from Rocky AI to resolve incidents faster than ever.
- **Full Request Visibility** — See complete request flows from frontend to backend, including database queries and external API calls.
- **Performance Optimization** — Identify slow operations and bottlenecks to proactively improve application performance.
-## Getting Started
+## Getting started
Ready to accelerate your incident resolution? Choose the approach that best fits your current needs:
-
+
Begin collecting distributed traces for your applications
@@ -36,11 +36,11 @@ Begin collecting distributed traces for your applications
Experience AI-powered root cause analysis and insights
-
+
Add OpenTelemetry instrumentation to your codebase
-
+
Connect traces with your existing observability platform
diff --git a/resolve/traces/how-it-works.mdx b/resolve/traces/how-it-works.mdx
index b063e965c..3f73c8d79 100644
--- a/resolve/traces/how-it-works.mdx
+++ b/resolve/traces/how-it-works.mdx
@@ -1,5 +1,5 @@
---
-title: 'How It Works'
+title: 'How it works'
description: 'Understand how Checkly traces work with OpenTelemetry to provide comprehensive observability.'
canonical: 'https://www.checklyhq.com/docs/resolve/traces/how-it-works/'
---
@@ -23,7 +23,7 @@ flowchart LR
## The flow
-
+
When trace export or the Coralogix integration is enabled, Checkly automatically instruments the HTTP requests made by your checks with `traceparent` and `tracestate` headers. These HTTP requests hit your web application or API when running checks.
API checks, URL monitors, Browser checks and Multistep checks include these headers:
@@ -34,13 +34,13 @@ API checks, URL monitors, Browser checks and Multistep checks include these head
Together, these headers propagate the trace context along the request chain. This is the most basic way of tying a synthetic check to your backend traces, though it won't provide much context about the check run itself, like the check name or location.
-
+
You can configure your OpenTelemetry backend on [Settings > Traces](https://app.checklyhq.com/settings/account/traces) so Checkly exports every API check, URL monitor, Browser check and Multistep check run as a span to your backend. This correlates all backend spans with the check run that triggered them when your application honors `traceparent`, together with full context of the check run.
Check details are stored in the `checkly` namespace as attributes on the span, such as the check name, check type, run location and tags. See [What is sent](/integrations/observability/traces/otlp#what-is-sent) for the span schema and the tag rules.
-
+
**No 3rd party backend needed.** This is what kicks Checkly's OpenTelemetry integration into high gear, and it works even if you don't have a 3rd party OTel backend already set up.
By adding the correct OTel libraries and simple filter statements, you can send ONLY the traces related to your Checkly checks back to Checkly:
@@ -52,7 +52,7 @@ By adding the correct OTel libraries and simple filter statements, you can send
Checkly's trace ingestion endpoint is a standard OTel backend endpoint that only accepts traces related to synthetic checks. This keeps your OpenTelemetry setup lean while providing full trace correlation benefits.
-
+
When your check breaks, you get an alert that points to a check result containing a full trace of the check run, including all backend spans:
- Complete trace of the check run
diff --git a/resolve/traces/import/https-grpc.mdx b/resolve/traces/import/https-grpc.mdx
index ccd44d392..915dda0ce 100644
--- a/resolve/traces/import/https-grpc.mdx
+++ b/resolve/traces/import/https-grpc.mdx
@@ -1,5 +1,5 @@
---
-title: 'HTTPS vs GRPC Traces'
+title: 'HTTPS vs GRPC traces'
description: 'Learn how to import traces from HTTPS/GRPC'
sidebarTitle: 'HTTPS vs GRPC'
canonical: 'https://www.checklyhq.com/docs/resolve/traces/import/https-grpc/'
diff --git a/resolve/traces/import/missing-spans.mdx b/resolve/traces/import/missing-spans.mdx
index dcfe7338f..ef598a065 100644
--- a/resolve/traces/import/missing-spans.mdx
+++ b/resolve/traces/import/missing-spans.mdx
@@ -1,7 +1,7 @@
---
-title: 'Missing Spans'
+title: 'Missing spans'
description: 'Learn how to import traces from OpenTelemetry'
-sidebarTitle: 'Missing Spans'
+sidebarTitle: 'Missing spans'
canonical: 'https://www.checklyhq.com/docs/resolve/traces/import/missing-spans/'
---
@@ -55,7 +55,7 @@ Missing spans can happen due to various reasons. Whether you're sending data to
#### Sampling directly in your applications' code.
Choose the specific [instrumentation language guide](/resolve/traces/instrumentation/nodejs) and review your configuration against Step 2 in the guides.
-### Review OpenTelemetry Exporter configuration
+### Review OpenTelemetry exporter configuration
Ensure the right Authorization keys and endpoints are in use.
@@ -79,7 +79,7 @@ Ensure the right Authorization keys and endpoints are in use.
exporters: [otlp/checkly]
```
-#### Exporting directly from your Application's code
+#### Exporting directly from your application's code
Confirm your environment variables use the correct endpoint and authorization:
diff --git a/resolve/traces/import/open-telemetry.mdx b/resolve/traces/import/open-telemetry.mdx
index c6e4aceb8..dc63d8935 100644
--- a/resolve/traces/import/open-telemetry.mdx
+++ b/resolve/traces/import/open-telemetry.mdx
@@ -1,5 +1,5 @@
---
-title: 'Setting Up The OpenTelemetry Collector'
+title: 'Setting up the OpenTelemetry Collector'
description: 'Learn how to import traces from OpenTelemetry'
sidebarTitle: 'From OpenTelemetry'
canonical: 'https://www.checklyhq.com/docs/resolve/traces/import/open-telemetry/'
diff --git a/resolve/traces/import/overview.mdx b/resolve/traces/import/overview.mdx
index 86fa879cc..349582198 100644
--- a/resolve/traces/import/overview.mdx
+++ b/resolve/traces/import/overview.mdx
@@ -1,8 +1,8 @@
---
-title: "Importing Traces To Checkly"
+title: "Importing traces to Checkly"
description: "Send OpenTelemetry traces from your infrastructure to Checkly so you can drill into why a check failed or degraded, right from the check result."
-sidebarTitle: "Importing Traces"
+sidebarTitle: "Importing traces"
canonical: 'https://www.checklyhq.com/docs/resolve/traces/import/overview/'
---
diff --git a/resolve/traces/instrumentation/nextjs.mdx b/resolve/traces/instrumentation/nextjs.mdx
index a2834b8b6..84f840cec 100644
--- a/resolve/traces/instrumentation/nextjs.mdx
+++ b/resolve/traces/instrumentation/nextjs.mdx
@@ -92,7 +92,7 @@ This is however not required, the above configuration should work just fine on N
Also notice the `sampler` configuration. This is a custom, **head-based sampler** that will only sample spans that are generated by Checkly by
inspecting the trace state. This way you only pay for the egress traffic generated by Checkly and not for any other traffic.
-## Step 5 (Local development). Start your app with the instrumentation
+## Step 5 (local development). Start your app with the instrumentation
Toggle on **Import Traces** and grab your OTel API key in the **OTel API keys** section of the [Traces page in the Checkly app](https://app.checklyhq.com/settings/account/traces) and take a note of the endpoint for the region you want to use.
diff --git a/resolve/traces/overview.mdx b/resolve/traces/overview.mdx
index 12d66ce38..ee0aa7301 100644
--- a/resolve/traces/overview.mdx
+++ b/resolve/traces/overview.mdx
@@ -10,7 +10,7 @@ canonical: 'https://www.checklyhq.com/docs/resolve/traces/overview/'
alt="Check result with OpenTelemetry trace"
/>
-## What is Distributed Tracing?
+## What is distributed tracing?
Distributed tracing tracks requests as they flow through your application's services and infrastructure. It helps you:
@@ -25,7 +25,7 @@ With telemetry traces configured, you will have access to traces in all the plac
- **Test sessions:** understand any failures during test session execution.
- **Check editors:** get a live trace while building, editing and debugging check code.
-## Getting Started with Checkly Traces
+## Getting started with Checkly Traces
To get started with Checkly Traces using OpenTelemetry, pick the scenario that best fits your needs.
@@ -83,22 +83,22 @@ Here's an actual example from Checkly's own backend.
2. The OTeL trace indicates this was actually do to our **Clickhouse** server returning a 500 errors, immediately telling our on-call team where to start looking.
3. Without the trace, we would have to look at all the various logging, error tracking and other tools that are integrated into the various middleware and infrastructure this request passes through (our load balancer, REST API server, Redis datastore etc.
-## Key Benefits
+## Key benefits
-
+
Only traces generated by Checkly checks are forwarded to third-party tools, significantly reducing data transfer costs while maintaining comprehensive monitoring coverage.
-
+
Combine synthetic monitoring data with application traces in your existing observability platform for a complete picture of system health.
-
+
When checks fail, trace data provides immediate context about what happened in your application stack, accelerating root cause analysis.
-
+
Works with existing OpenTelemetry instrumentation and popular observability platforms without requiring changes to your application logic.
diff --git a/what-is-checkly.mdx b/what-is-checkly.mdx
index 0d05a8e0a..f4403053b 100644
--- a/what-is-checkly.mdx
+++ b/what-is-checkly.mdx
@@ -40,25 +40,25 @@ Checkly helps developers increase uptime and reliability, improve shipping veloc
Define your entire monitoring setup with TypeScript constructs instead of manual UI configuration.
-
+
Browser monitoring powered natively by Playwright for fast, reliable end-to-end scenario monitoring.
-
+
Code-driven platform with constructs, APIs, and a CLI that manages the entire lifecycle of your monitors.
-
+
Unify testing, monitoring, and observability into a single workflow using Playwright and OpenTelemetry.
-
+
Detect both functional and performance errors in pre-production and production environments.
-## Use Cases
+## Use cases
- **[Run checks on every deploy](/guides/sdlc-monitoring)** — Validate functionality and performance in staging before deployment, catching regressions early.
- **[Production Monitoring](/learn/monitoring/api-monitoring)** — Continuously monitor critical user journeys, API endpoints, and application performance.
@@ -67,7 +67,7 @@ Detect both functional and performance errors in pre-production and production e
- **[Multi-Environment Validation](/concepts/environments)** — Test across different environments, browsers, and devices for consistent functionality.
- **[Compliance and SLA Monitoring](/learn/incidents/slo-sla-sli)** — Track uptime and performance metrics to meet SLAs and regulatory requirements.
-## Checkly Is Best Fit For
+## Checkly is best fit for
**DevOps and SRE Teams** looking for programmable monitoring that integrates seamlessly with their existing infrastructure-as-code and GitOps workflows.
**Full-Stack Engineering Teams** who want to shift monitoring left and treat monitoring as an integral part of their development process rather than an afterthought.