Skip to content

From Video Library to Build Week: A Hands-On Onboarding Story

Published November 6, 2026 by Beena Yadav

Hands-on onboarding for DevOps engineers is often discussed in principle and rarely examined in detail. The case below follows a fictional platform team through a change from video-led onboarding to a practice-first, in-person approach. The team, the company and the people are invented, but the dynamics are drawn from patterns that are widely reported in engineering organisations. The aim is to look analytically at what changed, why it seemed to work, and what remained difficult, rather than to present a tidy success story.

The starting point

The team, which we will call Lighthouse, ran the shared delivery platform for a mid-sized software company: build pipelines, container hosting, secrets handling and the observability stack. New engineers joined every few months, some from operations backgrounds, some from development, a few straight from training programmes.

Onboarding had been designed for efficiency. Each newcomer received a curated library of recorded walkthroughs covering the platform’s architecture, a reading list of internal documents, and access to a sandbox environment with step-by-step exercises. The material was good. Senior engineers had spent considerable time producing it, and it was kept reasonably current.

Yet the team lead, Sanne, kept noticing the same thing. New engineers would finish the material confidently, then struggle badly on their first real on-call rotation. They knew the names of every component and could draw the architecture from memory. What they could not do was work out, under time pressure, why a deployment was stuck in a pending state or why a particular service had stopped emitting metrics.

Framing the problem

Sanne resisted the obvious first reaction, which was to add more material. Instead she asked the team to describe, in detail, how each of them had actually learned to operate the platform. The answers were strikingly consistent. Almost nobody credited the recordings. They credited specific incidents they had worked through, usually alongside a more experienced colleague, often in the same room.

That gave the team a working hypothesis: the onboarding taught people about the platform, but it did not give them enough first-hand experience operating it. The knowledge was real but second-hand, and second-hand knowledge did not survive contact with a live incident.

The intervention: a build week

The team redesigned the first weeks around doing rather than watching. The core was an in-person build week, held whenever a new cohort joined, with these features:

  • Same room, same time. Newcomers and at least one senior engineer worked side by side in the office for the whole week.
  • A real deliverable. Each newcomer deployed a small but genuine internal service onto the platform, end to end, by the middle of the week.
  • Injected faults. On the later days, seniors quietly introduced failures into the newcomers’ services: an expired certificate, a misconfigured probe, a resource limit set too low.
  • Talk-aloud debugging. When a newcomer got stuck, the senior asked them to narrate their reasoning before offering any hints.
  • Recordings as reference. The existing video library stayed, but its role changed to something people consulted when they needed it, not a curriculum to complete.

What the team observed

Lighthouse did not run a controlled experiment, and any honest account has to acknowledge that. Cohorts were small, the people differed, and the platform itself evolved over the period. Still, a few qualitative observations were consistent enough to be worth recording.

Faster independence on real work

Engineers who went through build week began handling routine platform requests on their own noticeably sooner than earlier hires had, according to the seniors who worked with both groups. The newcomers themselves pointed to the injected faults as the turning point: having already diagnosed an expired certificate once, they recognised the symptoms immediately when it happened for real.

Different questions

Seniors noticed that the questions new engineers asked shifted. Earlier cohorts had asked what a component did. Build-week cohorts asked why a component had been configured a particular way, or what the trade-off had been. That is the kind of question that signals understanding rooted in experience rather than description.

Stronger working relationships

Spending a week solving problems together built relationships that video onboarding never had. Newcomers knew whom to approach and felt less hesitant about asking. Seniors had a clearer sense of each newcomer’s strengths. When on-call shifts began, handovers were smoother.

Better material

An unexpected benefit was that the recorded library improved. Watching newcomers work showed seniors exactly where the existing videos had glossed over difficult steps. Several walkthroughs were rewritten as a result.

What remained hard

The change carried real costs. Build week took senior engineers away from their own work, and the team had to protect that time actively against delivery pressure. Remote hires could not always attend in person; the team tried a remote version with pairing over video, which helped but was described as noticeably less effective at creating the same sense of shared problem-solving.

There was also a risk of over-correction. One cohort spent so much time on faults that they arrived at their first rotation knowing how to fix things but unclear on the platform’s overall design. The team adjusted by reintroducing a short architecture session at the start of the week.

How the newcomers described it

In short retrospectives at the end of each build week, newcomers were asked what had been most and least useful. The most common answer for “most useful” was the first injected fault they had to resolve on their own service. Several described a moment of near panic followed by a methodical search through logs and events that ended in the fix. They remembered that sequence vividly weeks later. The least useful elements were, interestingly, the parts of the week that resembled the old format: passive overviews where a senior presented slides. The team trimmed those sessions and moved their content into short, optional references.

Extending the idea beyond onboarding

Encouraged, Lighthouse applied the same principle more widely. They began running periodic hands-on game days for the entire team, simulating failures in a staging environment and working through them together. They also encouraged engineers to attend external workshops and lab sessions where they would practise unfamiliar tools themselves rather than watch talks. One engineer who relocated to Bengaluru mentioned using Bangalore Orbit, a guide to live events and workshops around the city, to find developer meetups and hands-on sessions near her new home.

Analysis: why the change seems to have worked

Several mechanisms plausibly explain the outcome. First, build week turned recognition into recall by forcing newcomers to produce working systems unaided. Second, injected faults gave them first-hand memories of failure, which are far more durable than descriptions of failure. Third, physical proximity shortened the feedback loop: help arrived at the moment of struggle. Fourth, talk-aloud debugging made reasoning visible in both directions, so seniors could correct thinking rather than only results.

None of this is novel. It echoes what many experienced practitioners say about how they learned. What is perhaps instructive is how easily a well-intentioned team had drifted away from it in pursuit of scalable, content-based onboarding.

Lessons for other teams

  1. Ask your engineers how they actually learned. Their answers are a strong guide to what onboarding should contain.
  2. Make newcomers ship something real, early, with support nearby.
  3. Practise failure deliberately before it happens unplanned.
  4. Keep recorded material, but treat it as reference, not curriculum.
  5. Budget senior time explicitly; hands-on onboarding is not free.

For individuals rather than teams, the same principles shape a sensible path into the field; our practical guide to breaking into DevOps work and our overview of the core capabilities DevOps engineers are expected to bring this year both stress practice over passive study.

Conclusion

The Lighthouse story is fictional, but its central finding is familiar. Engineers become capable operators by operating, ideally alongside people who already know how. Content has a place, and an important one. It simply cannot replace the first-hand experience of building, breaking and fixing a system in the company of colleagues.