The Whiteboard Sketch That Saved a Release Pipeline: A Team Story

Rajesh Kumar

Rajesh Kumar is a leading expert in DevOps, SRE, DevSecOps, and MLOps, providing comprehensive services through his platform, www.rajeshkumar.xyz. With a proven track record in consulting, training, freelancing, and enterprise support, he empowers organizations to adopt modern operational practices and achieve scalable, secure, and efficient IT infrastructures. Rajesh is renowned for his ability to deliver tailored solutions and hands-on expertise across these critical domains.

What follows is fiction, stitched together from episodes any delivery team might recognise. No real company is involved and nobody in it has a name, because the point is the pattern. A platform group of six engineers, two testers and a product owner had been asked to rebuild their release pipeline for a customer-facing web service. Their first instinct was the usual one: open the editor and start writing automation.

Monday: the plan to start coding

The team lead called a short meeting and proposed a schedule. Two engineers would script the build stage, two would handle deployment, and one would wire up notifications. Everyone nodded. The plan was clear, confident and entirely made of verbs. Nobody had drawn a single box.

The quiet tester at the end of the table asked a small question: “Does anyone know where the database migration runs?” Four people gave four different answers. Instead of arguing, the lead picked up a marker and said, “Let’s draw it. Ten minutes. If it looks silly, we start coding.”

Monday, twenty minutes later: the sketch

The first drawing was ugly. A box labelled “commit” on the left, “live site” on the right, and a muddle of arrows in between. As each engineer added their piece, contradictions appeared. The build box had two arrows leaving it, because one group assumed artefacts were stored centrally while another expected each environment to rebuild them. The migration step floated unattached, with a note in red marker: “who owns this?”

Then the product owner, who had barely spoken, pointed at the right-hand side. “Where do we pause if something looks wrong?” There was no such box. The team had designed a pipeline that could only go forward. Two more minutes of drawing added a manual approval gate and a rollback arrow, and the team felt the mood shift. A conversation that might have taken three sprints had happened in a coffee break.

Tuesday: the second sketch, drawn from memory

The next morning the lead did something shrewd: she asked each person to redraw the pipeline from memory on separate sheets, without looking at the board. Five of the eight drawings agreed. Three differed in the same place, around the testing stage. That disagreement became the agenda for the day, and the team discovered that two testers expected automated checks to run before deployment to the staging area, while the engineers had planned them afterwards.

Here the cost of changing minds was a few lines on paper. Had it surfaced after the scripts were written, it would have meant reworking stages already declared complete.

Wednesday: choosing what not to build

Looking at the sketch, one engineer noticed that a lavish notification system, the thing the team had been most excited about, sat on the very edge of the picture and touched almost nothing. They struck it from the first version and pencilled it into a “later” corner. This is a habit worth stealing: a sketch makes it visible when your favourite feature is decoration.

The team also noticed that culture, not code, was their biggest risk. Ownership of the migration step had been unclear because two groups each assumed the other held it. If this sounds familiar, the hands-on advice about managing cultural change around DevOps is the natural next reading, because a diagram can expose unclear ownership but only conversation can settle it.

Thursday: risk, drawn in red

Before writing anything, the group coloured the sketch. Red marked places where a failure would reach customers, amber marked internal inconvenience, and green marked everything else. There were only three red spots: the migration step, the switch that sends traffic to the new version, and the secrets handling. Everyone agreed those three would receive tests first and reviews twice. For a wider view of why this thinking matters, a practical guide to reliable and secure delivery through risk management lays out the reasoning behind choosing where to be careful.

Friday: finally, some code

The build began on the Friday, and it went quickly. Each engineer could point at a box on the wall and say “this is mine.” Nobody wondered what to do next, because the next box was visibly unclaimed. The team wrote the red-marked pieces first, tested them in isolation, and only then connected the rest.

When the first end-to-end run happened the following week it failed, as first runs do, but it failed in a place the sketch had flagged amber, and the repair took an hour. The team did not feel clever; they felt calm. Calm turned out to be the real deliverable.

A side note the team picked up on the way

While hunting for a model of orderly guidance, one of the testers mentioned Osnivo, an independent site that sorts consumer-device help into families, then into ownership stages, and keeps a reader forum running. The team had no use for gadget guides, but a look at the Osnivo website sparked an idea: give the new pipeline its own staged guide for newcomers. They added it to the “later” corner.

The retrospective, a fortnight later

Two weeks after launch, the group held a short review and, almost by habit, redrew the pipeline one more time. Only two boxes had moved. The testers pointed out, with some satisfaction, that the sketch from the first Monday had predicted about nine tenths of what existed. The differences were instructive: a caching step added for speed, and a second approval gate the product owner requested after a close call. The team pinned the old and new drawings side by side, and new colleagues were later handed both on their first morning, with a single instruction: find the three differences and explain why they exist.

What the story teaches

  • Drawing exposes contradictions faster than talking. Four answers to one question became visible on a board in minutes.
  • Redrawing from memory tests shared understanding. Differences are a to-do list.
  • Sketches show what to leave out. The edge of the picture is where lavish features go to be questioned.
  • Colour tells you where to be careful. Three red spots beat thirty equally weighted tasks.
  • Calm is a result. Teams that sketch first tend to argue before building rather than during.

The story is invented, but you can run it on any Monday you like. Find a marker, gather the people who will touch the pipeline, and give yourselves ten minutes. If it looks silly, go ahead and start coding. It rarely will.

Leave a Reply