Runbook Template: Complete Guide for Teams

A runbook is only as good as its structure. Without a consistent template, runbooks become scattered notes that nobody trusts during incidents.

This guide provides a battle-tested runbook template that works for any operational procedure.

What Is a Runbook?

A runbook is a documented procedure for completing a routine operation or responding to an incident. Good runbooks turn tribal knowledge into repeatable processes that anyone on the team can execute. If you’re new to runbooks, start with our guide on how to write a runbook.

Why Runbooks Matter

Consistency: Same procedure, same results, every time
Speed: No time wasted figuring out what to do
Knowledge sharing: New team members can execute immediately
Reduced errors: Tested procedures catch edge cases

The Essential Runbook Template

1. Header Section

Every runbook needs clear metadata:

# [Runbook Title]

**Last Updated:** 2025-12-08
**Owner:** @team-platform
**Severity:** P2
**Estimated Duration:** 15-30 minutes

## Overview
Brief description of what this runbook accomplishes and when to use it.

2. Prerequisites

List everything needed before starting:

## Prerequisites

- [ ] VPN connected to production network
- [ ] `kubectl` configured for production cluster
- [ ] Access to PagerDuty admin console
- [ ] Slack channel #incident-response open

3. Symptoms / Triggers

When should someone use this runbook?

## When to Use This Runbook

**Symptoms:**
- API response times > 5 seconds
- Error rate exceeds 5%
- PagerDuty alert: "API Latency Critical"

**Triggers:**
- Customer reports of slow responses
- Automated monitoring alerts

4. Step-by-Step Procedure

The core of your runbook:

## Procedure

### Step 1: Assess Current State

Check the current pod status:

```bash
kubectl get pods -n production -l app=api
```

Expected output: All pods should show `Running` status.

### Step 2: Check Resource Usage

```bash
kubectl top pods -n production -l app=api
```

If CPU > 80%, proceed to Step 3. Otherwise, skip to Step 4.

### Step 3: Scale Up

```bash
kubectl scale deployment/api --replicas=5 -n production
```

Wait 60 seconds for pods to become ready.

5. Verification

How to confirm the procedure worked:

## Verification

Run the following checks to confirm resolution:

```bash
# Check pod status
kubectl get pods -n production -l app=api

# Verify response times
curl -w "%{time_total}\n" -o /dev/null -s https://api.example.com/health
```

**Success criteria:**
- All pods in `Running` state
- Response time < 500ms

6. Rollback

What to do if things go wrong:

## Rollback

If the procedure causes issues:

```bash
kubectl scale deployment/api --replicas=3 -n production
```

If rollback fails, escalate to @team-platform immediately.

## Related Resources

- [API Architecture Doc](/docs/api-architecture.md)
- [Scaling Guidelines](/docs/scaling.md)
- [Escalation Procedures](/runbooks/escalation.md)

Runbook Template Best Practices

Keep It Scannable

Use headers, bullet points, and code blocks. During incidents, people scan—they don’t read.

Include Expected Output

Show what success looks like. “You should see 5 pods running” is clearer than “Check the pods.”

Test Regularly

A runbook that hasn’t been tested recently is a runbook that might not work. Learn more about why runbooks fail and how to prevent it.

Version Control

Store runbooks in Git. Track changes. Review updates like code. For real-world inspiration, check out our runbook examples for DevOps teams.

From Template to Execution

A great runbook template is step one. Making it executable is step two.

Stew turns your runbook templates into interactive procedures. Each command runs with a click. Each checkbox tracks automatically. Your template becomes a living document.

Join the waitlist and make your runbooks executable.