Templates
Software engineering templates
Sketch a system and its data, write the design and the decision behind it, run an incident from timeline to postmortem, and plan migrations, rollouts and on-call handovers together.
89 free templates · Editable · Works with Claude and ChatGPT · Page 1 of 2
Software engineering templates 1–60 of 89
Incident postmortem
A blameless review: summary, what happened, five whys to the root cause and owned actions.
Bug triage board
A kanban for incoming bugs, from new to fixed, with a severity guide everyone agrees on.
Agent control room
Watch and steer an AI agent: it posts its plan, status and tasks here; you move cards and comment to redirect it.
Sequence diagram
A sign-in flow as UML lifelines, activation bars, calls, replies and an alt fragment.
Data model (ERD)
An online shop’s tables and how they relate, drawn with crow’s-foot ends.
System architecture
Users, apps, services, data stores and outside providers, with what talks to what.
CI/CD pipeline
From pull request to production across four lanes, with BPMN events, tasks and gateways.
Incident timeline
What happened when during an outage, from first alert to follow-up, with impact and lessons.
Architecture decision record
Context, options with pros and cons, the decision and its consequences, on one board.
System context sketch
The big picture of one system: who uses it, which other systems it talks to, and what flows between them.
Domain events workshop
Map a business process as the events that happen in it, with the commands, people and rules around each one.
API design review
Review a new API before it’s built: each endpoint’s purpose, inputs, outputs, errors and the questions reviewers raise.
Technical design doc
Lay out a technical design for review: context, goals and non-goals, the proposal, alternatives considered, risks and rollout.
Migration plan
Move data or traffic from an old system to a new one in safe, reversible steps, with a check before each step.
On-call handover
Hand the pager over cleanly: what happened this week, what’s still open, what to watch and what the next person needs to know.
Threat modelling session
Walk through what an attacker could do to a feature: what’s worth protecting, how it could be reached, the impact and the fix.
Service ownership map
Who owns each service, where its docs and dashboards live, how critical it is and who to call when it breaks.
Code review checklist
The questions a reviewer runs through on every change, agreed by the team, with examples of what each one catches.
Performance investigation
Work through a slowdown methodically: the symptom, measurements, a hypothesis, one change at a time and proof it helped.
Dependency upgrade board
Track library and framework upgrades from spotted to shipped, so security fixes and major versions don’t pile up.
Observability plan
Decide what to measure for a service: the question each signal answers, where it lives and when it should wake someone up.
Service level objectives
Agree reliability targets from the user’s side: the journeys that matter, how to measure them, the target and what happens when you miss.
Feature flag rollout
Roll out a feature behind a flag in stages, with who sees it at each stage, what you watch and when you move on or back.
Spike plan
Time-box a technical investigation: the question to answer, what’s in and out, the timebox and what you’ll hand back.
Data pipeline map
Follow data from where it comes from to where it’s used: each stage, its owner, the checks and how fresh it is.
Bug bash plan
Organise an hour where everyone tries to break a feature before launch: scope, roles, test ideas, how to report and prizes.
Incident response roles
Who does what when a serious incident starts: the incident lead in the middle, and the roles that support them.
Dashboard requirements
Before building a dashboard, agree who it is for, the decisions it should help with, the numbers it needs and how fresh they must be.
Data quality issue log
Keep a shared list of known problems in your data: what is wrong, which reports it affects, how bad it is and who is fixing it.
Data dictionary
Describe the fields in an important table in plain words: what each holds, where it comes from, its allowed values and its pitfalls.
Data request board
Track the data and reporting requests coming to your team, from new asks to delivered answers, so nothing waits in someone’s inbox.
Data source inventory
List every system your reporting pulls from, who owns it, how data gets out, how often and how much you trust it.
Data ownership and access
Agree who owns each kind of data, who may see it, how sensitive it is and how long you keep it, in one table everyone can read.
Metric drop investigation
Work out why a key number suddenly changed, step by step: is it real, where is it, when did it start and what caused it.
Tech debt register
Known shortcuts in the codebase with what each one costs today, the risk it carries and the fix you would make.
Service runbook
What an on-call engineer needs at 3am for one service: how to tell it’s broken, first checks, safe fixes and who to wake.
Release readiness check
A go/no-go review before a release: what is ready, what is still open and what must be true before you ship.
Error budget policy
Agree in advance what the team does as a service uses up its allowance for failure, from business as usual to stopping releases.
Game day plan
Plan a practice failure in a safe window: what you break, what you expect to happen, how you stop it and what you learn.
Alert review
Go through last month’s alerts one by one and decide which to keep, tune, turn into a ticket or delete, so pages mean something.
Postmortem action tracker
Follow the fixes agreed in incident reviews through to done, so the same failure doesn’t come back next quarter.
Disaster recovery test
Prove you can restore a system from backup in another place, time each step and compare it with the recovery time you promised.
Change freeze plan
Plan a quiet period around a busy date: what is frozen, what can still ship, how exceptions are approved and how you thaw.
Toil inventory
List the manual, repetitive work that keeps an operations team busy, measure what it costs each month and pick what to automate.
Dependency failure map
Put a service in the middle and ask, for each thing it depends on, what users see when it fails and how you would cope.
Load test plan
Plan a load test before a launch or peak: the traffic you expect, what you will simulate, what counts as passing and what you will watch.
Incident tabletop exercise
Walk a team through an imagined incident round by round, talking through what each person would do, to find gaps before a real one.
Access review
Check who can get into each important system and at what level, and remove what people no longer need.
Cloud cost review
Review where the monthly cloud bill goes, find waste and agree a few savings with owners, without hurting reliability.
On-call health check
Ask how on-call is really going for the people who carry the pager: load, sleep, support and what would make it fairer.
Infrastructure capacity forecast
Forecast when each key resource runs out at current growth, so you can order, scale or redesign before it becomes an outage.
Agent permissions review
Decide what an AI agent may do on its own, what needs a person’s approval and what it must never do, action by action.
Prompt iteration log
Keep track of how a prompt evolves: each version, what changed, how it did on your test cases and whether to keep it.
Agent incident review
Look into a time an AI agent got something wrong: what happened, why it happened, why checks missed it, and what changes.
Model option comparison
Compare AI model or tool options for one job on quality, cost, speed, privacy and fit, using your own test cases.
AI feature spec
Specify an AI-powered feature: the user and job, inputs and outputs, how it can fail, the guardrails and how you’ll measure quality.
Red team session
Spend an hour trying to make an AI feature misbehave: the attempts, what worked, how bad it was and the fix.
Golden test set
Build the set of test cases an AI feature must pass: realistic inputs, the expected answer, tags and why each case matters.
Agent run review
Step through one run of an AI agent: what it did at each step, whether it was right, and what to change in its instructions or tools.
Team dependencies board
Who is waiting on whom across teams, by when, and how healthy each hand-off is, so blockers surface before planning day.
Bring your team and your agents to one board
Free to use, open source, and yours to host. No credit card, no seat count.