Watch what happens the moment a card slides into the Done column. Shoulders drop. Someone says “nice.” The task is, in everyone’s mind, over. And then three days later a client emails asking where the thing is — and it turns out it was never actually sent, deployed, reviewed, or whatever the real finish line was. The card said Done. The work wasn’t.
If that sounds familiar, your Done column is lying to you. Not maliciously — it’s just answering a different question than the one you think you’re asking. You think Done means “the customer has this and it works.” Your team, quite reasonably, reads it as “I finished my part and pushed it along.” Those are not the same thing, and the space between them is where deadlines quietly rot.
What “Done” Usually Means (and Why That’s a Problem)
On most boards, Done is defined by whoever drags the card there. A designer calls it done when the mockup is exported. A developer calls it done when the code is written. A writer calls it done when the draft is saved. Each person is telling the truth about their own slice — but nobody owns the question of whether the whole thing is actually finished and in the hands of the person who needed it.
So you get cards parked in Done that are really “done-ish”: done except it hasn’t been reviewed, done except it isn’t published, done except the client hasn’t signed off, done except nobody told the person waiting on it. The column fills up and looks like progress. Meanwhile the real work — the last unglamorous mile — sits in a blind spot because, officially, there’s nothing left to do.
The danger isn’t just the occasional dropped ball. It’s that your board stops being trustworthy. The whole point of a kanban board is to show the true state of your work at a glance. The second Done means six different things, you can no longer trust it, and you’re back to chasing people in chat to ask “wait, is that actually finished?”
The Real Finish Line Lives in the Handoff
Here’s the uncomfortable truth: most things go wrong after someone declares their part done. The code is written but not deployed. The invoice is approved but not sent. The article is drafted but not scheduled. The work didn’t fail in the doing — it failed in the handing-off, in that quiet gap where one person considers it finished and the next person doesn’t even know it’s their turn yet.
A card in Done should answer one question honestly: is there anything left for anyone to do before the person who asked for this gets what they wanted? If the answer is “well, someone still has to publish it,” then it isn’t done. It’s waiting. And waiting work deserves to be visible, not hidden behind a reassuring green column.
Give “Done” a Definition Everyone Shares
The fix is almost embarrassingly simple: write down what Done actually means, as a team, and make a card prove it before it’s allowed in. This is your definition of done — a short, shared checklist of exit criteria that turns a vague feeling into an agreement.
It doesn’t need to be elaborate. For a small content team it might be:
- Drafted and edited
- Reviewed by one other person
- Published (or scheduled) and the link verified
- The person who requested it has been told it’s live
For a dev team it might be code reviewed, merged, deployed to production, and confirmed working. For a client services team it might be delivered, client acknowledged, and invoiced. The content changes; the principle doesn’t. A card only crosses into Done when every box is ticked — no “I’ll do that last bit later.”
Two things make this stick. First, keep it short — four or five items, not a novel. A definition of done nobody remembers is just decoration. Second, keep it visible. Pin it right next to the board, or drop it into the card template so the checklist rides along with every task. On a digital board you can put those exit criteria straight onto the card as a mini-checklist, so “done” becomes something you can see rather than something you assume.
When the Honest Answer Is a New Column
Sometimes writing down your definition of done reveals that there’s a whole stage of work you’d been pretending didn’t exist — the review, the verification, the sign-off. If that stage regularly holds cards for a day or more, don’t bury it inside Done. Give it its own column.
A thin lane between Doing and Done — call it Reviewing, Verifying, or Ready to Ship — does something quietly powerful: it makes the last mile visible. Now you can see at a glance that three cards are finished-but-not-verified, and nobody mistakes them for delivered. It also exposes a surprisingly common bottleneck, because “waiting for review” is where a lot of teams secretly lose the most time.
You don’t want to overdo this. Every extra column is extra overhead, and a board with eleven stages is its own kind of lie. But one honest column that reflects real work beats a tidy Done column that hides it.
The Takeaway
A Done column is only as useful as the agreement behind it. Left undefined, it drifts into meaning “I did my bit” — and your board slowly stops telling the truth. Spend twenty minutes with your team writing a short, shared definition of done, make it visible on every card, and add a column only where real waiting work is hiding.
Do that and Done starts meaning what you always assumed it did: this is finished, it’s delivered, and nobody needs to chase it. That’s the whole promise of a simple kanban board — not more columns, just columns you can actually trust.