Every software organization has its own unique architecture and workflows. Beyond services and APIs, teams rely on internal libraries, CI/CD jobs, data pipelines, AI agents, and more to keep systems running smoothly. But as architectures grow more complex and interconnected, it can become difficult to keep track of all the structural dependencies and interactions in one place.

With custom entity types in Datadog Software Catalog, platform teams can now define and manage any component—whether it’s a pipeline, a library, or an AI agent—so that their catalog mirrors the reality of their architecture while staying simple and discoverable for developers.

In this post, we’ll look at how teams can create custom entities to help them visualize dependencies and ownership of any library or tool, troubleshoot issues faster, and apply best practices at scale.

Visualize dependencies and ownership

Custom entity types make hidden dependencies visible. To create and manage custom entity types, go to Manage Entity Types in Software Catalog and select Create New Entry to define a custom entity and assign ownership.

Additionally, you can choose to automate entity creation with GitHub, the Datadog API, or Terraform, such as for declaring a library with links, tags, and owning teams:

  apiVersion: v3
  kind: library
  metadata:
    name: my-library
    displayName: My Library
    tags:
      - tag:value
    links:
      - name: shopping-cart runbook
        type: runbook
        url: https://runbook/shopping-cart
      - name: shopping-cart architecture
        provider: gdoc
        url: https://google.drive/shopping-cart-architecture
        type: doc
      - name: shopping-cart Wiki
        provider: wiki
        url: https://wiki/shopping-cart
        type: doc
      - name: shopping-cart source code
        provider: github
        url: http://github/shopping-cart
        type: repo
    contacts:
      - name: Support Email
        type: email
        contact: team@shopping.com
      - name: Support Slack
        type: slack
        contact: https://www.slack.com/archives/shopping-cart
    owner: myteam
    additionalOwners:
      - name: opsTeam
        type: operator

Whether you’re tracking an AI agent that relies on a downstream service or a shared library used by multiple teams, Software Catalog gives you a single place to see relationships across your ecosystem. This unified view helps engineers and platform teams better understand how components interact, reducing the chance of missed connections during critical workflows.

Internal libraries and shared tools often lack explicit ownership, creating confusion when issues arise. With custom entity types, you can assign an owner to every component instead of only deployed services. This ensures accountability across your entire architecture, so developers always know who to contact when something breaks or when a question arises.

Apply best practices at scale

Different types of components require different standards, which is why custom entities allow you to apply targeted scorecard rules across your architecture. For example, you can require version updates for specific libraries or monitor the operational health of certain services. The rule in the screenshot below ensures that specific libraries and their dependencies have no unresolved critical vulnerabilities and exploits (CVEs).

A failure means one or more dependencies contains CVEs, while a pass indicates compliance with the current security standards. These rules for custom entities enable consistent governance while respecting the unique needs of each component type.

Troubleshoot unique issues faster

Unmonitored or undocumented dependencies can delay incident response. By representing components like pipelines and CI/CD jobs as first-class entities in Software Catalog, engineers can understand upstream and downstream impacts, spot potential failure points, and quickly find the teams, docs, and runbooks for any component to resolve issues faster.

For example, let’s say a team ships an internal library update and a downstream service begins throwing errors in production. The downstream team investigating the issue opens Software Catalog and immediately sees that their service depends on the newly updated library because it has been registered as a custom entity. From the same view, they can pivot to correlated logs to confirm that the errors started right after the new release. Rather than spending hours tracking down the right contacts, they can page the owning team directly from the catalog entry.

Model your architecture in your way

With custom entity types, Datadog Software Catalog adapts to your organization. By extending the catalog to cover every component of your architecture, you can drive ownership, uncover dependencies, troubleshoot faster, and enforce best practices at scale.

You can check out the documentation on custom entity types to learn more. If you’re new to Datadog, sign up for a 14-day free trial.