runbooks

Self-hosted · source-available · FSL-1.1-MIT

Prod broke? Runbooks help.

A runbook is the step-by-step procedure you follow when something breaks in production. Runbooks turns a directory of Markdown files into interactive versions of them: files are the content, the path is the sidebar, and a ## heading is a tickable step. No database, no CMS, no authoring UI.

Read the docs View the source 
docker run -d --name runbooks \
  -p 8090:8090 \
  -v "$PWD/content:/app/content" \
  -v runbooks-data:/app/data \
  ghcr.io/runbooks-help/runbooks:latest

In production at

Built for the moment you need it

Files are the content

A runbook is Markdown with frontmatter. You edit files in your editor and commit them; the app reads a directory at runtime, so a content change needs no rebuild and no redeploy.

Steps, not walls of text

A ## heading is a numbered, tickable, collapsible step, or an unnumbered section when you want reference prose. One page can mix both.

Readable under duress

Symptom-first titles, collapsible steps, code blocks with a per-block done box, decision callouts, a rollback section, and a Zen mode that shows one step at a time.

Inputs that never leave the page

Frontmatter vars become {{TOKEN}} substitutions inside code blocks, filled in the browser: substituted client-side and never sent to the server.

Notes and a timeline

Ticking a step records a timestamped line in the notes panel. Export them, or sync them to a git repo you own.

An agent surface

Every page is raw Markdown at /<slug>.md, indexed at /llms.txt, with a full-body search API, so LLMs and scripts read the same runbooks you do.

The runbook gets less wrong

Most tools assume a runbook is correct once it is written. It isn't. The system moves, the edge case never came up, and the author guessed. So the question is not is the runbook right? It is how fast does it get "less wrong", and can it self-correct?

Capture

Ticking a step writes a timestamped line to the notes, so every run leaves a trace. Keep it local, or sync it to a git repo you own.

Review

Point an agent at the runbook and its notes. It suggests classified changes: a step to fix, a lookalike to add, an environment fact to generalise, or a note that is not the runbook's job at all.

Revise

You decide and edit. The reviewer suggests; it never rewrites a procedure on its own. Each run leaves the runbook a little less wrong.

A symptom also looks like other things. A lookalike records what else it resembles, and how to rule it out, so the next person spends a query instead of twenty minutes. Read why.

See it

Vars dialog, ticking a step's blocks until it rolls up, the notes timeline, a decision callout, Zen.
docker run, a mounted content/, and /llms.txt answering.
/llms.txt, a raw /<slug>.md, and the search API.

Your knowledge, your infrastructure

Runbooks is one Go binary in a container. It reads your content/ directory, holds no database unless you turn on identity, and has no phone-home. Backups are files; content is portable Markdown.

Passkey (WebAuthn) sign-in is built in and free. It is off by default (a public runbook site needs no accounts), and when on, identity lives in SQLite, MySQL or PostgreSQL behind a small interface with no foreign keys.

Not for everyone, on purpose

Runbooks is for solo operators, small teams and game studios who keep their operational knowledge in files.

Not for you if you have a procurement team. No enterprise tier, no MSA process, no "Book a demo".

Editions

One codebase, three ways to play it. The built software is the whole product: nothing is withheld, whatever you pay.

Open

Free

The whole self-hostable app: git sync, passkey identity, proxy auth, the agent surface. Source-available, buildable, yours.

Get started

Honour mode

£20 per major

Gates nothing. Every build is public and we sign the releases, so paying buys the honours: a spot on the supporters page and the badge for the current major. It funds the work.

Buy honour mode

Hosted

£20 / org / month

We run it, including identity and the organisation layer (SSO/OIDC, RBAC, org-scale audit export). Unlimited seats.

Coming soon

Source-available under FSL-1.1-MIT: free to self-host, modify and use commercially, with no competing-use right, converting to MIT two years after each release.

FAQ

Click a question to open it.

How does a runbook stay correct?

It doesn't stay correct, and no runbook does: the system moves, and the edge case you hit was never written down. Runbooks treats that as the norm. Ticking a step records what you did; point an agent at the runbook and its notes and it suggests classified changes; you decide and edit. Every run leaves the runbook a little less wrong. Read why.

Why is Runbooks source-available rather than open source?

The licence has to do one thing an OSI licence cannot: stop someone reselling Runbooks as their own service. The AGPL does not, because the source is already public and a hyperscaler can run the unmodified code. The Functional Source License prohibits that competing use directly while leaving everyone else alone. It is source-available, not open source, and we describe it that way on purpose.

Can I use Runbooks at work?

Yes. Use it, modify it, self-host it, run it commercially for your own purposes. The only restriction is offering it as a product or service that substitutes for Runbooks.

Will it ever be open source?

Every release converts to MIT two years after it is published. Nothing stays locked forever.

What do I actually get for paying?

Nothing functional, on purpose. Every build is public and we sign the releases, so honour mode gates nothing: the software runs identically whether or not you pay. Paying earns the honours, an opt-in place on the supporters page under a name you choose, and the badge for the current major. You stay on the list once you have supported; the badge lapses when the next major ships, and renewing carries it on. It is how you say thank you and fund the work.

Why don't you accept pull requests?

Runbooks is maintainer-led, not community-led. Issues and discussions are open and welcome; we close unsolicited pull requests with a pointer to the policy, stated publicly so it is a policy rather than a snub. Reviewing other people's patches is the hidden cost that sinks small projects, and it is the cost we decline on purpose.

Can I contribute?

Rarely, and by invitation after a discussion. Invited contributors sign a CLA so copyright, and therefore the ability to enforce the licence, stays whole. Contributing grants no maintainership and no say over the roadmap.

Does Runbooks phone home?

No. It is one binary with no telemetry. Runbook variables are filled in and substituted in your browser and never sent to the server.

What happens if the project is abandoned?

We release all the source, including anything that was hosted-only. That pairs with the two-year MIT conversion: the source cannot stay closed regardless.

Can I use the name and logo?

The licence grants no rights to the Runbooks name or brand; a trademark policy governs how forks may use them.

Why is there no enterprise tier?

Because we do not want one. Large enterprises are out of scope by choice: no procurement, no on-prem SSO, no "Contact Sales". That is a service decision, not a licence term. The licence lets anyone use the software, including a large company; we simply will not sell to or support one.