
Release processes grow by accretion. Someone adds a manual approval after a bad week, someone else adds a checklist item, a third person adds a spreadsheet nobody remembers the reason for. Each addition made sense once. Together they make shipping slower than it needs to be, and the people doing the work tend to stop noticing. This guide offers a method for finding the small fixes: ask what would make the release easier, gather simple evidence, change one thing and compare.
The method has seven steps and needs no special tooling. A shared document and a stopwatch (or your phone’s timer) are enough. It works for a team of three or a team of thirty.
Step 1: choose one stage of the release
Resist the temptation to examine the entire pipeline. Pick one stage that people grumble about: preparing the release notes, waiting for approval, promoting a build to staging, verifying after deployment. A narrow scope produces a narrow, fixable list of problems. Write the stage name at the top of your document.
Step 2: record a baseline you can compare against later
Before asking anyone anything, gather a rough measure of the stage as it stands. Time it on the next two or three releases. Count the number of manual actions. Note how many times someone had to ask a colleague a question. These figures need not be precise; they only need to be gathered the same way afterwards.
Evidence matters because opinions about friction vary. One engineer thinks the approval step is slow, another thinks it is fine. A short timing log settles the matter and tells you which complaints are worth addressing first.
Step 3: ask the people who actually perform the stage
Bring together the two or three engineers who perform this step most often and put one question to them: what would make this easier? Keep the tone casual and the session short. Ask each person separately if you can, so that quieter voices are not drowned out.
Useful follow-ups include: “What do you do here that you suspect is unnecessary?” and “What do you check every time out of habit?” Record the answers in their own words, without trimming them into tidy phrases. The rough wording often carries the clue.
Step 4: sort the answers into three piles
- Remove: things that serve no remaining purpose, such as a field in a form that nobody reads.
- Simplify: things that serve a purpose but take more effort than needed, such as copying version numbers by hand.
- Support: things that are necessary and awkward, such as a manual check that needs a clearer checklist.
This sorting keeps you honest. It prevents the common mistake of dropping a useful safeguard simply because it is irritating. The aim is to take out only the effort that adds nothing.
Step 5: pick one change and write down its prediction
Choose the change that gives the most relief for the least work. Then write a one-sentence prediction: “If we generate the release notes from merged pull request titles, preparation should take about half as long.” A written prediction keeps you from rationalising the result afterwards. It also gives the team a clear target.
Keep the change reversible where possible. If it fails, you want to be able to return to the previous method within minutes, not days.
Step 6: apply the change to two or three releases
One release proves nothing, because every release has its own quirks. Run the new method on at least two or three and time it the same way you did in step two. Note any new problems that appear, since a fix at one point sometimes creates friction at another. For example, shortening a review step might expose a gap in testing that the review used to hide.
Step 7: compare, decide and share
Set the new numbers beside the baseline. Did the prediction hold? If yes, keep the change and write it into the release documentation. If it half worked, adjust it. If it did not help, revert and say so openly; a failed experiment that is shared saves another team from repeating it.
Finally, tell the engineers you interviewed what happened. Nothing encourages honest answers next time like seeing that earlier answers produced results.
A compact example of the method
Imagine a team where promoting a build to a staging environment took around forty minutes of hand-held attention. The baseline log showed that most of it was waiting for a colleague to paste an environment file into a chat. In the interviews, three people independently said they wished the file could be fetched automatically from a protected store. The change was to let the promotion script read the settings itself. The prediction: promotion needs about ten minutes of attention. Over three releases the average came in close to that, and the team kept the change. Total effort: one afternoon of scripting.
What the evidence might look like
Try to imagine the finished document before you begin. A good one is short: a stage name, three baseline timings, a bullet list of answers grouped into remove, simplify and support, one chosen change with its prediction, and three follow-up timings. That is perhaps a page. Resist the urge to add charts. If the numbers do not tell the story in a simple table, the change was probably too small to matter or the measurements too noisy to trust.
Noise is worth a comment. Release durations swing for reasons unrelated to your change: a flaky test, a colleague on leave, an unusually large batch of commits. This is why the method asks for several releases rather than one, and why it asks you to record context beside each timing. A note saying “large release, two reviewers away” explains an outlier far better than a footnote added weeks later.
Finally, keep the artefacts. When someone proposes the same fix next year, the page tells you what was tried, what it predicted and what actually happened. That memory is cheap to keep and surprisingly valuable.
Where this fits in a career
The skill of measuring friction, asking for input and testing a small change is one that engineers carry between roles. If you are mapping your own progress, a walk through the steps from entry-level DevOps work to senior responsibility shows how ownership of process tends to widen with experience. Likewise, a skills-and-projects roadmap for DevOps engineers is a handy reference for deciding which habits to build next.
A note on where else the question applies
Nothing here is specific to software. Any service that tries to be useful to newcomers can ask the same thing. Urology Hospitals illustrates this: it describes itself as an informational resource on urology that includes a hospital and doctor directory with no ranking; the site notes that it is not offering medical services. Whatever the subject, a resource like this improves most when it asks its readers what would make finding things easier, then changes one thing and watches what happens.
Common mistakes to avoid
- Changing several things at once, which makes it impossible to tell which one helped.
- Skipping the baseline and then relying on memory for the comparison.
- Asking only managers, who rarely perform the stage themselves.
- Removing a safeguard because it is annoying, without checking why it was added.
- Declaring success after a single release.
Next steps
Pick the stage this week, time it on your next release and book fifteen minutes with the people who run it. By the time the following release is done you will have a baseline, a list of answers and a small change ready to try. Repeat the cycle each quarter on a different stage, and the cumulative effect on your team’s release experience will be considerable.