Open your team's Datadog. You can see the API's 99th percentile latency for the last five minutes. Open Sentry — the exact stack trace of an error that fired seventeen seconds ago. Open Amplitude — how many users hit checkout yesterday, split by plan tier.
Now try to answer the question your customer success lead pinged you about ten minutes ago: what actually happens when a user on the annual plan tries to change their email address after they've already used their one allowed rename?
No dashboard answers that. Someone has to go read the code, or ping the engineer who wrote it, or hedge a guess from a Confluence page written last quarter.
Every layer of the stack got a dashboard except one
Twenty years ago, running a serious app meant flying half-blind. You SSHed in when things broke. You tailed logs. A cron job ran a ping check every fifteen minutes. Then observability grew up. Now every layer of the stack has an instrument aimed at it — you don't write the readings down, you watch them.
Infrastructure has Datadog. Errors have Sentry. Performance has New Relic. Usage has Amplitude. Business metrics have Metabase. Every one of those started as somebody handing you a spreadsheet once a week and ended as a dashboard that reads directly from the source of truth. The team stopped maintaining a picture and started watching one.
The product itself never got an instrument. The behaviour your customers actually experience — which features exist, how they fit together, what changed in Tuesday's release — has no pane on any dashboard. The only source that reflects it, the code, is unreadable to the people who most need it.
So they do what teams did before observability existed for the other layers: they ask a person. Atlassian's 2025 research found teams waste 25% of the working week searching for answers that should already exist somewhere. The word "searching" is generous — a lot of it is queueing on an engineer's calendar.
An instrument, not an artefact
The reflex, when I explain this, is to hear "documentation." Auto-generated docs. AI-summarised READMEs. A Confluence page that finally stays fresh. That is not the reframe.
Documentation is a written artefact someone produces and everyone else reads. Observability is an instrument aimed at a live signal, and there is no separate artefact to produce or maintain in the first place. Datadog doesn't maintain a document about your CPU load — it reads your CPU load. When the load changes, the reading changes. Nothing to keep in sync, because nothing separate exists to sync.
Product observability works the same way. The signal is the code. Every feature's behaviour is encoded there, every edge case is handled there, every business rule is expressed there. Read continuously, translated into plain language for the whole team, that reading becomes a dashboard aimed at product behaviour. Ship a release, the reading updates. There is no wiki to maintain because there is no wiki. There is a code source and a rendered view — the same relationship Datadog has to your infrastructure.
That is why "does it stay current?" is the wrong question to ask about the instrument. A dashboard is not something you keep current. Being current is what it is. And that is exactly why documentation always falls out of sync — the model that produces it is upstream of the code, not downstream of it. Flip that direction and drift becomes impossible.
What the instrument reads
An observability tool for infra reads CPU, memory, request counts. What does product observability read?
Features — the units your team and your users actually think in ("sign-in", "billing", "invitations"), not files or services. Each with a set of Context/Action/Outcome scenarios that describe how the feature actually behaves, edge cases included. When a customer asks "what happens if I hit my plan limit mid-import?", that scenario is there to point at, not to reconstruct from memory.
A feature map that shows how features connect. Which feature triggers which. Which shares state with which. Where the surface bulges out because a small billing change ends up touching three flows nobody was thinking about.
A per-release changelog that says what actually shipped, not what someone wrote in the Jira ticket. Not "we improved invitation handling" — "invitation links now expire after 7 days instead of 14, so a pending invitation older than a week has to be sent again." The DORA 2024 report found documentation quality is directly linked to organisational performance. Teams reach that link when the changelog is trusted, not when the wiki is thick.
None of that reading gets stored in a separate document. It is the current view of the current codebase, rendered in plain language, updated on every release.
What changes when you have the missing pane
Two things change immediately. A third takes a couple of months.
First, customer success stops queueing on engineering. The question "what happens if a user does X in state Y?" gets answered by opening the feature and reading the scenario. When only 3% of engineers completely trust their internal documentation (Port.io, 2025), the fact that CS routes around it entirely isn't a wiki-quality problem — it's a category problem. The category was missing.
Second, PMs and stakeholders share what shipped without asking. Every release, the changelog is a link. The founder answers a sales-call question without pinging engineering. The PM writes a stakeholder update from the report instead of interviewing the team.
Third — and this is the compound effect — the team stops treating "what does this feature do?" as a fragile thing that lives in senior engineers' heads. It becomes a query, the same way "what was our p95 latency at 3am on Tuesday?" is a query. The knowledge stops being human-shaped and single-point-of-failure. It becomes readable.
The observability shift is not new. Every other layer of the stack went through it a decade ago. The layer the customers actually touch is next, and product observability is what it looks like.
The demo project is Specsight running on a real codebase — features, scenarios, feature map, changelog. No account required. If you want to point Specsight at your own repository, get started.
