An engineering handbook is the single source of truth for how your team builds, deploys, and operates software. Done well, it accelerates onboarding, reduces inconsistency, and encodes hard-won institutional knowledge. This guide covers exactly what to include, how to structure it, and how to keep it alive over time.
What Is an Engineering Handbook?
An engineering handbook (also called an engineering wiki, playbook, or runbook) is a living document that captures the standards, practices, tools, and processes your engineering organisation uses to build and operate software. It differs from technical documentation (which documents what your systems do) in that it documents how your team works — the norms, conventions, and decision frameworks that govern daily engineering activity.
Notable examples include GitLab's public handbook (one of the most comprehensive in the industry), Stripe's internal engineering guidelines, and Basecamp's Shape Up methodology document. These organisations treat their handbook as a product — maintained, versioned, and owned by the engineering organisation as a whole.
Why an Engineering Handbook Matters
Without a handbook, institutional knowledge lives in Slack DMs, tribal memory, and individual engineers' heads. Every time someone leaves, knowledge walks out the door. Every time someone joins, they spend weeks interrupting colleagues with questions that have already been answered a hundred times. The handbook is the antidote: it converts ephemeral knowledge into durable, searchable, and shareable documentation.
Core Sections Every Engineering Handbook Should Include
Development Standards Section: What to Document
The development standards section is the highest-leverage part of the handbook. Clear standards reduce code review friction, make onboarding faster, and prevent the proliferation of incompatible approaches across teams.
| Standard Category | What to Document | Tooling to Reference |
|---|---|---|
| Code Formatting | Indentation, line length, import ordering | Prettier, Black, gofmt |
| Linting Rules | Enabled rule sets, exceptions policy | ESLint, Biome, Pylint, Golangci-lint |
| Commit Messages | Format spec (e.g. Conventional Commits), scope definitions | Commitlint, Lefthook |
| Branch Naming | Pattern: type/ticket-id/short-description | Git hooks, branch protection rules |
| PR Requirements | Min reviewers, test coverage gate, CI pass required | GitHub Branch Protection, GitLab approval rules |
| Testing Standards | Unit/integration/e2e coverage requirements, test naming | Jest, Vitest, Pytest, Playwright |
| API Design | REST conventions, versioning strategy, error format | OpenAPI spec, Spectral linting |
Architecture Decision Records (ADRs)
Architecture Decision Records are short documents that capture the context, decision, and consequences of significant architectural choices. They are one of the most valuable sections of an engineering handbook because they explain why the system is the way it is — preventing future engineers from unknowingly repeating past debates or reversing decisions for reasons that have already been considered.
A minimal ADR includes: Title (short noun phrase), Status (proposed/accepted/deprecated/superseded), Context (what situation prompted this decision), Decision (what was decided), Consequences (positive, negative, and neutral outcomes). Store ADRs in the repository as markdown files (/docs/adr/) so they live with the code.
When documenting your ADR process in the handbook, specify: where ADRs are stored (repo vs wiki), the required format, who can propose an ADR, how decisions are ratified (RFC process, engineering lead sign-off, team vote), and how ADRs are superseded when decisions change.
Incident Response and On-Call Section
The on-call and incident response section is critical for operational reliability. It should be self-contained enough that an engineer paged at 2am can find everything they need without asking anyone. Include:
- On-call rotation schedule and how to find who is on call
- Alert definitions — what each alert means and initial triage steps
- Runbooks for common incidents (database slow queries, memory leaks, service outages, failed deployments)
- Escalation path — when to escalate, who to page, how to declare a major incident
- Post-mortem process — blameless post-mortem template, timeline, required participants, action item tracking
- Communication templates — status page update format, stakeholder notification emails
How to Keep the Handbook Alive
Handbook Tooling Options
- Best for non-technical teams and mixed audiences
- Rich media, databases, templates
- Easy to edit for non-engineers
- Less version control than git-based options
- Weak diff/history vs markdown in git
- Best for engineering-first teams
- Full version history via git
- PR review process for handbook changes
- Hosted as static site (GitHub Pages, Netlify)
- Higher barrier for non-technical contributors
- Best for organisations already on Atlassian stack
- Deep Jira integration for ADRs and runbooks
- Good access control and audit trail
- Can become cluttered without strong governance
- Slower search vs dedicated tools
- Best for keeping handbook close to the code
- No additional tooling cost
- Wiki: easy editing; Pages: full static site
- GitLab handbook model is publicly proven at scale
- Less rich media support vs Notion/Confluence