A reliable uptime program starts with the endpoint, not the dashboard. This guide explains how to design useful website health checks, separate liveness from readiness, choose practical timeout and alert rules, and investigate failures involving dependencies, TLS, DNS, or monitoring providers. It also gives you a recurring review process so checks remain accurate as the application changes.
Overview
A website health check is a controlled request used to answer a narrow question: can a service be reached, and is it responding as expected? Uptime monitoring adds a schedule, one or more monitoring locations, alert rules, and an incident workflow around that request.
Do not treat one endpoint as proof that every user journey works. A successful response from a load balancer may hide a failed database, an expired certificate on another hostname, or a broken checkout flow. Conversely, an endpoint that checks every dependency can create false alarms when a nonessential integration is slow.
A practical monitoring design uses several layers:
- Liveness: Is the process or web server running and able to accept requests?
- Readiness: Is the instance prepared to serve normal traffic?
- Dependency checks: Are critical services such as a database or queue available?
- Synthetic checks: Can a representative user action, such as signing in or submitting a form, complete?
- Regional checks: Does the application work from the locations that matter to your users?
The goal is not to produce the largest number of checks. It is to create signals that an on-call person can understand and act on. Every alert should identify the affected service, the test that failed, the likely scope, and the next diagnostic step.
What to track
Design separate liveness and readiness endpoints
A liveness endpoint should be cheap and dependency-light. It might return 200 OK with a small JSON body when the application process is running. It should not perform an expensive database query on every probe unless the process cannot function without that query.
A readiness endpoint answers a different question: should this instance receive traffic? It can check essential dependencies and return a failure when the application is starting, shutting down, or unable to serve requests safely. In a containerized environment, this distinction helps an orchestrator restart unhealthy processes without repeatedly restarting a process that is alive but waiting for a dependency or deployment step.
Keep the response contract predictable. For example:
{
"status": "ok",
"service": "web",
"version": "2026.03.01"
}For a readiness response, include dependency state only when doing so does not expose sensitive information:
{
"status": "degraded",
"ready": false,
"checks": {
"database": "timeout",
"cache": "ok"
}
}Return an HTTP success status only when the endpoint meets the promise implied by its name. Avoid returning a custom success page with a 200 status for a failed application. Monitoring systems generally make decisions from status codes, response time, and body validation; inconsistent contracts make those decisions unreliable.
Track the right measurements
- Availability: Whether the expected status and body were returned.
- Response time: Record total request time and, where available, connection, TLS, time-to-first-byte, and content-transfer phases.
- Timeouts: A timeout is different from an HTTP error. Preserve that distinction in alerts and incident notes.
- Status-code distribution: A growing share of redirects, client errors, or server errors can reveal a problem before a complete outage.
- TLS and certificate validity: Monitor certificate expiration and hostname mismatches separately from application availability.
- DNS resolution: Test that the expected record resolves from relevant locations and that the answer points to the intended service.
- Content assertions: Check for a stable marker such as a known JSON field, page title, or response value rather than matching an entire page.
Use authenticated checks carefully. A public health endpoint is safer for basic reachability, while a synthetic transaction may require a dedicated test account, restricted permissions, and secrets stored in the monitoring platform rather than in a URL.
Choose a monitoring approach
| Approach | Useful for | Strengths | Verify before adopting |
|---|---|---|---|
| Hosted HTTP monitoring | Public endpoints and simple APIs | Fast setup, external vantage points, alert delivery | Regions, body assertions, retention, escalation controls, and maintenance windows |
| Cloud-native monitoring | Services already operating inside one cloud environment | Close integration with logs, metrics, load balancers, and deployment systems | External probe locations, cross-region visibility, and the cost of high-frequency checks |
| Self-hosted monitoring | Private networks or teams requiring control of probe data | Custom checks, internal reachability, and deployment flexibility | Probe redundancy, upgrades, storage, alert delivery, and operational ownership |
| Browser or synthetic monitoring | Sign-in, checkout, search, and other user journeys | Finds failures that a basic status check cannot see | Test-account maintenance, secret handling, runtime limits, and false failures caused by changing UI elements |
Provider features and pricing change, so compare the current documentation for check frequency, supported protocols, locations, status-page integrations, retention, notification channels, and incident escalation. Choose based on the failure modes you need to detect rather than on the number of dashboard features.
Cadence and checkpoints
Start with a small baseline and add complexity only when an observed failure justifies it. A reasonable initial setup includes one liveness check, one readiness or API check, a TLS check, and a synthetic check for the most important user journey.
Practical starting values
Use these as starting points, then adjust them to your application and network conditions:
- Set the request timeout comfortably above normal response time but below the point where users or upstream systems give up. For many simple HTTP checks, a timeout in the range of several seconds is a starting assumption, not a universal rule.
- Require two or more consecutive failures before paging for a transient public-endpoint error, unless the service is safety-critical or the check represents a confirmed user transaction.
- Use a recovery notification after one or more successful checks, and include the duration and affected locations.
- Use a separate warning threshold for slow responses. A service can be technically available while becoming too slow to use.
- Run checks from more than one location before declaring a broad outage. A single failing region may indicate a routing, provider, or local network issue.
Document each check in a small register with its URL, owner, purpose, expected status, body assertion, timeout, frequency, locations, severity, and maintenance-window behavior. Review this register monthly or after every material deployment.
Alert-tuning checklist
- Does the alert state exactly which hostname, path, region, and assertion failed?
- Can an engineer reproduce it with a command-line request or an equivalent internal check?
- Is the threshold based on user impact rather than an arbitrary round number?
- Are deployment windows and planned maintenance suppressed without hiding unrelated failures?
- Are alerts grouped so one dependency outage does not create dozens of duplicate pages?
- Does the recovery message close the loop with duration, locations, and suspected cause?
- Is there a lower-severity notification for intermittent or slow behavior?
For command-line reproduction, inspect headers, status, timing, and the response body rather than relying on a browser alone. A curl and jq workflow can make JSON checks repeatable; see the command-line API testing guide for a practical reference.
How to interpret changes
Incident runbook
- Confirm the signal. Check whether the failure is occurring from one location or several. Compare the monitor result with an independent request and application telemetry.
- Classify the failure. Separate DNS resolution errors, TCP connection failures, TLS errors, timeouts, HTTP status failures, and body-assertion failures. Each points to a different investigation path.
- Check recent changes. Review deployments, configuration changes, certificate renewals, DNS edits, feature flags, and dependency releases. Do not roll back automatically without confirming the affected component.
- Check the dependency boundary. If readiness fails because a database or third-party API is unavailable, determine whether that dependency is essential. A nonessential integration should usually degrade gracefully rather than make the whole site appear offline.
- Reduce blast radius. Use a rollback, traffic shift, feature-flag change, or temporary rate limit only when the action is understood and reversible. Record the decision and time.
- Validate recovery. Confirm successful checks from multiple locations, inspect error rates and latency, and test the affected user journey. A green health endpoint alone is not enough after a complex incident.
Common failure patterns
False positive: A single probe fails while users and other regions succeed. Check monitor network conditions, DNS answers, firewall rules, and the threshold for consecutive failures before changing application code.
Cascading dependency failure: A shared database, identity provider, or queue causes several endpoints to fail. Identify the common dependency, stop noisy duplicate alerts, and decide whether the application should serve a limited mode.
Slow responses: Status codes remain successful but latency rises. Compare application timing with database, cache, and upstream timing. A longer timeout may hide the symptom, so use a warning threshold and investigate the cause.
Certificate or DNS error: Confirm the hostname, certificate chain, expiration, CAA or certificate automation behavior, and the authoritative DNS response. The ACME certificate renewal guide and DNS runbook provide useful adjacent checklists.
When to revisit
Review health checks on a monthly or quarterly cadence, and immediately after any event that changes the path a user takes to reach the application. At minimum, revisit them after a hosting move, DNS change, reverse-proxy change, certificate renewal workflow, database migration, new critical dependency, or major deployment pipeline change.
During each review, compare alert volume with confirmed incidents. Remove checks that no longer represent user impact, replace brittle body assertions, verify that test accounts still work, and confirm that notification recipients and escalation rules are current. Check whether monitoring costs, retention, and probe locations still match the service requirements; provider capabilities can change over time.
Keep a short review record containing the date, changes made, checks retired, new failure modes discovered, and the person responsible for follow-up. Then run a controlled failure test: return a known error in a nonproduction environment, block a test dependency, or use a temporary maintenance response. Confirm that the expected alert, suppression, escalation, and recovery messages arrive.
Finish by publishing a one-page operational summary: endpoint contracts, owners, severity definitions, timeout assumptions, dependency behavior, and the first commands to run during an incident. A health check is valuable only when it remains aligned with the service and helps someone make a faster, safer decision.