Most teams can describe the pipeline they would build today. Fewer can describe the one that has been running since the project began. It still builds, it still deploys, and nobody wants to touch it. That is the pipeline most likely to fail at a bad moment. This how-to walks through refreshing an existing delivery pipeline step by step, without a rewrite and without halting releases. The plan is deliberately plain: look, list, fix, remove, and record.
Step 1: Pick one pipeline and freeze the scope
Choose a single pipeline, preferably one that matters to customers. Resist the urge to review everything at once. Write one sentence describing what it should do, for example “build the service, run the tests and deploy to staging, then to production after approval”. That sentence is your reference for deciding what belongs and what does not.
Step 2: Read it end to end, as a stranger
Open the pipeline definition and read every stage from top to bottom. Note anything you cannot explain. Pay attention to hard-coded versions, commented-out blocks, temporary workarounds with names like “fix” or “hack”, and variables nobody recognises. Keep a plain list. A pipeline that has grown for years almost always holds a few stages whose original reason has been forgotten.
Step 3: Check the things that expire
Make a short inventory of every credential, certificate and token the pipeline uses. For each one record where it lives, who created it, when it ends and who renews it. Include the quiet ones such as deploy keys, registry logins and signing keys. If a person who left the company owns any of them, move ownership to a team account first. The risk-focused piece on managing risk in reliable and secure delivery gives useful context on why unmanaged secrets are such a common cause of outages.
Step 4: Update the dependencies you can safely update
List the base images, build tools, runners and plugins in use, and compare each version with what the vendor currently supports. Update one thing at a time, in a branch, and run the whole pipeline after each change. A single combined upgrade makes failures impossible to trace. Where an update would be large or risky, write it down as a planned task rather than forcing it into this exercise.
Keep a log as you go, even a crude one. A line saying what you changed, why, and how to undo it turns a risky afternoon into a reversible experiment, and colleagues who wonder where your afternoon went can read the answer for themselves.
Step 5: Make the tests prove something
Look at the test stage. Count the ones that are switched off, the ones that have stayed green for as long as anyone recalls, and the ones that exercise features long since deleted. Remove tests for deleted features, repair or quarantine the flaky ones with an owner and a deadline, and confirm that at least one test can fail for the right reason by breaking the code on purpose in a scratch branch. A green pipeline only means something if red is still possible.
Step 6: Walk the links and references
Pipelines point outwards constantly. Notifications link to dashboards, failure messages link to runbooks, readmes link to design notes, and configuration comments link to vendor documentation. Gather these into one list and check them. A platform like URLSnow manages sets of links and its automated nightly checks record whether each one still responds, which saves you from clicking through dozens of addresses by hand. Replace anything that has gone dead, and update any message template that points somewhere obsolete.
Step 7: Remove what nobody uses
Now take the list from step two and decide on each questionable stage. If you can show that nothing consumes its output, disable it first and wait one release cycle. If nobody complains, delete it. Do the same for unused environments, old build artefacts and abandoned scheduled jobs. Retirement is part of maintenance, not a separate project.
If your organisation has a change window or an approval process, use it. Pipeline edits are production changes in disguise, and following the normal route keeps the cleanup from becoming a surprise for anyone.
Step 8: Tell the people who depend on it
Changes to a shared pipeline affect other people. Post a short note describing what you changed, what you removed and who to ask if something looks wrong. Cultural resistance is often what makes old pipelines stay old, because people fear being blamed for a change. The discussion of managing cultural change in a DevOps transition offers sound advice on bringing colleagues along, and the same principles apply to a quiet pipeline cleanup.
Step 9: Record what you learned
Update the pipeline’s readme with the date of the review, the changes made and the open tasks. Use terms the whole team knows; the beginner glossary of common DevOps terms is a good reference if newcomers will be reading your notes. Add the next review date to the team calendar, because a refresh that is never repeated becomes the next stale pipeline.
One more habit is worth adopting: whenever an incident touches the pipeline, add a line to the same readme. Over time the file becomes a short history of what breaks, which is the best guide to what deserves your attention at the next review.
Step 10: Set a rhythm
You do not need a heavy process. A short review of one pipeline per sprint, rotating through the estate, keeps every pipeline looked at a few times a year. Treat the findings as normal work items. If a review finds nothing, that is a pleasant result and the time spent was still worthwhile.
What to expect
The first refresh is usually the longest, because it has to clear years of sediment. Expect to find at least one credential close to expiry, one stage that does nothing, and one link that leads nowhere. After that, each review is quicker, and the pipeline becomes something the team can reason about. That clarity pays off when you launch your next service, since you can copy a pipeline you trust instead of copying one you hope is fine.
Start today with step one. Pick the pipeline that scares you least, set a time limit of half a day, and see how much you can repair. Small, regular upkeep is much cheaper than a rescue after a failed release, and you will feel the difference the next time a deadline arrives.









