What is trunk-based development and how does it support CI/CD?

Question

IT Interview Practice · Accepted Answer

**Trunk-based development** is a branching strategy where developers integrate small changes **frequently into a single main branch (trunk)**, using very short-lived branches (or committing directly). It's strongly associated with high-performing CI/CD because it maximizes continuous integration.

## What trunk-based development is

```text
Developers commit small, frequent changes to a SINGLE shared branch (trunk/main):
  → very SHORT-LIVED branches (merged within hours or a day) — or commit directly
  → integrate continuously (multiple times a day) into trunk
  → trunk is kept always RELEASABLE (working, deployable)
→ vs long-lived feature branches that diverge for days/weeks before merging.
```

## Why it supports CI/CD well

```text
✓ MAXIMIZES continuous INTEGRATION — frequent small merges = the essence of CI
  (catch integration issues immediately; tiny, easy-to-resolve conflicts)
✓ AVOIDS "merge hell" — no long-lived branches diverging → no big painful merges
✓ Small changes = lower risk, easier review, faster feedback
✓ Keeps trunk always deployable → enables continuous DELIVERY/deployment
→ Research (DORA) links trunk-based development to high delivery performance.
```

## Handling incomplete work

```text
How to commit to trunk frequently when features aren't done?
  ✓ FEATURE FLAGS → merge incomplete features hidden behind off flags (don't break trunk)
  ✓ Break work into small, independently-mergeable, non-breaking pieces
  ✓ Branch by ABSTRACTION → introduce changes incrementally behind abstractions
→ The discipline: integrate small, keep trunk working, hide incomplete work.
```

## Trunk-based vs feature-branch (Git Flow)

```text
TRUNK-BASED → short-lived branches, frequent integration, continuous delivery,
  feature flags — favored for high-velocity CI/CD
GIT FLOW (long-lived branches) → more structured, release-oriented, but longer
  divergence and bigger merges → less continuous
→ Trunk-based is generally preferred for true CI/CD; Git Flow for scheduled releases.
```

## Why it matters

Understanding trunk-based development is valuable senior-level knowledge because it's **strongly associated with high-performing CI/CD** and represents an important branching philosophy, so it's useful for understanding effective delivery practices.

The core idea — developers integrating **small changes frequently into a single trunk** using very short-lived branches (rather than long-lived feature branches that diverge for days or weeks) — directly **maximizes continuous integration**, which is the essence of CI: frequent small merges catch integration issues immediately and produce tiny, easy-to-resolve conflicts, **avoiding the "merge hell"** of long-divergent branches.

Understanding **why it supports CI/CD well** (maximizing integration, avoiding big painful merges, keeping changes small and low-risk, and keeping trunk always deployable to enable continuous delivery) explains why it's favored for high-velocity delivery — and notably, **DORA research links trunk-based development to high delivery performance**, giving it empirical support.

Understanding **how to handle incomplete work** while committing frequently to trunk — using **feature flags** (merging incomplete features hidden behind off flags so trunk stays working), breaking work into small independently-mergeable pieces, and branch by abstraction — is the key practical discipline that makes trunk-based development feasible (it requires these techniques to integrate incomplete work without breaking trunk).

Understanding the **contrast with feature-branch/Git Flow** approaches (trunk-based for high-velocity continuous delivery; Git Flow's long-lived branches for more structured but less continuous, scheduled releases) reflects sound judgment about branching strategy.

Since trunk-based development is the branching approach that best enables true continuous integration and delivery (with research linking it to high performance), and since understanding it, why it supports CI/CD, and how to practice it (feature flags, small changes) reflects understanding of high-performing delivery, understanding trunk-based development is valuable senior-level knowledge — an important practice associated with effective CI/CD, reflecting the delivery-practice maturity expected for senior roles shaping how teams integrate and deliver.

What trunk-based development is

Why it supports CI/CD well

Handling incomplete work

Trunk-based vs feature-branch (Git Flow)

Why it matters

Related questions