A feature is not finished when it passes its tests. It is finished when someone can tell, in production, that it does what was intended. The two statements sound alike and differ in practice. Tests run before release against prepared conditions. Production runs afterward against real users, real data and combinations nobody prepared. If the only evidence that a feature works is an absence of complaints, the team has not yet learned whether the intent survived.
What observability means for a single feature
The OpenTelemetry primer on observability describes observability as the ability to understand a system from the outside by asking questions about it, without needing to know its inner workings. The practical meaning for a product owner is simple. After release, when something looks odd, the team should be able to answer questions it did not predict, using signals the system already emits.
Those signals are usually grouped into three kinds, described in the OpenTelemetry documentation on signals: metrics, which are numeric measurements over time; logs, which are records of events; and traces, which follow a single request through the parts of a system. Each answers a different question. Metrics say how often and how fast. Logs say what happened. Traces say where the time or the failure went.
Start from the acceptance criteria
The most useful habit is to pair every acceptance criterion with something observable. A criterion such as “a customer who confirms a new delivery date sees the updated date immediately” can be paired with an event recorded when the date is confirmed and an event recorded when the updated date is displayed. If the two counts diverge, the intent is being lost somewhere between them, and the divergence is visible without anyone filing a report.
This turns acceptance from a moment before release into a state that can be checked at any time. A criterion with no way to observe it in production is a hope. When a criterion has no obvious signal, that is worth discussing, because it usually means the criterion is vague.
Two kinds of signals
Product owners need to distinguish technical signals from behavioral ones.
- Technical signals describe the health of the machinery: error counts, response times, queue depth. They tell the team whether the feature is running.
- Behavioral signals describe whether people use the feature as intended: how many start the flow, how many complete it, where they stop. They tell the team whether the feature is working for its purpose.
A feature can be healthy on the first kind and failing on the second. A form that loads quickly and never produces a completed submission looks fine on a dashboard of response times. Both kinds belong on the page the product owner reads.
Instrumenting at the boundary
For a feature added to a running product, the most informative place to measure is the boundary where the new behavior meets the existing system. Calls into the core, data read from it and results returned to it all cross that boundary, and failures there are the hardest to attribute. A few well-chosen measurements at the edge, with a trace that follows a request across it, usually tell the team more than many measurements deep inside the feature.
The same signals give a team a shared reference when it is joined by outside engineers. In software engineering staff augmentation, as JetRuby describes it, senior engineers join the in-house team, work in its tools and under its management, so the dashboards, alerts and traces already in place are the ones the newcomers read. A criterion paired with a signal at the boundary tells a newly arrived engineer what a correct change looks like in production, without anyone having to retell the intent.
Care with what is recorded
Observability is not a license to record everything. Logs and events can easily capture personal data, credentials or content that was never meant to be stored. Before instrumenting, the team should agree on what is allowed into signals, what must be removed or masked, and how long the data is kept. This is a product and legal question as well as an engineering one, and it is easier to settle before the first event is written than after a large archive exists.
Alerts that mean something
Signals only help if someone looks at them. Alerts should point at symptoms people care about, such as the completion rate of the main flow dropping, and not at every internal fluctuation. An alert that fires constantly is soon ignored. For each alert, the team should know who receives it and what the first step is.
Common mistakes
- Instrumentation added after the first incident. The signals are then missing for exactly the failure that made them necessary.
- Dashboards built for engineers only. If the product owner cannot read the page, the intent cannot be checked by the person who holds it.
- Signals with no baseline. A number means little until the team knows what normal looks like, so observation should begin early in the rollout.
- Too many signals. A handful per criterion is enough. More hides the few that matter.
In short
A new capability is accepted twice: before release against criteria, and after release against evidence. Pair each criterion with a signal, measure at the boundary with the existing system, separate technical from behavioral signals, protect what is recorded, and alert on symptoms. The result is a feature whose behavior the team can read at any time rather than guess.

