Living Software Catalog and Version Drift
A catalog that stays honest — systems, components, owners and dependencies, with per-environment version drift on one grid.
These images are illustrations of the concept, not screenshots of the actual product.
Overview
Most software catalogs decay within a quarter. Somebody fills in a spreadsheet of services, ownership changes, a library is retired, two versions ship, and the catalog quietly becomes a record of what was true once. Living Software Catalog and Version Drift is the VibeControls concept for a catalog that stays close to reality because it lives where the work happens — beside the agents, projects and sessions that touch the software every day — and because it shows deployed versions rather than intentions.
The concept moves from wide to narrow across four screens. The first is a landing view of catalogs: a grid of cards for the organized libraries a team keeps, each with a visibility badge for public, internal or private, a one-line description, counts of the components and projects it holds, and classification chips. An explainer strip defines a catalog as an organized library of services, APIs, jobs and the systems they belong to, and a search field with a visibility filter narrows a count shown as a showing-of-total line.
The second screen drops into the components themselves — a filterable table where every row is one building block of the software. Columns carry the component and its type, an owner with an avatar, a lifecycle badge running from experimental through active to deprecated, a tier badge, the current version and a health score drawn as a small bar with a numeric value. Type and lifecycle filters sit above, so finding every deprecated API takes two choices rather than a spreadsheet hunt.
The third screen is a single component in full: a header carrying its description, its owner and badges for kind, lifecycle and tier; summary cards for type, lifecycle, version, catalog membership and tags; and tabs spanning overview, catalogs, a scorecard, docs, dependencies, its originating template and settings. The dependencies tab draws the graph on a canvas, with upstream packages showing their versions and a relationship badge distinguishing runtime from peer, edges converging on the service itself, and zoom controls in the corner.
The fourth screen answers the question the other three set up: where is each of these actually running? An environment topology table crosses components against development, staging and production, showing the deployed version in every cell with a colored status dot, an add placeholder where nothing has been recorded, and a legend separating in-sync from drifting and from a stale production. Promote and record-deployment actions sit in the header, so the grid is a place to act rather than only to read — which is what turns the catalog from documentation into a surface a platform team can run a fleet from.
What this concept shows
- A catalogs landing grid with visibility badges for public, internal and private libraries
- Per-catalog counts of components and linked projects, plus classification chips such as domain and tier
- A components table with owner, lifecycle, tier, current version and a numeric health score, narrowed by type and lifecycle filters
- A component detail header with summary cards for type, lifecycle, version, catalog membership and tags
- A dependency graph that labels upstream packages with their versions and a runtime or peer relationship
- Tabs that keep a scorecard, docs and the originating template attached to the component itself
- An environment topology grid showing deployed versions across development, staging and production with a drift legend
- Promote-version and record-deployment actions placed directly on the topology view
How it works
- Start from the catalogs landing to see how the organization's software is grouped and who can see each library.
- Open a catalog and filter its components by type or lifecycle to find the ones you care about.
- Scan the table for owner, tier, version and health score to spot anything unowned, deprecated or degraded.
- Open a component to read its scorecard and docs and to trace its dependency graph, version by version.
- Switch to the environment topology grid to compare what is deployed in development, staging and production.
- Use the legend to separate components in sync from those drifting and those with a stale production version.
- Promote a version or record a deployment from the same view so the grid reflects the change immediately.
Who it's for
- Platform engineers running an internal developer portal
- Service owners tracking lifecycle and dependency risk
- Engineering leads who need one view of ownership across a portfolio
- Release managers comparing versions across environments
- New joiners trying to understand what the organization runs
Illustrations
4 illustrations of this concept. Select one to view it full size.
Catalogs Landing
This illustration shows the top level of the catalog area. A heading gives the number of catalogs, next to actions for creating one and an overflow menu, and an explainer strip defines a catalog as a team's organized library of software components — services, APIs, jobs and the systems they belong to. A search field and a visibility filter sit above a showing-of-total line. The body is a three-column grid of catalog cards, each with an icon, a name, a badge marking it public, internal or private, a one-line summary, and a footer carrying a component count, a linked-project count and small classification chips such as a domain or tier marker. Names and figures shown are sample data standing in for a real organization's libraries.
Components Table with Owners and Health
This illustration shows the components list, headed by a count of how many are in the catalog and a create action. An explainer strip describes components as the individual building blocks of the software — each service, frontend, library or API — tracked with its owner, dependencies and lifecycle. Below it, a search field sits beside filters for type and lifecycle, over a showing-of-total line. The table gives each component an icon and a type sub-label, an owner shown as an avatar with a name, a lifecycle badge reading active, experimental or deprecated, a tier badge in a gold, silver and bronze scheme, a version string and a health column drawn as a small progress bar with a numeric score and a check mark. All rows are sample data.
Component Detail and Dependency Graph
This illustration shows a single component opened from the catalog. A back link sits above a header carrying the service name, a one-line description with its owner, a share action, and badges for kind, lifecycle and tier. Beneath the header, summary cards give the type, the lifecycle with a small progress indicator, the current version, the number of catalogs the component belongs to, and a set of tag chips. A tab row spans overview, catalogs, scorecard, docs, dependencies with a count, the originating template and settings, with dependencies selected. The canvas below draws five upstream packages as nodes, most labeled with a version and each with a badge marking a runtime or peer relationship, with curved edges converging on the service node. Zoom and fit controls sit in the corner. All names and versions are sample data.
Environment Topology and Version Drift
This illustration shows the environment topology view, described in its subtitle as the current deployed version of every component across development, staging and production. Header actions offer promoting a version and recording a deployment. The table lists components with a type sub-label down the left and one column per environment; each cell pairs a colored status dot with a version string, or shows a dash-and-add placeholder where no deployment has been recorded for that environment. The sample rows show several shapes at once — a service running ahead in development, a frontend trailing in production, a service and an infrastructure module with no production entry, a machine-learning pipeline service whose production cell is flagged red, and a mobile app with no staging record. A legend at the foot separates in sync, behind or drifting, and stale production.
Topics
- software catalog
- internal developer portal
- service ownership and lifecycle
- component dependency graph
- version drift across environments
- deployment topology grid
- service tier and health score
- catalog visibility and tags
- promote version between environments
- developer portal component detail
Related concepts

Golden-Path Templates and Scaffolding
Pick a team-approved blueprint, fill in a few variables and get a new component with its build, CI, ops deck and docs already wired.
2 illustrations
GitOps, Living Docs and Quality Scorecards
See a project's repository activity, its compiled documentation and a weighted quality score side by side, inside the vibe itself.
3 illustrations
Plugin Marketplace and Fleet Rollout
Browse plugins that extend every agent, check prerequisites and versions, then roll one out across chosen machines in a single step.
4 illustrations
Fleet Health and Live Logs
See which agents, sessions, vibes and targets are healthy, then stream a struggling agent's logs to find out why.
2 illustrations