DevOps Fundamentals

One culture, six practices, and the reason software teams started shipping every day instead of every quarter.

The continuous loop Plan · Build · Test · Release · Operate · Observe

Developers spend three months writing a new payment feature. They are excited — this is the kind of thing users have been asking for. They package everything up and hand it to the operations team on a Friday afternoon.

Operations open the ticket. The new feature needs a different database setting, a new firewall rule, a few extra environment variables, and a fresh deployment script. Nobody told them. They have a hundred other services to keep alive over the weekend, and the developers have already started their weekend.

By Monday, the feature is live. It is also broken. The developers say "operations deployed it wrong." Operations say "the developers shipped a bug." A new ticket is opened to investigate whose fault it is.

DevOps is the answer to this story. The same team writes the code, ships the code, and is woken up if the code breaks. No hand-off. No blame queue. One goal.

01So what is DevOps, exactly?

The short answer: DevOps is the practice of building and running software as one team, using automation to make changes safe and small. But the term means slightly different things to different people — and the difference matters, because each definition pulls the focus to a different part of the work.

The simple version

DevOps is what happens when the people who write the software and the people who run the software stop being two teams and start being one team.

The technical version

DevOps is a set of practices — version control, continuous integration, infrastructure as code, automated testing, observability — that let a team ship a small change to production safely, many times a day.

The cultural version

DevOps is a culture of shared ownership. The team is responsible for the full life of the service: design, build, deploy, monitor, and fix at 3 a.m. when it breaks. Tools follow.

The interview version

DevOps is the combination of culture, practices and tools that lets an organization deliver software at high speed, with high quality, and with fast recovery when things go wrong.

02Why DevOps exists at all

For decades, "Dev" wrote the code and "Ops" ran the servers. They had different bosses, different tools, different goals, and often different floors of the building. Three forces pushed those walls down.

Force 1

Software became the business

Banks, hotels, supermarkets — everyone is now a software company that happens to do something else on the side. When the website is your storefront, shipping a fix once a quarter is not an option anymore.

  • Then. A bank changed its loan rules twice a year.
  • Now. A fintech changes them twice a day, in response to a fraud spike or a marketing campaign.
Force 2

Cloud made infrastructure programmable

Provisioning a server used to take six weeks and three approvals. With AWS, Azure and GCP, it takes one API call. If a developer can create infrastructure in seconds, the old "submit a ticket and wait" model stops making sense.

  • Then. Order hardware, rack it, cable it, install an OS, hand it over.
  • Now. terraform apply. Network, server and database in 90 seconds.
Force 3

Agile fixed dev — but not ops

Agile made development teams faster. They started releasing every two weeks. But the releases were still hand-deployed by a separate ops team, on a separate schedule. The queue moved from "design" to "deploy", and the bottleneck just shifted.

  • Dev's speed. Two-week sprints, lots of finished work.
  • Ops's speed. One change window per month, lots of frustration.
  • DevOps fix. Make ops part of the team — and automate the bottleneck away.
Result

So … the wall came down

One team, with shared on-call, shared dashboards, shared tools, and shared pain. When deploying is everybody’s problem, deploying gets easier, because the people who feel the pain are the people who can fix it.

  • The promise. Ship faster and safer at the same time.
  • The catch. The team has to actually want to own the whole thing.

03How to tell if a team is "really" doing DevOps

Forget the job titles and the slide decks. The DORA program (Accelerate State of DevOps) measured thousands of teams and found that four numbers consistently separate elite teams from low performers. If you remember nothing else from this chapter, remember these.

On-demand
Deployment frequency
Elite teams ship multiple times a day. Low performers ship a few times a year.
<1hr
Lead time for changes
From "commit pushed" to "running in production". Elite is under an hour; low is over a month.
<15%
Change failure rate
Of all deploys, how many caused an outage or required a hotfix.
<1hr
Mean time to restore
When something does break, how fast you can put it right.
i

Interview shortcut

Ask the candidate "how often does your team deploy to production?" If the answer is "once a month" or "we have a release window", the rest of the conversation tells you why — not whether — the team is struggling.

04The six practices behind every DevOps team

These are not tools — they are practices. Each one removes a different kind of manual work and a different kind of risk. You can implement them with many different tools, but a team that skips one of them will feel it.

Practice 01

Version control for everything

Not just application code — the infrastructure that runs it, the pipeline that ships it, the dashboards that monitor it, even the runbooks the on-call engineer reads at 3 a.m. If it changes, it lives in Git.

  • Why. One reviewable history, one audit trail, one source of truth.
  • How. Pull requests for every change. CODEOWNERS for sensitive paths.
Practice 02

Continuous Integration

Every commit triggers a build that compiles the code, runs the tests, and reports back in minutes — not days. A broken build blocks the merge. Broken main is never normal.

  • Why. Catches bugs while context is still fresh.
  • How. Small PRs. Fast tests. Parallelize. Cache.
Practice 03

Continuous Delivery

Every green build produces a deploy-ready artifact. Pushing it to production is a button. Sometimes it’s an automatic button (that’s called Continuous Deployment); sometimes a human approves it.

  • Why. Removes the "release weekend" as a thing.
  • How. Immutable artifacts, environment promotion, rollback in one click.
Practice 04

Infrastructure as Code

Servers, networks, databases, queues — described in plain text files. To make a change you open a pull request, get it reviewed, and let a pipeline apply it. The cloud console becomes read-only.

  • Why. Identical environments. Reviewable changes. Disaster recovery is one command.
  • How. Terraform / OpenTofu / Pulumi / Crossplane. Pick one. Be boring.
Practice 05

Standardized runtime

Every service ships the same way: as a container, run by the same orchestrator. The difference between two services becomes the code inside the container, not the bespoke install script.

  • Why. One deploy story. One monitoring story. One security story.
  • How. Docker for the package, Kubernetes (or ECS, or App Runner) for the runtime.
Practice 06

Observability with SLOs

Logs, metrics, traces, and a small number of agreed reliability targets. When the error budget is running out, the team slows down feature work and pays back the debt. Reliability is treated as a feature, not a department.

  • Why. Users feel pain before dashboards do. Close that gap.
  • How. OpenTelemetry SDK, a backend (Grafana, Datadog, …), SLO + burn-rate alerts.

05How we got here — in three eras

DevOps did not arrive on a Tuesday. It is the third answer to a question the industry has been asking for fifty years: "how do we ship software faster without breaking it?" Each era fixed the previous era’s bottleneck.

~1970 — 2000

Waterfall

Big upfront design, one massive release per year. Worked when software was sold in shrink-wrapped boxes. Feedback arrived after the box did.

2001 — today

Agile

Short iterations, working software every two weeks. Fixed development’s pace. But the operations team still released on a separate calendar. The bottleneck just moved.

~2009 — today

DevOps

Same team owns build and run. Releases happen many times a day, with automation doing the dangerous parts. The bottleneck becomes… deciding what to build next.

06The mindset shift

Tools and pipelines are the easy part. What actually makes DevOps work is a change in how the team thinks. Three shifts matter more than any other.

Shared ownership

From: "I wrote it; ops will run it."
To: "I wrote it; I will run it — with my team."

When you carry the pager for your own service, you write better health checks. Pain is a very effective teacher.

Small batches

From: a giant quarterly release with 300 changes.
To: 30 tiny releases, every working day.

Risk grows non-linearly with diff size. Ten 10-line PRs are far safer than one 100-line PR — and far easier to roll back.

Blameless improvement

From: "Who pushed the bad change?"
To: "Why did the system let a bad change through?"

Blameless postmortems do not mean "no accountability". They mean: fix the process that allowed it, not the person who tripped on it.

07Anti-patterns — "we’re doing DevOps", but…"

Some teams adopt the tools and miss the point. Here are the most common ways teams accidentally rebuild the old wall — just with shinier bricks.

Anti-pattern
"The DevOps team". A separate group writes pipelines and Terraform for the developers. They become the new "ops" — same wall, new title. Healthier model: a small platform team builds golden paths, the product teams self-serve.
Anti-pattern
Tool worship. "We bought Kubernetes / Jenkins / Argo, so we are doing DevOps." Tools without the culture just make the wall taller. Buy them after you have agreed on small batches, shared ownership, and trunk-based delivery.
Anti-pattern
Hero culture. One brilliant engineer always firefights at 3 a.m. The pager is "theirs". That engineer eventually leaves, and the team discovers it forgot how to operate the system. Spread the pager.
Healthy
Boring releases. A deploy in the middle of Tuesday afternoon, while everyone keeps working, with nobody specifically watching it. If that scares your team, you have a DevOps problem — not a tool problem.

08Putting it together

Take-aways

1. DevOps is one team that builds, ships, and operates the software — backed by automation that makes changes small and safe.

2. It exists because software became the business, the cloud made infrastructure programmable, and Agile alone left ops behind.

3. A "real" DevOps team scores well on four numbers: deploy frequency, lead time, change failure rate, and time to restore.

4. Six practices (version control, CI, CD, IaC, standard runtime, observability) plus three mindsets (shared ownership, small batches, blameless improvement) cover the whole game.

Next chapter: we open the engine room. CI / CD pipelines — the automation that turns "we believe in DevOps" into "we ship every two hours."