Catalog My learning Blog
CI/CD and DevOps Tutorial: Build a Delivery Pipeline · Phase 4 · Lesson 27 · 3 min read

DevOps Anti-Patterns and Building the Culture

On this page
  1. Why DevOps transformations stall
  2. DevOps anti-patterns
  3. The removal test for culture
  4. Changing culture in practice
  5. Where this course leaves you
  6. Check yourself

Why DevOps transformations stall

A company buys a CI/CD platform, a Kubernetes cluster and an observability suite. A year later, releases are still monthly, incidents still end in finger-pointing, and the new "DevOps team" is the bottleneck everyone waits on. The tools were never the hard part.

DevOps anti-patterns

Anti-patternWhat it looks likeBetter
The renamed ops teamA "DevOps team" owns all pipelines and deploys; developers file ticketsA platform team builds self-service tools; product teams own their services
Tool-first adoption"We have Kubernetes, so we do DevOps"Start from a problem (slow releases, painful incidents) and choose practices, then tools
Hero cultureOne person fixes every outage and is praised for itSpread knowledge; reward fixes that prevent incidents, not heroic recoveries
Blame after incidentsPostmortems name a culpritBlameless reviews focused on the system (Day 23)
Big-batch releasesQuarterly release trains with weeks of testingSmall, frequent changes behind flags (Days 2 and 15)
Metrics as weaponsDORA numbers used to rank teamsMetrics for each team's own improvement (Day 26)
Manual gates everywhereChange advisory boards approve every deployAutomated checks; human review where risk is high
Anti-patterns that stall DevOps adoption on one side, and the cultural practices that replace them on the other.
Anti-patterns that stall DevOps adoption on one side, and the cultural practices that replace them on the other.

The removal test for culture

Is a practice part of the culture, or only enforced by a tool or a rule? Imagine the enforcement disappeared:

YAML
Practice: "We deploy small changes several times a day."
  If the pipeline broke tomorrow, would engineers still want small, frequent changes?
  Yes -> it's how the team works.
  No, they'd batch changes into big releases -> the tool drives it, the belief doesn't.

Practice: "We write blameless postmortems."
  If the template stopped asking for "contributing factors, not people",
  would reviews stay blameless?
  Yes -> taken root.
  No, people would name who made the mistake -> not yet.

Practices that fail the test need conversation, examples from leaders, and time, not more tooling.

Changing culture in practice

Culture changes through repeated experience, not announcements:

  • Start small and visible. Pick one team and one painful problem (say, deploys that take a day) and fix it end to end. Success stories spread faster than mandates.
  • Leaders model it. Managers who share their own mistakes, join postmortems as learners, and protect time for reliability work make it safe for others.
  • Make the right way the easy way. Platform teams provide templates, golden paths and self-service environments, so following good practice takes less effort than avoiding it.
  • Shared goals. Development and operations share SLOs and on-call, so stability and speed are everyone's job (Days 21 and 22).
  • Measure and reflect. Use DORA metrics and retrospectives to see whether changes help, and adjust.
  • Psychological safety. Westrum's research, cited in DORA's reports, found that "generative" cultures (high trust, information flows freely, failures lead to inquiry) predict better delivery and better outcomes.

Where this course leaves you

You've seen the full loop: small changes on a shared trunk, fast CI with meaningful tests, artifacts built once and promoted, infrastructure as code, progressive delivery with flags and canaries, observability that catches regressions, practiced incident response, blameless learning, and metrics to see progress. None of it works alone, and all of it depends on teams that trust each other enough to change.

Check yourself

It becomes a new handoff point between developers and production. Developers still don't own operations, and the DevOps team becomes a bottleneck for every pipeline or infrastructure change.

Imagine removing the tools or rules that enforce a practice. If the team would keep doing it, they believe in it; if it would disappear, it's only kept alive by enforcement and isn't really part of the culture.

With one concrete, painful problem, such as a slow manual release, fixed end to end on one team. Visible results build momentum and credibility for wider change better than a large reorganization.

They build self-service tools and paved paths, such as templates, pipelines and environments, that product teams use on their own, without filing tickets. They enable teams rather than acting as gatekeepers for every change.

Teams need time to pay down automation and reliability work, and blameless culture only lasts if managers model it after incidents.