Teams about to add a new CI/CD capability, whether a scanner, a deployment tool or another runner pool, often skip a step that costs an afternoon and saves a quarter: a CI/CD pipeline inventory. The checklist below is meant to be run as an actual working session with a shared document and a timer. Each item ends in a recorded fact, so the output can be read cold by a reviewer arriving next month.
The principle is simple. A capability you believe is missing is frequently present in a partial or dormant form, and the only way to find out is to look in a fixed list of places. Treat the checklist as evidence gathering, and resist the urge to decide anything until all sections are complete.
Preparation: scope and roles
- Choose one product or service as the scope. A whole company is too broad for a single session.
- Name a scribe, a person who knows the build system, and a person who knows deployments.
- Agree on the recording format: asset, owner, purpose, last used, notes. Keep it identical across sections.
- Set a timer of two hours. If a section overruns, note it as incomplete rather than extending the meeting.
Section 1: repositories and the pipeline definitions inside them
- List every repository involved in building and releasing the product, including infrastructure and configuration repositories.
- For each, note the location of its pipeline definition and the date of its last successful run.
- Flag pipelines that have not run for ninety days. They are either obsolete or run only on request, and both facts matter.
- Search for scheduled pipelines. Nightly or weekly jobs are the most commonly forgotten items.
Section 2: runners, agents and build capacity
- List every machine or pool that executes builds: shared, self-hosted, local, and anything on someone’s desk.
- Record who maintains each, what it is installed with, and how it is patched.
- Compare utilisation against capacity using whatever figures the system reports. If you have none, record that as a finding.
- Check whether an idle pool could take on the workload you were about to buy more capacity for.
Section 3: checks already in the path
This is where most hidden capability lives. Many pipelines already contain linting, unit tests, dependency checks or image scans that were enabled once and never mentioned again. Read the definitions rather than trusting memory.
- Extract every named step and classify it: build, test, security, packaging, deploy, notify.
- For each security or quality step, record whether failures block a release or are only reported.
- Note which reports are written to artefact storage and whether anybody reads them.
- Mark any step that is commented out, set to allow failure, or skipped by a condition that is never true.
A broad overview of what a modern delivery platform offers out of the box, such as the one in this summary of platform features for faster software delivery, is a useful cross-check at this stage. Compare its list with your pipeline definitions and see how many features your team has enabled without noticing.
Section 4: secrets, access and service accounts
- List every credential used by pipelines, with its owner and creation date.
- Identify service accounts with no recent activity.
- Confirm which stored variables are still referenced by a live pipeline.
- Record anything stored outside the designated secret store.
Section 5: environments and deployment targets
- List every environment a release can reach, including temporary ones that never got removed.
- Note the deployment method for each: manual, scripted, tool-driven.
- Check cloud billing for environments that exist but do not appear in your list.
- Record who may deploy where.
Section 6: observability and notifications
- List the dashboards, alerts and logs that cover the pipeline and the product it ships.
- Record where failure notifications go and whether the recipients are still active.
- Check whether deployment events are recorded anywhere that can be queried later.
Section 7: subscriptions and licences
- Read the billing lines for anything touching build, test, scanning and deployment.
- Match each to a pipeline step or a named user. Items that match nothing go in the review column.
- Record renewal dates, since these fix the deadline for any retirement decision.
Worked mini-example
Suppose the proposal on the table is a new dependency scanner. Section 3 turns up an existing scanning step that runs on every merge but is configured to allow failure and write its report into artefact storage nobody opens. Section 6 shows that notifications for that job go to a retired mailbox. The shortfall is therefore not a missing scanner; it is a report with no reader and a failure that blocks nothing. The remedy is to make the step blocking for high-severity findings, route its output to the team channel and name an owner. A purchase decision, if one is still needed, can now be compared against a working baseline instead of an imagined empty slot.
Analysis: turn the facts into a gap list
When the sections are complete, build a three-way table. Column one lists the capability you wanted. Column two names the existing assets that touch it. Column three states the specific shortfall. If column two is full of items, your next task is configuration or adoption, not procurement. If it is empty, the shortfall is a genuine gap and column three becomes the requirement for whatever you evaluate or build.
The same logic is applied in wider platform thinking; the discussion in a longer look at running platforms with Kubernetes, DevSecOps and automation at scale is a reasonable follow-up once you have your own data in hand.
Reporting the result
Circulate the document within a day while memories are fresh. Add a short summary at the top with four numbers: assets found, assets with no owner, assets unused for ninety days, and genuine gaps. Four numbers are easier to discuss than forty rows, and they give the next review a baseline of the inventory itself.
For readers who like to see the idea reflected in other operations settings, the site RobotsOps, which publishes blog posts on robotics operations, offers a change of scenery, and its existence is a reminder that careful listing of equipment is routine wherever machines are run.
Follow-up cadence
- Assign owners to every unowned item within one week.
- Retire or archive confirmed dead assets before their renewal dates.
- Re-run the checklist before any significant tooling proposal.
- Store the document beside the architecture notes so that it is found when needed.
Run this way, the audit is a small, repeatable routine rather than a project. Teams that adopt it usually notice that proposals become more specific: they cite the section and row they extend, and they state what the existing pipeline already does. That discipline alone improves the quality of decisions about what to add next.









