Convention Over Configuration: A DevOps Beginner’s Primer

Convention Over Configuration: A DevOps Beginner’s Primer

New DevOps learners often assume that the job is about knowing as many tools as possible. In practice, experienced engineers spend much of their effort removing choices so that routine work stops demanding thought. One long-standing idea behind this is called convention over configuration: agree sensible standard ways of doing things, and only configure what genuinely differs. This primer explains how limiting your choices works in DevOps practice, why it reduces decision fatigue, and ends with a plain list of key words so the jargon stops tripping you up.

Starting from the problem

Imagine you join a team that maintains a dozen services. For each one you must decide how to name branches, where configuration lives, how the build is triggered, which base image to use and how to label releases. If every service answers those questions differently, you must learn twelve sets of habits. If they all follow the same short set of conventions, you learn one and apply it twelve times. That is the entire appeal: the same knowledge covers more ground.

Psychologists describe the opposite experience as decision fatigue. Each small choice draws on a limited pool of attention, and when the pool runs low, judgement gets sloppy. Engineers who spend their mornings answering trivial questions have less left for the hard ones, like diagnosing a fault or designing a safe change.

The three layers where choices pile up

A helpful way to organise the topic is to think in layers.

  1. Code and collaboration. Branch naming, commit message style, review rules, how changes are merged.
  2. Build and delivery. Pipeline structure, test stages, artefact naming, release labels.
  3. Environment and configuration. Settings for local, test and production, secrets handling patterns, base images and runtimes.

At each layer, the practice is the same: write down a small number of approved answers and make them the default. A learner who recognises these three layers can look at any project and quickly see where the team has decided and where it has not.

Glossary of terms you will keep hearing

These words come up constantly whenever engineers talk about narrowing choices, and each gets a sentence or two below.

  • Convention: an agreed standard way of doing something, so nobody needs to decide again.
  • Default: the option used automatically unless someone deliberately picks another.
  • Preset: a named bundle of settings, such as a “test” profile that sets many values at once.
  • Template: a ready-made starting point for a new project or pipeline, containing the standard layout.
  • Pipeline: the automated sequence that builds, tests and delivers a change.
  • Branch rule: a policy about how code branches are named, protected and merged.
  • Base image: the starting layer used to build a container, usually chosen from a short approved list.
  • Exception: a documented departure from the default, with a reason attached.

How the idea shows up in real tools

Many popular frameworks quietly practise the idea. They assume a standard folder layout, a standard way of naming things and a standard place for configuration. Because you follow the convention, you write little configuration at all. People who have learned one such framework often find a second one easy, since the conventions rhyme. When you start your own projects, copying that spirit is a quick win: pick a layout, name it, write it down.

A worked example you can try

Suppose you are learning by building a small web service in a personal repository. Rather than inventing everything as you go, write a half-page of decisions before you begin.

  • Branches: one main branch plus short-lived topic branches named with a single pattern.
  • Pipeline: one template with the stages build, test, package.
  • Configuration: three profiles called local, test and production.
  • Images: one approved base image for the language you use.

Now every time a choice comes up, you have an answer. Your attention goes to learning how the pieces fit, not to re-deciding the naming scheme each day. When you eventually discover a better approach, change the half-page once and the benefits spread everywhere. For the problem-solving side of this habit, see our discussion of building critical thinking for DevOps problem solving, which pairs well with the idea of keeping routine decisions out of the way.

Where beginners go wrong

  • Copying conventions without understanding them. A default is useful only if you know why it exists. Ask the reason behind each one.
  • Over-engineering the menu. A dozen presets for a single small project is just choice in a different costume.
  • Forgetting to write it down. Conventions kept only in memory drift apart within weeks.
  • Treating exceptions as embarrassing. Real systems differ. Record the exception and move on.

Our overview of the knowledge gaps students commonly need to close shows other places where early habits shape later confidence.

Why this is a career skill, not only a tidiness habit

Teams value people who make the common case easy for others. An engineer who contributes a clean template, writes the convention down and keeps it up to date multiplies the productivity of everyone around them. That sort of contribution is easy to demonstrate in interviews and portfolios, because the effect is visible: shorter onboarding, fewer repeated questions, calmer reviews. It also connects to bigger organisational goals, as discussed in our note on the skills and strategy behind IT transformation.

The human routines are conventions too

The same principle applies beyond code. Who is on call this week, how absences are recorded, when handovers happen: all of these can be settled by convention. For a glimpse of how a site approaches the people side, look at Inoroff, a website whose pages go through how a modest-sized company might handle who is in, who is away and who signs off, from check-ins and leave requests to manager approvals and rotas. The overview lives at the Inoroff site, and it makes a useful contrast with the code-focused conventions above: both aim to answer routine questions once.

What changes when you move from one project to many

On a single personal project, conventions feel like a tidy extra. Across many services they become a form of infrastructure. Consider what happens when a new engineer joins a team that follows a handful of conventions. In the first week they read one short page, clone a template and ship a small change. In a team without conventions, the same engineer spends the first week asking colleagues how each service differs and keeping a private list of exceptions. The tools are identical; the experience is completely different.

For this reason, mature teams often treat their conventions as a product. Someone owns them, listens to complaints, fixes rough edges and retires rules nobody follows. As a beginner you can practise that mindset early by looking after your own half-page as if other people depended on it, even when you are the only user.

A quick self-check

After reading, test yourself with a few questions. Can you name the three layers where choices pile up? Can you explain, in your own words, the difference between a default and a preset? Could you write a half-page of conventions for a toy project in ten minutes? If any answer is shaky, reread the matching section and try again. The glossary is there to be revisited.

Where to go from here

  1. Pick one small project and write its half-page of conventions today.
  2. Follow it for two weeks and note where it creaks.
  3. Adjust the page once, then keep following it.
  4. Look at a team project you know and list its conventions, written or unwritten.
  5. Practise explaining one convention and its reason aloud to a friend.

The point of all of this is modest and powerful. A few well-chosen defaults let you spend your learning energy on the interesting parts of DevOps, rather than burning it on the thousand small decisions that never needed to be decisions at all.