Opsphere
← All articles

Service Catalog Observability: Connect Ownership to Telemetry

Service Catalog Observability: Connect Ownership to Telemetry

Abstract service catalog aligned with telemetry

A service catalog tells your team what exists, who owns it and what it depends on. Observability tells you what those services are doing right now. Service catalog observability joins the two, so that every alert, trace and log line lands on a named service with a named owner, and so that what the catalog documents is checked against what production actually does.

This guide is for SRE, DevOps and platform teams that want that join without adding yet another tool to the stack. It covers what to record, how to keep it from going stale, what to look for in catalog software and how MCP and AI agents change the evaluation.

Opsphere
Connect Operational Context to Telemetry
Opsphere brings cloud, observability, CI/CD, security and engineering context together to help teams investigate incidents from a single interface.
Visit

TL;DR

  • Problem: Service metadata (owner, tier, dependencies) lives in one place and telemetry in others. During an incident, engineers reconcile the two by hand.
  • Takeaway: A catalog is useful for observability only when each entry carries the same identifiers your telemetry uses, and when registration and sync are automated rather than maintained by hand.
  • Evidence: A team that built an in-house catalog reported that entries went stale as team names and ownership changed. Enforcing registration at creation and syncing on a schedule were its fixes.
  • Next step: Standardize four to five attributes across services, pick the systems that will feed the catalog automatically, and evaluate tools on integrations, governance and total cost.

Table of Contents

What service catalog observability means

The phrase covers two related ideas, and it helps to separate them from two things it is often confused with.

A service catalog is a system of record for the services your organization runs. Each entry usually names the owner, the tier or criticality, the environment, the dependencies and links to the repository, runbook and dashboards.

Observability is the ability to understand a system’s internal state from the telemetry it emits: metrics, logs and traces.

Service catalog observability is the practice of tying the first to the second. The catalog says what a service should look like (a tier-1 service, owned by the payments team, depending on a database and a queue). Telemetry shows whether production agrees. When they diverge, one of them is wrong, and finding out which is the point.

It is not the same as:

  • An IT service request catalog. That is a menu of things employees can order, such as a laptop or an access request. It is built for requesters, not for engineers investigating a latency spike.
  • An observability platform. A platform stores and analyzes telemetry. It does not decide who owns a service or what its availability target is. It needs the catalog to supply that context.

In practice the two meet in the incident. An alert fires for a service name. Someone has to answer: who owns this, what does it call, what changed recently, and how important is it? If the answers live in a wiki, a spreadsheet and three consoles, the first ten minutes go to assembling context instead of fixing the problem.

What an observability-ready catalog entry contains

A catalog entry that supports observability needs fields that telemetry can match against. The most useful starting point is a shared naming scheme for resource attributes.

OpenTelemetry’s guidance on managed telemetry platforms for Kubernetes workloads recommends organizational resource attributes such as service.name, service.version, service.namespace or service.owner, and deployment.environment.name. The reason is practical: with those attributes on every signal, telemetry can be identified and associated with the team responsible for it.

A workable minimum catalog entry looks like this:

Field What it answers Matches telemetry attribute
Service name Which service is this? service.name
Owner or team Who gets paged and who decides? service.owner or service.namespace
Environment Production, staging or another? deployment.environment.name
Version or release What changed? service.version
Tier How critical is it? Catalog only, used to rank alerts
Dependencies What breaks if this breaks? Derived from traces and topology
Runbook and dashboard links Where do I look first? Catalog only

Two points about this table.

First, the identifiers must be identical. If the catalog says checkout-api and telemetry says checkout_api_prod, no automated join is possible, and every correlation falls back to a human who remembers the mapping.

Second, responsibilities are split. The same OpenTelemetry guidance distinguishes application owners, who are responsible for the quality and resilience of their applications’ telemetry, from platform teams, who provide default configuration and operate the telemetry pipelines. A good catalog reflects that split: the entry shows who owns the service and which platform provides its telemetry defaults.

Examples of service catalogs in practice

Public write-ups of working catalogs are rare, and the useful ones show what teams actually put in them.

CarGurus described its internal catalog, called Showroom, in a 2023 engineering post. Each entry records ownership and automatically aggregates links to the codebase, log queries, jobs, pipelines, hosts and API documentation. It also scores each service with compliance checks and offers self-service workflows for creating services and transferring ownership.

The pattern worth copying is the aggregation. The catalog does not try to hold every detail. It points to the system that holds each one, so an engineer lands on the right log query or pipeline from a single page.

A catalog fed by Kubernetes and API specs

A 2021 API Specs conference talk (slides) describes a team that ran most of its microservices on Kubernetes. It used an internal Kubernetes catalog API to find live services and ingested them into its developer portal through custom processors. The team generated 175 API documentation pages that update automatically on a frequent interval, so anyone could discover and test endpoints without leaving the portal.

The lesson is the direction of data flow. The runtime (Kubernetes) was the source, and the catalog was populated from it. Entries that mirror what is actually deployed are harder to let drift than entries someone typed in once.

A minimal version for a small team

You do not need a portal to start. A five-person SRE team running on AWS and Kubernetes can begin with:

  1. A single list of production services with the four attributes above.
  2. A rule that a service cannot deploy without those attributes set as labels or resource attributes.
  3. A weekly check that compares the list to what is running.

That is enough to make incident triage faster, and it exposes the gaps that a tool would later need to fill.

Keep the catalog current or it becomes a liability

A stale catalog is worse than none, because engineers trust it. The CarGurus team reported exactly this: catalog information quickly went stale as team names changed and ownership moved around. They concluded that two countermeasures work, and implemented both for Showroom (source):

  • Enforce registration at creation. New services in their monorepo had to register through pipeline governance, so a service could not exist without an entry.
  • Sync on a schedule. Job data synced nightly through APIs, and compliance checks scored how well each live service integrated with platform offerings.

Apply the same logic to your own setup:

  • Make registration a gate, not a request. If creating a service through your template or pipeline produces the catalog entry, nobody has to remember.
  • Pull, do not type. Take ownership from your identity or on-call system, environment from your cloud account structure, and dependencies from traces or topology.
  • Score completeness. A simple percentage of required fields filled per service gives teams a reason to fix gaps.
  • Review ownership when teams reorganize. Reorgs are when entries rot fastest. Treat a team rename as a change that needs a catalog update in the same ticket.

Check documented expectations against production

This is the half of service catalog observability that most catalogs skip. The catalog documents targets: a tier, a latency goal, an availability level. Observability can test them.

For example, if a service is listed as tier 1 with a 99.9% availability target, you can compute actual availability from telemetry and compare. If it is listed as having two dependencies and traces show six, the catalog is incomplete and your blast-radius estimates are wrong.

Documented targets compared with production observations

If your targets come from customer contracts, it helps to see how response times, uptime and clauses are usually written. These IT SLA examples show the kinds of commitments your telemetry will need to prove.

A useful review cadence is quarterly. Pull each tier-1 service, compare the documented target with the measured result and the documented dependencies with the observed ones, then fix whichever side was wrong.

How to evaluate service catalog software

The tool category is broad, so decide your criteria before you look at products. The International Foundation for Information Technology says tool selection should assess functional capabilities, integrations, scalability, usability, governance and total cost of ownership. Total cost includes implementation, integration, training and ongoing operations, not only the subscription.

For an observability-focused catalog, translate those into questions:

  • Integrations. Does it read from your cloud accounts, Kubernetes clusters, CI/CD and observability tools directly, or does it require you to push data into it?
  • Source of truth. Does it replace your existing tools or sit on top of them? Replacement adds migration work and a second place to keep current.
  • Telemetry duplication. Does it ingest a copy of your telemetry, adding cost, or query it where it lives?
  • Governance and access. Are permissions scoped per user and per environment? Is access read-only by default?
  • Freshness. How does it discover changes, and how quickly do they appear?
  • Cost over time. What does the third year cost in engineer hours, not only license fees?

Small teams should weigh the last point heavily. A catalog that needs a dedicated owner to feed it is a tool-sprawl problem with a nicer interface.

Evaluating MCP and AI-agent support

If your team is adopting AI agents for operational work, the catalog becomes more valuable, because an agent needs the same context an engineer does: what this service is, who owns it and what it touches. The Model Context Protocol (MCP) is an open standard for connecting AI assistants to tools and data. It standardizes the connection, not what is exposed through it.

So evaluate three things:

  1. Which tools the MCP server exposes. A server that offers a handful of lookups differs greatly from one that covers cloud, Kubernetes, CI/CD and observability.
  2. Whether access is permission-scoped. An agent should see only what the signed-in user can see.
  3. Whether the workflows you need are supported. Triage, investigation and runbook lookup are different jobs.

Read-only access deserves special attention. An agent that can query but not change production lets you adopt AI-assisted investigation without a new class of change risk.

A unified operational layer instead of another catalog to maintain

Many teams reach for a catalog because their context is scattered across AWS, Kubernetes, observability, CI/CD and security tools. Opsphere approaches this from the other side: it connects to the tools you already use, without requiring you to replace them, and keeps each tool as the source of truth. It does not duplicate your telemetry.

What that means for catalog-style questions:

  • Opsphere unifies operational context across AWS, Kubernetes, observability, CI/CD, security and engineering tools in a single interface.
  • It provides more than 300 read-only operational tools, available to AI agents through MCP, so investigation stays within strict read-only access.
  • Its Cloud Catalog sits in the admin panel alongside tools and tenant control. A product update shows it in use: the Algolia integration supports per-environment Applications via Cloud Catalog.
  • Its platform covers real-time topology mapping, alert correlation and noise reduction, and automated runbook generation.

For teams that want agents to work from real operational context, the MCP operational gateway is the entry point. Platform teams can see how this fits their work on the platform engineering use case page.

A practical rollout in four steps

Whatever tools you choose, the sequence below keeps the effort proportionate.

1. Standardize the attributes

Agree on service.name, an owner attribute, service.version and deployment.environment.name, as described in the OpenTelemetry guidance above. Write down allowed values. Fix names in one pass rather than gradually.

2. Pick the sources that feed the catalog

For each field, decide which system is authoritative: the cloud account for environment, the on-call system for ownership, the pipeline for version, traces for dependencies. If a field has no authoritative source, it will go stale.

3. Gate new services

Make registration part of service creation. Existing services get a one-time backfill, starting with tier 1.

4. Measure usage and accuracy

Track two things. Completeness: what share of production services have all required fields. Use: whether engineers reach for the catalog during incidents, for instance by tracking how often runbook and owner links are opened. Low use is usually a sign of stale or hard-to-find data, so improving how easily services can be found, much like improving discoverability on any content platform, raises both.

A target to aim for: during an incident, an on-call engineer should get owner, tier, dependencies and recent changes for the alerting service in one view, within a minute.

Try it on your own stack

Opsphere publishes its plans on the pricing page: Community is €0 per month, Developer is €19 per month and Team is €500 per month. Enterprise and Custom Solutions are also listed there. Developers can connect a single environment and see how unified context and read-only MCP tools behave before involving the wider team.

Opsphere

If your next step is wiring an AI assistant into your operations, the Claude Code integration shows how it connects.

FAQ

What should a service catalog contain for observability?

At minimum: service name, owner, environment, version, tier, dependencies, and links to the runbook and dashboards. The first four should use the same identifiers as your telemetry, such as OpenTelemetry’s service.name and deployment.environment.name, so the two can be joined automatically.

How is a service catalog different from a CMDB or an IT request catalog?

An IT request catalog lists what employees can order. A configuration management database (CMDB) records assets and their relationships, often for IT operations and audit. A service catalog for observability is organized around running services and their owners, so engineers can use it during incidents. They can overlap, but the engineering catalog needs to update with every deploy.

How do we stop the catalog from going stale?

Require registration when a service is created, and sync data from authoritative systems on a schedule. One engineering team that built its own catalog reported that both measures were needed after entries drifted as teams and ownership changed. Add a completeness score so gaps are visible.

What should we check before connecting an AI agent through MCP?

Confirm which tools the MCP server exposes, whether access follows the signed-in user’s permissions, and whether it supports the workflows you need, such as investigation or runbook lookup. Read-only access limits the risk of letting an agent query production systems.

Opsphere
Discuss Service Catalog Observability
Reach out to discuss how Opsphere’s operational intelligence platform connects cloud and observability context for DevOps and SRE teams.

Sources

This article is provided for general informational purposes only and does not constitute professional, legal, security, or compliance advice. Please evaluate recommendations against your organization’s specific environment and requirements.