Synthetic monitoring answers one operational question before customers answer it for you: does the service work right now? Some of the worst failures happen when traffic is low: a certificate expires overnight, a DNS change disrupts access in one region, or an API returns HTTP 200 with an error in its response. Without scheduled checks, these failures may go undetected until users encounter them. Synthetic monitoring runs checks at regular intervals to detect failures even when no real users are active.
This article covers how synthetic monitoring works, the different types of API and browser tests, and the metrics used to measure availability and performance. It also examines how synthetic monitoring compares with real user monitoring (RUM) and application performance monitoring (APM), along with its benefits, limitations, and best practices.
What Is Synthetic Monitoring?
Synthetic monitoring is an active monitoring technique that uses automated checks to verify the availability, functionality, and performance of websites, APIs, and applications. A probe sends requests or executes scripted user journeys at scheduled intervals, then checks the results against expected status codes, response content, and performance thresholds.
For example, an API test can send GET /api/v1/health every five minutes and verify that the endpoint returns HTTP 200, a JSON field "status": "ok", and a response time below 500 ms. Browser tests go further by simulating actions such as logging in, searching for products, or completing checkout.
Synthetic monitoring is a form of black-box monitoring: it examines how a service behaves without requiring instrumentation inside the application. However, a failed check doesn’t necessarily reveal the underlying cause. You still need application logs, metrics, and traces to investigate what went wrong.
How Does Synthetic Monitoring Work?
Synthetic monitoring runs predefined checks against applications and services from selected locations at regular intervals. Each check compares the response with expected behavior, records the result, and contributes to alerts when failures meet configured conditions.
The process follows six steps:
-
Define the check: Choose a target and check type, such as an HTTP endpoint, DNS query, or browser journey. -
Set assertions: Specify the status codes, response content, certificate properties, or performance thresholds that determine success. -
Choose locations and frequency: Select where checks run and how often they execute. -
Execute the check: Probes send requests or run scripts, capturing responses, timings, and errors. -
Collect results: Store execution outcomes and metrics to track availability, failures, and latency over time. -
Trigger alerts: Evaluate failed checks against configured thresholds and notify the responsible team when alert conditions are met.
Test Scripts, Requests, and Assertions
A synthetic check defines what to test and what constitutes a successful result. Protocol checks perform operations such as an ICMP echo, DNS lookup, TCP connection, or HTTP request. Scripted checks execute multiple requests or automate browser interactions using tools such as Playwright or k6. Assertions determine whether the result meets expectations and, depending on the monitoring platform, can validate:
-
HTTP status codes: Require a specific status or an accepted range. -
Response headers: Check that a header exists or contains an expected value. -
Response bodies: Match required text or reject known error messages. -
JSON fields: Validate values using JSONPath, such as$.status, or the platform’s supported property syntax. -
Response time: Fail or flag a check when execution exceeds a latency threshold. -
Certificate properties: Verify TLS certificate validity and expiration dates.
An HTTP 200 response does not necessarily mean an application is working. Amazon CloudFront can return a custom error page with HTTP 200 even when its origin returns an error. Similarly, a GraphQL operation can return HTTP 200 while its response contains resolver errors. API tests should therefore validate response content alongside status codes.
For example, Prometheus blackbox_exporter supports fail_if_body_matches_regexp to reject responses containing an error message such as Could not connect to database. Its fail_if_body_not_matches_regexp option can require expected content instead. For GraphQL checks, validate the required data fields and check that the errors array is absent or empty.
Probes, Locations, and Check Frequency
A probe executes synthetic checks from a specific network location, determining which network path the check tests and which services it can reach. Public probes run outside your infrastructure and help detect failures involving DNS resolution, CDN routing, TLS connections, and regional network paths. Private probes run from networks that can reach internal services, including private APIs and internal load balancers. Depending on the platform, these may be agents deployed in a VPC or Kubernetes cluster, or part of an existing monitoring backend.
For example, groundcover runs synthetic checks from its installed BYOC backend, allowing it to monitor internal services without exposing them to public probes. Other private-runner implementations may communicate with a vendor’s control plane, so network access and outbound connectivity requirements vary. Public probes accessing protected endpoints should use authentication rather than relying only on shared probe IP allowlists.
Check frequency determines how often a probe can detect a failure. Shorter intervals provide more frequent measurements but increase execution volume, while longer intervals allow brief outages to occur between checks without being detected. To calculate the number of scheduled executions over a 30-day month, use:
Monthly executions = Checks × Locations × (43,200 ÷ Interval in minutes)
For example, one API check running every minute from three locations produces 129,600 scheduled executions per month. Running it every five minutes reduces that to 25,920, while adding locations increases executions proportionally. However, scheduled executions are not always the same as billable units. Some providers also count execution duration, test type, or retry attempts. For example, Grafana Synthetic Monitoring calculates billable test executions using runtime rounded up to the nearest minute.
Collecting Results and Triggering Alerts
Each check produces a result indicating whether it passed or failed, along with available response timings, errors, and failed assertions. Depending on the check type, the result may also include response details or screenshots. These records help teams calculate availability, track latency, and investigate recurring failures. However, a failed attempt does not always trigger an alert. Monitoring platforms use retries, failure thresholds, and multi-location confirmation to distinguish temporary problems from persistent outages.
-
Retries: A failed attempt can be repeated before the scheduled run is marked failed. Withnretries, a run may involve up ton + 1attempts. Retries reduce alerts caused by transient failures but increase detection time and may add billing costs. -
Failure thresholds: Alerts can require consecutive failed runs, a specified number of failures within a time window, or a failure condition that persists for a defined duration. Two consecutive failed results from a check scheduled every ten minutes are approximately ten minutes apart. Total detection time also depends on scheduling, timeouts, retries, and monitor evaluation. -
Multi-location confirmation: Platforms supporting location-based alert rules can require failures from multiple locations before triggering a global alert. This reduces alerts caused by isolated probe problems but may miss outages affecting only one region.
For example, a platform supporting multi-location confirmation could run a critical API check every minute from three regions, allow one retry, and trigger a global alert when two regions report failures. If each region’s availability matters independently, configure separate regional alerts so an outage affecting only one region is still reported. These confirmation mechanisms should reflect how quickly the service’s owner needs to detect failures, since additional retries and evaluation periods can delay notifications.
Some platforms also distinguish failed checks from degraded performance. In groundcover Synthetics, a failed critical assertion marks a check as failed, while a failed degraded assertion produces a degraded result without triggering the associated failure monitor. Each synthetic test automatically creates a monitor, but notifications still require an appropriate notification route.
When synthetic checks contribute to a service-level objective (SLO), define how successful runs, retries, and missing results affect availability calculations. Probe-based availability measures success from selected locations, not the percentage of successful real-user requests. Error-budget burn-rate alerts can help detect SLO violations when enough measurements are available, but low-frequency checks may need failure thresholds suited to their smaller sample sizes.
Types of Synthetic Monitoring Checks
Synthetic monitoring checks range from basic network connectivity tests to browser tests that reproduce complete user journeys. Each type verifies a different part of a service, so the right choice depends on the failures you need to detect.
Network and protocol checks verify individual parts of a service, but their results don’t necessarily prove that the application works. A host may reject ICMP requests while its applications remain available, and a successful TCP connection only confirms that a port accepts connections. HTTP checks go further by validating application responses, although they may still miss failures in the user interface.
Multistep API tests verify workflows by passing data between requests, such as using an authentication token returned by one endpoint to access another. Scripted checks add conditional logic and custom validation when standard request sequences are insufficient. Browser tests exercise the rendered application, including JavaScript and user interactions, to detect problems that endpoint checks may miss. Depending on the platform, browser checks can also collect screenshots, execution logs, and web performance metrics.
Not every monitoring platform supports all these check types. For example, groundcover Synthetics supports HTTP checks through its UI, while SSL/TLS, TCP, and DNS checks can be configured through its Terraform provider.
What Metrics Does Synthetic Monitoring Measure?
Synthetic monitoring measures service availability, response time, and whether checks return the expected results. Most platforms record whether each check passed or failed, its execution time, and any failed assertions. Depending on the check type, you can also measure packet loss, DNS resolution time, connection failures, and certificate expiration.
Check success rate is the percentage of reported executions that passed, while failure rate is the percentage that failed. These measurements are sampled rather than continuous, so a check running every minute can miss an outage that occurs between executions. Success rate and uptime can also differ across multiple probe locations. For example, uptime may count an interval as available when at least one probe succeeds, while success rate counts individual executions. The exact calculations depend on the monitoring platform.
HTTP checks provide additional timing metrics that help you identify where requests are slowing down:
-
DNS lookup: Time spent resolving a hostname. High values may indicate resolver delays or DNS network problems. -
TCP connection: Time required to establish a connection. Increases may indicate network latency or connection-handling problems. -
TLS handshake: Time spent negotiating a secure connection. Delays can result from network round trips or TLS termination. -
Time to first byte (TTFB): Time from the start of a request until the first response byte arrives, including connection setup and server processing. -
Content transfer: Time spent receiving the remaining response body after the first byte.
You can inspect these timings using curl. The following command uses --write-out to display the HTTP status and cumulative timings for each request stage:
The timings are cumulative seconds from the start of the request, not individual phase durations. For a new direct HTTPS connection, subtract time_namelookup from time_connect to estimate TCP connection time, and time_connect from time_appconnect to estimate the TLS handshake. TTFB includes earlier connection stages, so a high value doesn’t necessarily indicate slow application processing. Redirects, proxies, and connection reuse can also affect these measurements.
Browser tests add rendering and interaction metrics. First Contentful Paint (FCP) measures when the first content appears, while Largest Contentful Paint (LCP) measures when the largest visible content element renders. Cumulative Layout Shift (CLS) measures unexpected visual movement, and Speed Index indicates how quickly visible content appears. Browser and multistep API tests can also measure transaction completion time, which is how long an entire scripted journey takes.
Google recommends an FCP of 1.8 seconds or less, LCP of 2.5 seconds or less, and CLS of 0.1 or less for good performance, assessed at the 75th percentile of real page loads. Another metric, Interaction to Next Paint (INP), measures responsiveness to user interactions. Standard Lighthouse page-load tests cannot measure INP because they don’t perform user interactions. Instead, Total Blocking Time (TBT) provides a lab proxy.
Synthetic measurements help you detect performance regressions under repeatable conditions, but they don’t represent every user’s experience. Each check runs from a particular location under specific network and device conditions, while real users access your application under different conditions. Compare synthetic results with real-user performance data to determine whether a regression also affects users.
Synthetic Monitoring vs. Real User Monitoring vs. APM
Synthetic monitoring, real user monitoring (RUM), and application performance monitoring (APM) examine application performance from different perspectives. Synthetic monitoring tests whether specific endpoints and user journeys work, RUM measures what actual users experience, and APM helps you investigate performance and failures inside your applications and services.
Synthetic monitoring is active monitoring because it generates its own traffic, allowing checks to run even when no users are active. RUM collects data from actual sessions across different devices, browsers, and network conditions. APM uses application and infrastructure telemetry to investigate service failures, dependencies, and application response time.
All three can also be used before production, although their requirements differ. Synthetic checks can run against staging environments or as part of deployment validation. RUM needs an instrumented application receiving traffic from testers, while APM needs telemetry collection configured for the services being tested.
Consider a checkout failure. A synthetic check can detect that a monitored checkout path is failing, while RUM shows whether real customers encounter the problem and which browsers or regions are affected. APM traces, logs, and metrics can then help determine whether the failure involves an application error, a slow dependency, or infrastructure problems.
Combining these approaches provides a more complete view of application health. For example, groundcover supports scheduled synthetic endpoint checks, browser-based RUM, and backend telemetry in the same full-stack observability platform. You can investigate synthetic failures alongside real-user activity, application traces, and infrastructure metrics without switching between separate monitoring systems.
Benefits and Use Cases of Synthetic Monitoring
Synthetic monitoring helps you detect failures without waiting for user reports, validate important application workflows, and measure performance under repeatable conditions. Its main benefits include:
-
Outage detection during low traffic: Scheduled checks continue testing services overnight, during weekends, and in regions with few active users. This helps you detect failures that request logs and real user monitoring may not reveal until traffic returns, reducing the time between an outage and its detection. -
Critical user journeys: Multistep API and browser checks verify operations such as login, signup, search, and checkout. Instead of confirming only that a website responds, you can test whether a customer can complete a transaction. These checks should use test accounts and avoid creating unintended orders, payments, or other production changes. -
Deployment validation: Run checks against staging environments or new releases to detect broken endpoints and workflows before wider deployment. Browser tests can run in CI/CD pipelines, while scheduled checks can monitor a deployed version during rollout. Failed results can inform release gates or rollback decisions when those controls are configured. -
Regional availability: Checks from different geographic locations can expose failures caused by DNS changes, CDN routing, or regional network problems. Comparing results helps you determine whether an endpoint is unavailable everywhere or only from certain locations. Coverage depends on where your monitoring platform runs its probes. -
Third-party dependencies: API checks can monitor integrations with payment gateways, identity providers, and other external services. Testing an actual integration path helps identify failures affecting your application’s dependency on that service, although it doesn’t reveal the provider’s internal root cause. Use supported test endpoints or credentials where transactions could have side effects. -
Performance baselines: Running the same checks under consistent conditions helps you detect changes in API response times, page rendering, and transaction completion. You can compare results before and after deployments to identify regressions, although synthetic measurements don’t capture the full range of real-user conditions. -
SLO and SLA measurement: Synthetic results can contribute to availability service-level indicators (SLIs) and service-level objectives (SLOs) when their checks represent the behavior being measured. They can also provide evidence for service-level agreements (SLAs) if the agreed measurement method uses synthetic checks. Define how retries, missing results, probe locations, and downtime are counted before using these measurements for reliability reporting. -
Faster incident investigation: A failed check identifies the affected endpoint, failed assertion, and execution time, helping engineers narrow their investigation. In groundcover Synthetics, synthetic executions generate traces that you can examine alongside application logs, metrics, and other traces. This context can help reduce mean time to resolution (MTTR) when investigating service failures.
Setting Up a Synthetic Monitoring Check
Suppose you want to monitor an order service at https://api.example.com/v1/orders/health. The check should confirm that the endpoint is reachable, returns the expected JSON, and responds within 800 milliseconds.
You can set this up using an HTTP synthetic monitoring tool. The following steps use an illustrative endpoint, so replace the URL and credentials with values from your environment.
1. Test the Endpoint and Define the Expected Response
Start by sending a request to the endpoint to confirm what a healthy response looks like. For example, a healthy order service might return HTTP 200 with this JSON:
You can inspect the response using curl. Set ORDER_API_TOKEN to a dedicated monitoring token retrieved securely from your secret manager, then run:
The command saves the response body to order-health.json and displays the HTTP status and total request time. You can then validate the expected JSON fields using jq:
The expression returns true and exits successfully when all conditions match. If a required value is incorrect or the errors field exists, it returns false and exits with a nonzero status.
These commands let you verify the endpoint manually. The next step is to configure a monitoring platform to perform the checks automatically.
2. Create the Scheduled HTTP Check
In your synthetic monitoring platform, create a new HTTP or API check and configure the request using these settings:
Next, add assertions that determine whether each execution passes:
The critical assertions determine whether the endpoint is functioning correctly. If your platform supports warning or degraded states, configure the response-time threshold separately so a slow but otherwise healthy response doesn’t automatically count as an availability failure.
3. Configure Retries and Notifications
A single failed request can result from a temporary network problem, so configure one retry after two seconds. If the retry also fails, the scheduled execution is marked as failed.
Next, create an alert rule for the Order API Health check. For example, evaluate the check every minute and require the failure condition to remain active for two minutes before firing. Monitoring platforms differ in how they evaluate pending periods and consecutive failures, so use the option that matches your intended alert behavior.
Finally, connect an alert destination such as Slack or PagerDuty and create a notification policy that routes failures from the order-service check to the responsible team. Make sure the policy matches the check’s name or labels, and test the destination before relying on it for production incidents.
4. Verify That the Check Detects Failures
Before enabling production alerting, test the configuration in a staging environment. One way to simulate a failure is to temporarily change the expected value of dependencies.db in the staging check to a value the endpoint does not return. Alternatively, use a controlled test response such as:
The HTTP status may still be 200, but the database assertion should fail because timeout doesn’t match connected.
Verify that the monitoring platform records the failed assertion, applies the configured retry policy, and sends a notification after the alert condition is met. Restore the original assertion or response afterward, and confirm that the check returns to a healthy state.
5. Investigate Failed Checks
When a check fails in production, open its execution details and identify the failed assertion. For example, if dependencies.db changes from connected to timeout, use the failure timestamp to inspect the order service’s logs, database connection metrics, and distributed traces. Look for connection timeouts, exhausted connection pools, or errors from the database dependency.
You can use groundcover Synthetics to configure HTTP checks from your BYOC backend. Each check automatically creates an associated monitor, and its executions generate traces that you can find using source:synthetics in the Traces Explorer. You can then investigate the synthetic results alongside application logs, metrics, and traces.
This example monitors the health of an order service, not the entire checkout process. To verify that customers can complete a purchase, you would need a multistep API or browser check that exercises the actual checkout workflow.
Limitations of Synthetic Monitoring and Best Practices
Synthetic monitoring helps detect failures and performance regressions, but its effectiveness depends on which paths you test, where checks run, and how you maintain them. The main limitations include:
-
Incomplete application coverage: Synthetic checks validate only the endpoints and workflows you configure. A health endpoint might pass while checkout remains broken, and even a browser test can miss failures in paths it doesn’t exercise. -
Limited real-user representation: Each execution runs under specific network, device, browser, and geographic conditions. These controlled tests help identify regressions but cannot reproduce every user’s experience. Real-user monitoring provides the broader performance data needed to understand differences across devices, networks, and user sessions. -
False alerts and unreliable tests: Temporary network failures, unavailable probes, expired credentials, and outdated browser scripts can cause checks to fail even when the application is healthy. However, a failure confined to one location can also indicate a genuine regional outage, so you shouldn’t automatically dismiss isolated probe failures. -
Production side effects: Browser and multistep API checks can create orders, modify accounts, trigger emails, or initiate payments. Without controlled test data and cleanup, repeated executions may affect production records or external services. -
Maintenance and execution costs: Browser scripts require updates as applications change, while monitoring infrastructure and credentials need ongoing maintenance. Costs can also increase as you add checks, locations, and execution frequency, particularly with per-execution billing.
Best Practices for Reliable Synthetic Monitoring
Prioritize critical workflows: Start with login, authentication, checkout, and other operations whose failure would significantly affect users. Use lightweight endpoint checks for basic availability and reserve multistep or browser tests for workflows that require deeper validation. Include response assertions so a successful HTTP status doesn’t conceal an application error.
Write maintainable browser tests: Prefer stable, user-facing locators such as getByRole() and getByTestId() over selectors tied to CSS classes or DOM structure. Use auto-retrying assertions instead of fixed delays, and update monitoring scripts alongside application changes. This reduces failures caused by UI changes rather than actual service problems.
Configure alerts around meaningful failures: Use retries or consecutive-failure thresholds to filter brief network interruptions, but avoid delaying alerts beyond the response time your service requires. Monitor important regions individually, even if you use multiple-location confirmation for widespread outages. Also alert on missing check results so a failed monitoring runner doesn’t silently appear healthy.
Protect credentials and production data: Store monitoring credentials in a secret manager and use dedicated, least-privilege test accounts. For checks that modify data, create isolated test records and implement cleanup that runs even after a failure. Use supported payment test modes where applicable. If a workflow cannot run safely against production, keep it in pre-production testing rather than scheduling it as a production monitor.
Review and maintain your checks: Assign an owner to each important monitor, review recurring failures, and remove checks that no longer represent current application behavior. Reassess execution frequency and probe locations as services change. When investigating incidents, compare synthetic failures with RUM, application logs, metrics, and traces to distinguish external availability problems from application failures.
Finally, synthetic monitoring is not load testing. Synthetic checks send controlled requests at regular intervals to verify availability and correctness. Load tests generate traffic at defined concurrency or arrival rates to evaluate performance under increasing demand. A synthetic check passing every minute doesn’t establish that the service can handle peak traffic.
How to Choose a Synthetic Monitoring Tool
Choosing a synthetic monitoring tool starts with identifying what you need to test, where those tests must run, and how you’ll investigate failures. A tool suited to public website uptime monitoring may not provide the same coverage for private Kubernetes services or complex browser journeys.
Evaluate the following capabilities:
-
Supported check types: Look for HTTP/API, DNS, TCP, and SSL/TLS checks for endpoint and network monitoring. If you need to validate login, checkout, or other user journeys, confirm that the tool supports multistep API tests or browser automation. Not every platform supports all these check types. -
Assertions and validation: Check whether you can validate response status codes, headers, JSON fields, response bodies, and latency thresholds. These capabilities help detect application errors that basic availability checks might miss. -
Public and private probe locations: Public probes help detect failures affecting users in different regions, while private runners can monitor services inside Kubernetes clusters or VPCs. Confirm that the tool supports the locations and network access your services require, including whether checks run from every selected location or rotate between them. -
Alerting and failure handling: Look for configurable execution intervals, retries, failure thresholds, no-data detection, and integration with Slack, PagerDuty, or your incident management system. The tool should help distinguish temporary probe failures from sustained outages without hiding genuine regional problems. -
Troubleshooting capabilities: Useful results include failed assertions, request timings, execution logs, and screenshots for browser checks. Integration with application logs, metrics, and distributed traces helps you investigate whether an alert originated from network connectivity, application errors, or infrastructure problems. -
Automation and maintenance: Terraform, APIs, and CI/CD integrations let you manage checks alongside application changes. Also evaluate credential management, access controls, and the effort required to maintain scripts or self-hosted runners.
Compare Deployment and Pricing Models
Open-source tools can reduce software licensing costs, but you still need to maintain their monitoring infrastructure. For example, Prometheus blackbox_exporter supports HTTP, HTTPS, DNS, TCP, ICMP, and gRPC probing, with Prometheus typically scheduling its executions through scrapes. Uptime Kuma provides self-hosted uptime monitoring with a web interface and notification integrations. Managed services handle more of the monitoring infrastructure for you, although their billing models vary.
When comparing prices, calculate how many checks you’ll execute each month. For example, 10 API checks running every minute from three independently active locations generate 1,296,000 executions over 30 days. Changing the interval to five minutes reduces that number to 259,200 executions.
These figures represent executions, not necessarily billable units. Some platforms charge for each probe run, while others count individual requests within multistep checks, browser execution time, or retries. Location scheduling also matters: Grafana Synthetic Monitoring runs checks independently from each selected probe, while other platforms may rotate execution locations. Review included allowances, overage rates, and private-runner costs before comparing monthly prices.
How groundcover Supports Synthetic Monitoring in Kubernetes
For teams already monitoring Kubernetes applications, groundcover Synthetics combines scheduled endpoint checks with application and infrastructure observability. Checks execute from the groundcover backend deployed in your own cloud, allowing you to monitor private services without exposing them to public monitoring probes. Each synthetic execution generates a trace that you can investigate alongside application logs, metrics, and other traces.
groundcover supports HTTP/HTTPS synthetic checks through its interface, with SSL/TLS, TCP, and DNS checks available through its Terraform provider. If you require browser-based journeys or checks from public geographic locations, verify those requirements separately rather than assuming the same coverage.
Unlike per-execution pricing, groundcover’s pricing is based on monitored hosts. Synthetics is included on its Pro ($30 per host/month), Enterprise ($35), and On-Premise ($50) plans, without an additional license charge for each synthetic test. The Free plan doesn’t include Synthetics, and infrastructure costs associated with running the BYOC backend remain separate.
Ultimately, the right tool is the one that can test your critical services from the necessary locations, detect meaningful failures, and provide enough context to investigate them without creating excessive monitoring costs or maintenance work.
FAQs
Choose the interval based on how quickly you need to detect failures. Critical payment, authentication, and checkout endpoints can start with one-minute checks, while lower-priority pages may only need checks every 15–60 minutes. Add retries or failure thresholds to reduce alerts caused by transient errors, but account for the extra detection time. Shorter intervals also increase execution volume and potentially costs, so configure frequency according to each service’s reliability requirements rather than using one interval for every check.
Synthetic monitoring is an active approach that generates test traffic to verify application availability and performance, even when no users are active. Passive monitoring observes existing traffic and activity without generating synthetic test requests. Examples include real user monitoring (RUM) and network traffic analysis.
Synthetic monitoring is useful for proactively detecting failures along predefined paths, while passive monitoring captures behavior occurring under actual operating conditions. Both approaches complement each other: synthetic tests can identify problems before users encounter them, and passive data helps determine their real-world impact.
Synthetic monitoring and end-to-end (E2E) testing can use the same automation frameworks, such as Playwright, but differ in purpose and execution. E2E tests typically run during development or CI/CD to validate application behavior, while synthetic monitors run on a schedule to detect failures in deployed services and trigger alerts when configured conditions are met.
You can reuse test scripts for both, but production monitors require additional safeguards. Unlike tests using mocked dependencies, production checks interact with live systems and may need dedicated test accounts, controlled data, and cleanup procedures.
The best synthetic monitoring software depends on what you’re testing and where checks need to run. Checkly supports Playwright-based browser and API monitoring, while Grafana Cloud Synthetic Monitoring provides protocol, API, scripted, and browser checks with public and private probes. Uptime Kuma suits basic self-hosted uptime monitoring, and Prometheus blackbox_exporter supports protocol-level checks for Prometheus-based environments.
For Kubernetes teams that need to monitor private endpoints and investigate failures using application telemetry, groundcover Synthetics integrates scheduled checks with logs, metrics, and traces. Compare check types, probe locations, troubleshooting capabilities, and pricing before choosing a platform.
Yes. Synthetic checks can monitor private Kubernetes services when their execution environment has network access to the target. You can deploy a private runner inside a cluster or VPC, subject to DNS resolution and network policies, without exposing internal endpoints to the public internet.
For example, groundcover runs synthetic checks from its installed BYOC backend. This lets you test internal services and investigate failed checks alongside application and infrastructure telemetry.
It can. Browser-based synthetic checks may generate pageviews, RUM sessions, or analytics events when tracking scripts execute during tests. API checks generally don’t create browser RUM sessions, although their requests can appear in backend logs and request metrics.
To avoid distorting user analytics, identify synthetic traffic using dedicated test accounts, headers, or other supported identifiers, then exclude it from user-experience and business reporting where appropriate. Some monitoring platforms also block analytics scripts during synthetic browser tests. Keep synthetic activity identifiable in backend telemetry so you can still investigate failures.





