
The team in this case study does not exist. It is a composite, drawn up to show a start-stop-continue retrospective in a believable DevOps setting, so treat every detail as illustration only. Think of a platform team of five serving a few dozen application developers. They had just come out of a quarter that felt worse than any individual incident explained, and the engineering manager booked ninety minutes to look back at it properly.
The quarter that went sideways
The team had inherited a patchwork of build pipelines and was halfway through replacing them with a standard template. Along the way they had handled a string of urgent requests from application teams, two awkward outages and one painful week where the on-call rota collapsed because two engineers were ill at once. By the end of the quarter, the template was only partly rolled out, morale was thin, and the application teams had started to describe the platform team as “slow.”
Nobody had been idle. That was the puzzling part. The manager’s instinct was to ask for a plan for next quarter. The senior engineer suggested something smaller: spend an hour on what had happened before deciding anything about what would happen.
How they ran the start-stop-continue session
The format was plain. The manager put the three headings on a shared board. Each person spent ten minutes writing notes alone, one idea per note. Then the group read them out, clustered duplicates and discussed. The manager spoke last on purpose, so the team’s own view would shape the lists rather than echo the manager’s.
Before writing, they pulled up the ticket history for the quarter. The data was blunt: a large share of the closed tickets were small one-off requests, while the template rollout, the work everyone had called the priority, had progressed in thin slivers between interruptions.
What they wrote under “start”
- Start a weekly office hour for application teams, so small questions have a predictable home instead of arriving as interruptions.
- Start protecting two half-days a week for the template rollout, with notifications muted.
- Start leaving a brief written note for whoever takes the pager next.
What they wrote under “stop”
- Stop taking requests through direct messages. Everything goes through the shared queue, even small things.
- Stop treating every request as equally urgent. A quick triage on Monday sorts the queue into now, this week and later.
- Stop letting one engineer be the only person who understands the old build servers.
What they wrote under “continue”
- Continue the blameless review of every outage, because it had produced their best improvements.
- Continue the short daily stand-up, which had kept the team honest about who was stuck.
- Continue documenting each decision in the repository, so new people could follow the reasoning.
The argument that mattered
Not everything went smoothly in the room. One engineer objected to the stop on direct messages: the application teams liked the speed of chat, and cutting it off might look unfriendly. Another pointed out that answering instantly was exactly why the rollout kept stalling. The group argued for fifteen minutes and landed on a compromise. Chat could stay as a way to ask where a ticket stood, but any actual request had to be written into the queue. The compromise was not elegant, yet it kept everybody onside, and it was written on the board as a rule anyone could point to.
That detail matters because retrospectives are not only about producing lists. They are where a team negotiates its own rules, in the open, with the reasons recorded.
What changed in the following weeks
The team did not transform overnight. The first week of office hours was quiet because application teams did not trust it. By the third week, three or four developers turned up regularly, and the number of interrupting messages visibly dropped. The protected half-days did what they were meant to: the template rollout started to move in solid steps, and within another quarter most services had left the old pipelines behind.
The queue triage brought a side effect the team had not predicted. Application teams began writing better requests, because a clear request moved to “now” faster than a vague one. The platform engineers spent less time decoding what people actually wanted.
What the manager learned about the role itself
The manager, who had expected to drive the session, found that stepping back worked better. By speaking last, the manager heard concerns that would otherwise have been talked over, including a quiet worry that the template rollout was being judged by the number of services moved rather than by how reliable they were afterwards. The manager added a line to the continue list about reviewing reliability alongside progress, and promised to say no, on the team’s behalf, to ad hoc asks from outside the queue.
Where the plan wobbled
Honesty requires noting the weak spots. The note for the next pager-holder was dropped within a month, because it felt like paperwork with no visible payoff. At the next retrospective, it appeared on the stop list, replaced by a single line in the team’s chat channel at the end of each shift. And the “bus factor” item about the old build servers was only half addressed: one pairing session happened, a second never did. Both slips appeared in the next review, which is exactly what the format is for.
What the numbers would have shown
It is worth saying what a team in this position should measure, without inventing figures. Count the tickets that arrived by direct message against those that came through the queue. Note how many working hours per week stayed free of interruptions for the rollout. Record how long a request waited between arriving and being triaged. These are small, ordinary counts that any team can pull from its own tools, and they turn “it feels better” into a statement the group can check. The fictional engineers pinned a simple tally to the same board as the three lists, and by the following review the tally told the same story as the mood in the room.
Lessons a practical team can take
- Pull up real data before the session, so the lists reflect what happened rather than what people remember.
- Let the team speak before the manager does.
- Argue about the stop items; that is where the real decisions are made.
- Write down compromises along with the reasons.
- Read last time’s lists at the start of every session.
Why this suits career growth too
The engineers in the story each learned something that no course had taught. The junior member learned how to push back politely on a request. The senior learned that sharing knowledge about the old build servers was part of the job, not a favour. For readers thinking about how those lessons map onto their own progression, this account of moving from junior to senior DevOps engineer offers useful context, and a write-up on how developers can cross over into DevOps roles sketches where such habits lead.
A glance at other fields
Sorting work into three clear buckets is hardly unique to software. A site like BestPilotsNow, an aviation discovery website offering separate sections for people, flight schools, courses, resource pages, a forum and a blog, groups quite different material into labelled areas so a visitor can find what is relevant. A retrospective does the same for a quarter’s worth of tangled experience.
The practical takeaway
Nobody on this platform team found a clever new tool. They looked honestly at a hard quarter, wrote three short lists, argued about the uncomfortable items and committed to a handful of specific changes with names and dates. Some of those changes worked, some wobbled, and the next review caught the difference. For a busy team, that loop of look back, decide, act and look back again is about as practical as improvement gets.