Retro Setup Eats 10 Minutes Every Sprint: A Lighter Tool
By: Evgeny Padezhnov
Sprint ends. Someone schedules the retro. Then ten minutes vanish before anyone writes a single note.
Heavyweight whiteboard tools carry a setup tax. The board loads slowly. A template needs picking. A guest hits a permission wall and pings the host on Slack. The retro itself is simple: three columns, some notes, a few votes. The tooling around it is not.
This is a case study in cutting that tax. The result is a single-purpose corkboard for the web. Built for one job: run a retro, fast, then get back to work.
What a retro actually needs
A retrospective has a tiny feature set. Strip away the marketing pages and the requirements fit on an index card.
- Three columns. Usually "Went well", "Needs work", "Actions".
- Sticky notes anyone can add.
- Anonymous entry, so junior people speak freely.
- Voting, to surface the top issues.
- A shared cursor or live updates, so the board feels alive.
That is the whole product. The Atlassian retrospective play describes the same shape: collect, group, vote, decide. No connectors. No mind maps. No infinite canvas.
Common mistake: treating a retro tool like a general whiteboard. General whiteboards optimize for drawing anything. A retro optimizes for one ritual that repeats every two weeks. Different problem.
Key point: the setup friction comes from generality. A tool that does one thing needs no template picker, no onboarding, no project hierarchy. Open a URL. Start typing.
The build: one process, no pipeline
The corkboard runs as a single Node process. No build step for the backend. No bundler config marathon. The frontend is plain HTML, CSS, and a small amount of vanilla JavaScript served as static files.
State lives in memory and syncs over a WebSocket. A note is a flat object:
const note = {
id: nanoid(), // stable client-generated id
column: "went-well", // went-well | needs-work | actions
text: "",
author: "anon-3f", // random per-session handle
votes: 0,
updatedAt: Date.now(),
};
Client-generated ids matter. The browser creates the note, draws it immediately, then tells the server. No round trip before the note appears. The interface never waits on the network to feel responsive.
The server is a relay plus a store. It keeps the current board and rebroadcasts every change.
import { WebSocketServer } from "ws";
const wss = new WebSocketServer({ port: 8080 });
const board = new Map();
wss.on("connection", (socket) => {
// new client gets the full board once
socket.send(JSON.stringify({ type: "sync", notes: [...board.values()] }));
socket.on("message", (raw) => {
const msg = JSON.parse(raw);
if (msg.type === "upsert") board.set(msg.note.id, msg.note);
if (msg.type === "delete") board.delete(msg.note.id);
broadcast(raw, socket); // fan out to everyone else
});
});
function broadcast(raw, sender) {
for (const client of wss.clients) {
if (client !== sender && client.readyState === 1) client.send(raw);
}
}
That is the core. Around 40 lines do the real work. The MDN WebSocket API covers the client side in full. A new participant receives one sync message, then incremental updates.
In plain terms: the server is a dumb pipe with a memory. Browsers do the rendering. The network carries small JSON messages.
Deployment is a single command on a small VPS:
node server.js
# or under a process manager
pm2 start server.js --name corkboard
No database server. No container orchestration. A 1 GB box handles a team retro without strain.
Real-time sync without a CRDT
The first instinct was to reach for a conflict-free replicated data type. Yjs is the obvious choice for collaborative editing. It handles concurrent edits to shared text cleanly.
For a retro corkboard, it was overkill. Two people rarely edit the same sticky note at the same moment. They each write their own. Conflicts are the exception, not the rule.
Last-write-wins solved it. Each upsert carries updatedAt. If two updates race, the later timestamp wins. The loser sees the winning version on the next broadcast. No merge algorithm. No vector clocks.
Text editing on a single note got one refinement. Instead of broadcasting every keystroke, the client debounces. It sends the note 300 ms after typing stops. Fewer messages, no flicker on other screens.
let timer;
input.addEventListener("input", () => {
note.text = input.value;
clearTimeout(timer);
timer = setTimeout(() => send({ type: "upsert", note }), 300);
});
Tested in production with a distributed team across three time zones. Last-write-wins never caused a lost note in normal use. The simpler model held.
This is the trade-off worth naming. CRDTs win when many users edit shared prose concurrently. Retros do not have that pattern. Matching the tool to the actual access pattern removed a large dependency.
What broke, honestly
Several things failed on the first pass. Practice shows the failures teach more than the wins.
In-memory state died on restart. A deploy wiped the board mid-retro once. The fix was a periodic snapshot to disk. Every 10 seconds the server writes the board to a JSON file. On boot it reads the file back.
import { writeFile, readFile } from "node:fs/promises";
setInterval(async () => {
await writeFile("board.json", JSON.stringify([...board.values()]));
}, 10_000);
SQLite was considered. For a single board that resets each sprint, a flat file was enough. Adding a database would have been complexity without a payoff.
Drag events flooded the socket. An early version sent the note position on every mousemove. With four people moving notes, the server drowned in messages. The fix was to send position only on drop, not during the drag. The local screen animates smoothly; the network sees one update per move.
Anonymous voting was gameable. Without accounts, one person could vote many times. The accepted answer was a per-session vote limit stored client-side. It is not tamper-proof. For a team that trusts each other in a room, it is enough. Real auth would reintroduce the friction the whole project removed.
Scope creep started immediately. Requests arrived for shapes, arrows, colors, image upload. Each request was reasonable. Together they would rebuild Miro. The board shipped with columns, notes, and votes only. Saying no kept the setup time near zero.
Common mistake: adding persistence and auth before knowing they are needed. The board ran for weeks before the snapshot was added. The restart bug proved the need. Building it earlier would have been speculation.
The result
The setup tax dropped from minutes to seconds. Open the URL. Share it in the channel. Everyone is on the board, anonymously, before the first note would have loaded in the old tool.
The numbers that matter are small and concrete. One Node process. One JSON file for state. Roughly a few hundred lines total across server and client. No login. No template. No build pipeline for the backend.
If it works — it is correct. The corkboard does less than a commercial whiteboard on purpose. The narrow scope is the feature. Every removed option is one less decision during a meeting that should already be short.
In practice, the deeper lesson is about scope, not code. The slow part of the retro was never the discussion. It was the tooling overhead before the discussion. Cutting features cut the overhead.
What to try right now
Pick the next retro and time the setup. Start a stopwatch when the meeting opens. Stop it when the first real note gets written. That gap is the tax the team pays every sprint.
If the gap is large, the fix does not require building anything first. Try it: open a shared document with three headings and let people type under each. No drag, no votes, but zero setup. Measure the same gap again.
If the lightweight version works, the case for a heavyweight tool weakens on its own. Build the corkboard only when the plain document hits a real limit, such as voting or anonymity. Let the limitation justify the code, not the other way around.
Information is accurate as of the publication date. Terms, prices, and regulations may change — verify with relevant professionals.