Support work has a rhythm of its own. Tickets arrive, alerts fire, customers ask questions, and the day ends with a queue that looks much like the one it started with. In that churn, it is hard to notice which habits help and which quietly drain the team. The start-stop-continue retrospective is a simple tool for noticing. This primer explains it for beginners in DevOps support and managed services, defines the vocabulary you will hear, and shows how to apply it to an ordinary stretch of ticket work.
The basic idea in four sentences
After a defined period, such as a week of on-call or a month of managed-service work, the team looks back. Members write what the team should start doing, stop doing and continue doing. The group trims the list to a few concrete items. Those items are checked at the next review. Everything else in this article elaborates on those four sentences.
Mini-glossary for newcomers
Support teams use a lot of shorthand. These are the terms most useful when reading about retrospectives and running one.
- Retrospective: a structured look back at a period of work, held to improve how the team operates.
- Ticket: a recorded request or incident, with an owner and a status.
- On-call: the rota under which one person at a time is responsible for responding to urgent alerts.
- Incident: a surprise that slows, breaks or switches off something customers rely on.
- Runbook: step-by-step instructions kept for a task or failure that has happened before.
- Escalation: handing a problem upward, to a colleague better placed to solve it or to decide.
- SLA (service level agreement): the response or resolution commitment made to a customer.
- Toil: dull, repeated hands-on chores that leave nothing lasting behind and are candidates for automation.
- Blameless review: an examination of what happened that focuses on process and conditions rather than on individuals.
- Action item: a specific, owned task that comes out of a review.
Keep this list handy during your first few sessions. When a colleague says an item is “toil,” for example, they mean it belongs on the stop list or is a candidate for automation.
What each start-stop-continue list means in a support setting
Start
A start item is a practice the team does not do yet but expects to be worthwhile. In support work, good starts are usually small. Examples include tagging each ticket with a root-cause category, adding a line to the runbook every time a new fix is discovered, or holding a ten-minute weekly review of the tickets that bounced between teams.
Stop
A stop item is a practice that costs more than it returns. Support teams often find stops in places where work is duplicated or where effort goes unseen: answering the same question by hand every week, chasing customers for information that the form could have collected, or keeping dashboards no one looks at.
Continue
A continue item is a practice that is working and needs protecting. It might be the habit of confirming resolution with the customer before closing a ticket, or the weekly rotation of the person who triages the queue. Naming it ensures it survives a busy period.
A worked example, with evidence
The following is an invented small managed-services team, described to show how evidence shapes the lists. Over a month, the team handled a steady flow of tickets. At the review, they looked at the ticket data and noticed that a modest set of recurring request types accounted for most of the queue, and that these had been solved by hand each time. They also noticed that reopened tickets tended to cluster around cases where the customer had not been told what the fix was.
Their lists:
- Start: write a runbook entry for each of the top recurring request types, and begin including a plain-language summary of the fix when closing a ticket.
- Stop: stop resolving recurring requests from memory, because the knowledge sits in one person’s head.
- Continue: continue the weekly triage rotation, since it spread familiarity with the queue across the team.
The next month’s data showed fewer reopened tickets, and new team members resolved recurring requests without asking for help. Those were modest results, but they were visible and they traced back to three lines on a page.
How to run your first session
- Pick the period. A week, a month or a particular incident response.
- Gather simple evidence. Ticket counts, reopen counts, times to first response, a list of escalations.
- Write silently for ten minutes. One idea per note, under the three headings.
- Cluster and discuss. Merge duplicates and talk through disagreements.
- Select two or three items per list. Each needs an owner and a date.
- Record the lists. Place them in the team wiki and link them from the runbook index.
- Review next time. Open with last session’s lists and mark each item.
Where beginners go wrong
Three mistakes are common. First, treating the retrospective as a venting session; the rule that each complaint must become an action prevents this. Second, writing items that are not testable, such as “communicate better,” when “send a status message every four hours during an incident” can be checked. Third, ignoring the continue list, which means the team loses habits that nobody realised were load-bearing.
Reading that supports the practice
The retrospective sits inside a larger understanding of how DevOps teams work. For the principles behind the day-to-day habits, a short article on DevOps principles for delivering software well is a sound reference. Still working out where support sits among other jobs? A rundown of common DevOps job titles and the routes between them can help you place your own work.
A parallel from another sector
Organising information into clear, labelled areas helps any audience, which is why a directory-style aviation website like BestPilotsNow presents itself as an aviation discovery website, with menu areas for finding pilots, schools and courses and for reading, chatting and browsing articles. The lesson for a support team is a modest one: if your runbooks, tickets and lessons-learned notes live in a single heap, nobody will find them. Give each its own labelled place, and review the labels at the retrospective.
Keeping the sessions fresh over time
After a few rounds, teams sometimes find that the lists start to repeat. That is a signal, not a failure. Try changing the lens: review only the tickets that were escalated, or only the night-time alerts, or only the work done for one customer. Narrowing the view surfaces specifics that a general review smooths over. Rotating the facilitator also helps, since each person asks slightly different questions and notices different things.
Another useful variation is a “stop” session on its own, held when the team feels overloaded. Each person lists the three chores they would most like to be rid of, and the group picks the one that is both annoying and achievable. Small wins like that build the trust that makes a larger retrospective productive.
Measuring progress without overdoing it
It is tempting to build a scorecard around the retrospective. Resist the urge. For each action item, pick one observable sign of progress, such as the number of runbook entries added or the count of reopened tickets, and look at it at the next session. A handful of simple signs is enough. The aim is to confirm that actions happened and to see whether the pattern moved, not to produce a report.
Summary
The start-stop-continue retrospective gives a support team a regular, low-cost chance to sort its recent work into three honest lists and to turn a few of them into action. A beginner needs only a defined period, some simple evidence, a few quiet minutes of writing and the discipline to read the lists again next time. The glossary above covers the words you will meet, and the example shows what a first set of lists can look like. Start small, record what you decide and let the next review tell you whether it worked.