trunk-based development

Deployment & Operations

Meaning

Trunk-based development is a source‑control branching strategy where developers commit directly to a single main branch (the “trunk”) and keep feature work short‑lived. It addresses the pain of long‑running feature branches that cause integration conflicts and delayed feedback. Teams reach for it when they need rapid, continuous integration and frequent releases.

Primary Function

Version control strategy

Communicative Purpose

Enables rapid integration of changes and reduces merge conflicts by avoiding long‑lived branches.

Pattern

Develop on the main branch, integrate small changes continuously, release frequently.

Função primária

Version control strategy

Propósito comunicativo

Enables rapid integration of changes and reduces merge conflicts by avoiding long‑lived branches.

Situações de gatilho

Web application development: deploying new UI changes multiple times per day; Mobile app development: releasing patches without waiting for a release branch; Microservices architecture: iterating on service APIs while keeping the main line stable

Contextos

Agile teams, continuous delivery pipelines, DevOps environments, microservice codebases

Padrão

Develop on the main branch, integrate small changes continuously, release frequently.

Colocados típicos

feature flag
continuous integration
short‑lived branch
fast‑forward merge

Substituições comuns

GitFlow – uses long‑lived develop branch
more overhead
Feature branching – longer branch lifespan
higher merge risk
Release branching – isolates releases but adds complexity

Erros comuns

Merging large, untested changes directly to main → introduces bugs; Skipping code review on trunk commits → reduces code quality; Using long‑lived feature branches despite trunk policy → defeats purpose and creates integration hell

Similar / contraste

GitFlow – structured with develop branch; Feature branching – separate branches per feature; Continuous integration – focuses on automated testing but not branch strategy

Interferências

Coming from GitFlow: assuming a permanent develop branch is required → trunk‑based dev eliminates it and encourages direct main commits

Família do chunk

GitFlow
feature branching
continuous integration
release branching

Nuance

Do not use when regulatory constraints demand isolated release branches; Trunk‑based dev reduces merge overhead but may increase build load on CI servers; It works best when each commit is kept small and passes all tests before merging

Efeito pragmático

Reduces integration bottlenecks, shortens lead time from code commit to production, and improves overall code health.

Dica de memória

Think of the trunk of a tree: every new leaf (change) grows directly from the main stem, never from a distant branch.

Frequência: HighFormulaicidade: FixedTipo de construção: conceptPrioridade de aquisição: Automatic productionPrioridade de output: BothTag de espaçamento: Immediate

Examples

import subprocess def commit_to_trunk(message, files): subprocess.run(["git", "add"] + files, check=True) subprocess.run(["git", "commit", "-m", message], check=True) subprocess.run(["git", "push", "origin", "main"], check=True) commit_to_trunk("Add utility function", ["utils.py"])

import subprocess def short_lived_feature(name): subprocess.run(["git", "checkout", "-b", name, "main"], check=True) # make changes... subprocess.run(["git", "add", "."], check=True) subprocess.run(["git", "commit", "-m", f"Feature {name}"], check=True) subprocess.run(["git", "checkout", "main"], check=True) subprocess.run(["git", "merge", "--ff-only", name], check=True) subprocess.run(["git", "push", "origin", "main"], check=True) subprocess.run(["git", "branch", "-d", name], check=True) short_lived_feature("fix-logging")

import os def new_algorithm(data): # new implementation return [d * 2 for d in data] def old_algorithm(data): return [d + 1 for d in data] def process(data): if os.getenv("ENABLE_NEW_ALGO") == "1": return new_algorithm(data) else: return old_algorithm(data) print(process([1, 2, 3]))