A production cloud application needs more than a collection of dashboards. It needs a deliberate observability stack that connects logs, metrics, traces, error events, uptime checks, and alerts to the people responsible for responding. This checklist explains what to monitor, how to set useful signals and thresholds, how to review changes on a recurring cadence, and when to update the stack as your architecture evolves.
Overview
Observability helps a team understand what an application is doing from the evidence it produces. Monitoring usually starts with known conditions, such as whether a service is available or whether latency exceeds a threshold. Observability goes further by helping engineers investigate unfamiliar failures and connect a user-visible symptom to the underlying service, dependency, deployment, or resource constraint.
A practical observability stack for a cloud-native application does not need every available tool. It needs consistent signals, useful context, sensible retention, controlled access, and clear ownership. The stack may be assembled from a cloud provider, a platform as a service, an application performance monitoring product, open-source components, or a combination of these. The provider matters less than whether the system supports the workflow your team must follow during normal operation and an incident.
Use this guide when launching a service, adding a database or external API, changing deployment infrastructure, investigating noisy alerts, reviewing an outage, or evaluating a monitoring vendor. Treat the checklist as a living part of your cloud deployment workflow rather than a one-time implementation task.
What to track
Start by mapping each important user journey to the services and dependencies that support it. For a web application, that may include the browser or mobile client, edge layer, application service, authentication provider, database, queue, object storage, and third-party APIs. Then confirm that each layer produces enough evidence to answer three questions: Is the system working? Who is affected? What changed?
Core observability signals
| Signal or capability | What to capture | Review questions |
|---|---|---|
| Logs | Structured events with timestamp, severity, service, environment, request or trace identifier, and a safe summary of the event. | Can an engineer reconstruct the sequence of a failed request without exposing secrets or personal data? |
| Metrics | Request rate, error rate, latency distributions, saturation, resource use, queue depth, and business-relevant outcomes. | Do the metrics show both user impact and the condition that may be causing it? |
| Traces | Propagation of a request or job across services, databases, queues, and external calls. | Can the team identify where time is spent and which dependency failed? |
| Error tracking | Unhandled exceptions, rejected promises, failed jobs, release or version context, and useful stack details. | Are duplicate errors grouped, prioritized, and assigned to an owner? |
| Uptime checks | External checks for key endpoints and, where appropriate, synthetic user journeys. | Would the check detect an outage that internal infrastructure metrics might miss? |
| Dashboards | A small set of service, dependency, deployment, and user-journey views. | Can an on-call engineer understand current health without searching through unrelated panels? |
| Alert routing | Severity, condition, destination, escalation path, owner, and link to a runbook. | Does each actionable alert reach someone who can respond at the required time? |
Logging checklist
- Use structured logs where possible so fields can be filtered and grouped consistently.
- Include environment, service name, deployment version, severity, and correlation identifiers.
- Record useful request context without logging passwords, tokens, payment details, or unnecessary personal information.
- Define retention by operational value and access requirements rather than keeping everything indefinitely.
- Make application logs distinguishable from audit records, security events, and provider logs.
Metrics and traces checklist
- Track request volume, successful responses, failures, and latency using dimensions that remain manageable.
- Measure latency distributions rather than relying only on averages; slow requests can be hidden by an average.
- Instrument background jobs, queue processing, scheduled functions, and asynchronous workflows.
- Propagate trace context across service boundaries and external calls when the integration supports it.
- Use OpenTelemetry where it fits your architecture to create a portable approach to telemetry collection and export.
- Separate high-cardinality diagnostic data from low-cardinality metrics used for dashboards and alerts.
Service-level indicators and alerts
Define service-level indicators, or SLIs, around user impact. Examples include the proportion of successful requests, the latency of a critical workflow, the percentage of jobs completed on time, or the availability of a public endpoint. An alert should normally indicate a condition that requires action, not merely an interesting change in a graph.
For each alert, document the condition, severity, owner, notification route, expected response, and runbook link. Consider separating urgent paging alerts from lower-priority tickets or scheduled review items. A threshold that looks reasonable in a test environment may be unsuitable in production, so validate it against normal traffic and known busy periods before relying on it.
Cadence and checkpoints
Observability quality changes as application behavior, traffic, dependencies, and team responsibilities change. A recurring review prevents dashboards and alerts from becoming historical artifacts.
At launch or before production release
- List critical user journeys and confirm that each has a measurable success signal.
- Verify telemetry in the production-like environment, including logs, traces, error events, and external uptime checks.
- Test alert delivery and confirm that recipients can access dashboards and runbooks.
- Check redaction for credentials, tokens, personal information, and sensitive request data.
- Record retention settings, sampling decisions, expected ingestion volume, and ownership.
Monthly or quarterly review
- Review alert volume, acknowledged alerts, escalations, and alerts that produced no action.
- Compare error rates and latency with the previous review period, while accounting for changes in traffic or releases.
- Remove obsolete dashboards, duplicate alerts, unused log fields, and instrumentation for retired services.
- Check that service owners, on-call rotations, escalation routes, and runbook links are current.
- Review retention, sampling, data access, and telemetry costs against the application’s current needs.
After a deployment, dependency change, or incident
Compare the deployment or change window with request errors, latency, saturation, dependency failures, and user reports. If the signal is ambiguous, improve instrumentation before simply adding more alerts. Following an incident, update the relevant dashboard and runbook, add a narrowly defined alert only when it represents an actionable failure mode, and record who owns the follow-up.
How to interpret changes
A change in one signal is rarely a complete diagnosis. Use the relationship between signals to narrow the investigation. A rise in error rate after a release may point to a code or configuration change, while stable application errors combined with rising database latency may indicate dependency pressure. Increased latency without increased traffic can warrant a review of deployment changes, resource limits, connection pools, or an external provider.
Check scope before severity. Determine whether the issue affects all users, one region, one endpoint, one tenant, or one version. Then compare current values with a relevant baseline: a recent normal period, a comparable traffic window, or the last deployment. Avoid treating every deviation as an incident. A useful alert combines a meaningful condition with enough duration or impact to justify intervention.
When an alert is noisy, ask four questions:
- Was the alert actionable when it fired?
- Did it identify user impact or a credible risk?
- Did the assigned responder have enough context to act?
- Should the condition be tuned, routed differently, documented, or removed?
Incident-review template
After an outage or significant degradation, capture the affected service and user journey, start and end times, detection method, scope of impact, relevant logs and traces, timeline of changes, response actions, contributing conditions, and follow-up owners. Also note what was missing: a signal, a dashboard, a runbook step, an escalation route, or permission to access the evidence. This turns an incident review into an observability improvement plan rather than only a narrative.
When to revisit
Schedule a formal observability review at least monthly or quarterly, depending on the service’s change rate and operational risk. Revisit sooner when you launch a new application, add a service or data store, introduce a queue or serverless function, change cloud providers, alter deployment workflows, or adopt a new monitoring vendor. Also review the stack after repeated false alarms, an undetected failure, an increase in traffic, a major security or privacy requirement, or a change in on-call ownership.
At each review, use this short action list:
- Choose one critical user journey and trace it from external check to dependency.
- Confirm that logs, metrics, traces, and error events share enough context to be correlated.
- Inspect the last period’s alerts and label each as actionable, noisy, missing context, or obsolete.
- Verify redaction, retention, access, sampling, and current platform integration settings.
- Assign owners and due dates for gaps, then record the next review date.
Keep this checklist with the service’s architecture notes, deployment workflow, and incident runbooks. The goal is not to collect every possible signal. It is to maintain a dependable path from user symptom to evidence, decision, and responsible action as the cloud application changes.