Most observability stacks reflect a quiet divide. Engineers watch CPU, memory, latency, and error rate. Product and revenue teams watch signups, checkout conversion, and ARR. The metrics live in different systems, are queried by different people, and rarely cross paths — except during incidents, when the divide becomes a problem.
A latency spike at 3 PM might or might not have hurt revenue. A signup drop might or might not be an infrastructure issue. Without business metrics in the same place as system metrics, every incident retrospective requires a cross-team data hunt. The teams that observe the gap close it by treating business metrics as observability data, instrumented the same way and queried in the same UI.
This guide is about how to do that without breaking the observability backend.
Why It Matters
Three concrete benefits of pulling business metrics into the observability stack:
-
Incident triage with business impact. "Checkout latency rose by 30% at 14:32" matters more when next to "checkout conversion dropped by 18% at 14:35." The bridge between the two is the first thing leadership asks for during an incident review.
-
Faster detection of silent failures. A code change that breaks a button doesn't move the latency or error metrics. It moves "button click rate." Without that metric, the issue surfaces from sales, not monitoring.
-
Tighter feedback loops on engineering changes. A latency optimization is one thing. A latency optimization that demonstrably moved checkout conversion is another. The data closes the loop.
The argument against — "these are product metrics, not engineering metrics" — falls apart in practice. They are operational metrics that happen to be measured in dollars instead of seconds.
Where to Put Them
Two architectural patterns.
Same backend, separate namespace. Emit business metrics from application code to the same time-series database (Prometheus, Datadog) as system metrics. Use a clear naming convention to distinguish: business_* or revenue_* as the metric prefix.
$metrics->counter('business_checkout_completed_total')
->inc(['plan' => 'pro', 'country' => 'US']);
Grafana dashboards include both side by side. Alerts can fire on business metrics the same way they fire on system metrics. Cross-correlation is trivial.
Bridge from a separate analytics system. Emit business events to the analytics pipeline (Snowflake, BigQuery, etc.) and replicate aggregates back to the metrics backend periodically. Pre-aggregate the high-value rollups ("daily checkout count by plan") and write them as metrics.
The first pattern is simpler and produces better latency on the metrics — useful for incident triage. The second pattern is better when business metrics need the dimensionality of a real analytics warehouse. Many teams do both: realtime aggregates in metrics, deep slicing in analytics.
Naming Conventions
The single most common failure: emitting business metrics with names that conflict with or shadow system metrics. requests_total already exists. Adding a requests_total for "checkout requests" makes both unusable.
A few conventions that hold up:
- Prefix consistently.
business_*for events with revenue meaning.product_*for behavioral events that aren't revenue-tied. - Use the same unit conventions as system metrics. Counters end in
_total, gauges have no suffix, durations end in_seconds. - Reflect what the metric measures, not where it came from.
business_signup_completed_totalis better thanweb_app_signup_handler_count. - Use labels for slicing, not metric names.
business_checkout_completed_total{plan="pro"}is correct;business_checkout_pro_completed_totalis not.
Naming is harder than it looks. Disagreement on a label name takes more time to fix later than to debate now.
Cardinality Risk
The most dangerous mistake is adding business dimensions that look natural but have unbounded cardinality.
user_idas a label — one series per user. Explodes immediately.email— same problem.referrer_url— long tail of unique strings.utm_campaign— usually fine, but verify.country— bounded; safe.plan— bounded; safe.currency— bounded; safe.
The rule: a label is safe if you can enumerate every value it will ever take. If you cannot, do not use it as a label.
When you need high-cardinality dimensions (per-user revenue, per-merchant volume), do not put them in Prometheus. Put them in the analytics warehouse and pull aggregates back. Or use a high-cardinality-friendly backend like Honeycomb.
Ownership
The other failure mode is unclear ownership. When the metric is part of both the engineering observability stack and the product analytics, both teams assume the other owns its accuracy. Three months later it has drifted from reality and nobody noticed.
A workable ownership model:
- The team that emits the metric owns its correctness.
- The team that consumes the metric is responsible for catching drift ("the dashboard says X, the warehouse says Y, they should match").
- A formal review is run quarterly across the business metrics, with a single person responsible for any reconciliation.
Without this, drift is inevitable.
Examples That Work
A few business metrics that consistently pay off when instrumented:
- Conversion funnels. Per-step counters from page view to completed action.
funnel_step_visited_total{step="plan_selection"}. Drops in any step are visible immediately. - Revenue events.
revenue_event_totalwith labels for plan, currency, and event type. A counter for every payment, refund, upgrade, downgrade. - Feature usage. Counters per feature for daily active users. Highlights when a release ships that nobody uses — or breaks something that gets used heavily.
- Customer-impact errors. A subset of system errors that affect customer outcomes. "User saw an error page" rather than "the server returned 500." Different aggregates, different alerts.
- Time-on-page or session duration. A direct signal of user experience, often more responsive than Core Web Vitals to specific UI changes.
Each of these is one or two counter/gauge metrics in the application code. The investment is small; the visibility is substantial.
Alerts That Use Business Metrics
Most incident-grade alerts are still about system metrics. But a small set of business-metric alerts catch problems that system metrics miss:
- Sudden drop in primary conversion. "Checkout completion rate dropped 30% in the last hour." Almost always meaningful.
- Specific revenue events at zero. "No new subscriptions in the last 30 minutes." Off-hours noise makes this hard to tune; usually paired with a comparison to last week.
- Per-region conversion delta. "US conversion rate is normal; EU conversion rate dropped." Usually means a region-specific bug.
These alerts have higher false-positive rates than system metrics (legitimate business variance is normal). Route them to a low-priority channel for the first quarter while you tune. Promote to page-grade only after demonstrated reliability.
Annotations Cross the Gap Too
A dashboard that shows business metrics next to system metrics is most useful with annotations. Deploys, feature flag flips, marketing campaign launches, third-party incidents — each of these belongs as an annotation on both the system and business panels.
A deploy annotation explains a latency change. A campaign launch annotation explains a signup spike. The dashboard moves from "here are some lines" to "here is the story" the moment annotations are wired in.
What Engineers Should Stop Trying to Own
A few business metrics belong in the analytics stack, not the observability stack:
- LTV, CAC, cohort retention. Time horizons longer than a few weeks; rarely useful in incident response.
- A/B test outcomes. Statistical significance and cohort tracking are not what time-series databases do.
- Funnel analyses with arbitrary cohorts. Better in a real analytics tool.
The metrics that belong in the observability stack are the ones useful for short-time-horizon decisions during incidents and within hours of a deploy. Everything else is product analytics' territory.
A Starting Set
For a team adding business metrics to its observability stack for the first time:
- Identify the top three customer-facing actions (login, signup, checkout — whatever maps to your product).
- Emit a counter for each, with bounded labels (plan, country, source).
- Build a dashboard with these metrics next to the corresponding system metrics for the same paths.
- Add annotations for deploys.
- Watch for a quarter. Add one alert for the most important conversion metric.
This is a few days of work and bridges a gap that often takes a full incident retrospective to discover exists.
Building observability that ties customer outcomes to system health? We help teams design metrics that engineering, product, and revenue all use together. scopeforged.com