Align your technical team around one board.
Runboard is a framework for CTOs and engineering leaders. It turns everything your team is doing into one holistic view — so you can focus effort and budget where they’ll be most effective, and the whole organisation runs smoother.
Fresh from the blog.
New thinking on running a technical organisation — published on Substack, the plain-writing companion to the framework.
A board, not a list.
Most guidance for technical leaders is a list — responsibilities to cover, boxes to tick. A list never tells you where you’re stuck; a board does. Nine boxes: the three kinds of work you’re always doing, against the three levers you can actually pull.
Spread build knowledge past the one architect — pairing, design docs, a real second owner.
Automate the path to shipping: build-test-ship pipelines, environments from a script, tests.
Ship without queuing: staged rollouts and one-click undo so releases don’t wait on sign-off.
No single person holds an outage together: on-call rotations, runbooks, named practising backups.
The system watches itself: monitoring, alerts before customers notice, automatic recovery.
Pre-agreed limits for routine ops: spending caps, change windows, blast-radius rules.
Translation isn’t one person’s job: more than one voice can speak tech to the business.
Make the trajectory visible: dashboards that pull the signals together for the board on their own.
Decide direction without endless meetings: a written decision policy, disagree-and-commit.
One shared picture.
You, the team, and the board you answer to argue from the same grid — not three different maps of where the trouble is.
Diagnose before you spend.
Name the kind of problem first. The dear mistakes are fixing the wrong kind — buying a tool for what’s really a people problem.
Raise the box that’s holding you back.
You can’t fix nine at once. Find the one slowing everything down, raise it, move on before it becomes a crisis. That’s balance.
Three ideas that are really one machine.
Pull any one out and the other two stop working. That’s the whole philosophy — everything else is just applying it.
Measure, so you can see which way you’re heading.
You can’t steer what you can’t see, and most teams are flying blind in ways they’ve stopped noticing. Measuring turns opinion into something you can look at.
Build guardrails, so people can act without queuing at your door.
You became the place decisions go to wait. The fix isn’t to decide faster — it’s to build things ahead of time that make most decisions safe to make without you.
Keep the work in balance, so speed doesn’t burn down the system.
A team moves at the speed of its slowest necessary part — and the slowest part keeps changing. Notice what’s holding you back now, fix that, move on.
Three things you can actually change.
There are only three levers in any team. Each is the same move, aimed at a different kind of stuck. Start with whichever is holding you back most.
Every hero is a bug.
Knowledge and authority trapped in people. The fix is a role: work pulled out of the one person who does it, so it survives when they don’t.
BUILD a role → ToolsTake the human out of the loop.
Work done by hand, and problems you can’t see. The fix is automation: get the machine to do the work, and to watch the work.
BUILD an automation → TechniquesSpeed is a default you engineer.
Decisions that wait for approval. The fix is a guardrail: built ahead of time so a wrong call breaks only a little — small enough nobody signs off.
BUILD a guardrail →It’s also a tool you can run.
Runboard isn’t only a way of thinking — it’s a command-line tool that scores the same nine boxes on your own machine in about five minutes. Local-first, no signup, nothing leaves your laptop.
Zero install — npx fetches it on demand. Scaffold, run the
self-assessment, and read your board.
npx runboard@latest init # scaffold .runboard/ in your repo
npx runboard@latest assess # guided nine-dimension self-assessment
npx runboard@latest board # your heatmap + biggest constraintDrive the same assessment conversationally — the Runboard MCP server runs locally over stdio. Add one entry to your client:
{
"mcpServers": {
"runboard": {
"command": "npx",
"args": ["-y", "runboard", "mcp"]
}
}
}
Local-first by design — no account, no network calls, no telemetry. Your data lives in
.runboard/ in your own repo; commit it and its git history becomes
your trajectory record.
Run the board.
New writing on running a technical organisation — plain, opinionated, no filler. Every couple of weeks.