liveBook · Manning

Trunk-based development

Trunk-based development is a software workflow in which developers frequently integrate small changes into a shared mainline, typically using short-lived or no feature branches.

How 4 Manning books explain it

Platform Engineering on Kubernetes

Trunk-based development is a source-control practice in which the main branch remains continuously releasable through small, validated changes and short-lived feature branches.

How it is used
Keeps the main branch releasable while coordinating feature work, validation, artifact creation, and frequent service releases.
How deep it goes
Defines branch and pipeline behavior through release tagging and validation, but does not prescribe one universal pipeline implementation.
Examples
Uses pull-request checks, main-branch pipelines, Git tags, binary artifacts, container images, unit tests, coverage checks, and security scans.
What you can do after
Operate a Git workflow that validates feature changes, protects main, and produces traceable releases after successful merges.

Read how Platform Engineering on Kubernetes explains trunk-based development →

Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform

Trunk-based development is a workflow that integrates small, incremental changes directly into a shared main branch with short-lived or no feature branches.

How it is used
Coordinates incremental infrastructure changes when teams share one main branch and continuously test delivery.
How deep it goes
Explains definitions, Git steps, pipeline stages, benefits, limitations, and testing requirements without detailing implementation internals.
Examples
Uses firewall rules, firewall licenses, Git commands, delivery pipelines, unit tests, integration tests, and manual approval.
What you can do after
Apply via Git and a continuous delivery pipeline to coordinate small infrastructure changes and identify conflicting commits.

Read how Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform explains trunk-based development →

Effective Platform Engineering

Trunk-based development is a version-control practice in which developers integrate small changes frequently into a shared mainline.

How it is used
Keeps platform infrastructure changes continuously integrated into a shared mainline and a reliable path to production.
How deep it goes
Specifies pair programming, short-lived branches, and daily-or-more-frequent merges, without detailing branching mechanics or conflict resolution.
Examples
Uses platform-team pushes to trunk, short-lived GitHub story branches, and infrastructure changes progressing through a sandbox environment.
What you can do after
Apply it by merging platform changes frequently into main while preserving a stable, recurring release path.

Read how Effective Platform Engineering explains trunk-based development →

The AI Pocket Book

A development workflow where changes are integrated directly into the main branch with supporting practices to avoid breaking production.

How it is used
Organizes software teams around continuous integration, testing, controlled releases, and reliable delivery rather than isolated coding.
How deep it goes
Explains the branch workflow, feature flags, staged rollout, and automated testing, but stops short of detailed implementation guidance.
Examples
Uses a feature flag that exposes new code first to the developer and quality assurance team before a broader release.
What you can do after
Operate a trunk-based workflow with short-lived branches, automated tests, feature flags, and staged validation.

Read how The AI Pocket Book explains trunk-based development →

Related concepts

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.