Buyer Problems

How to Write a Project Update a Client Can Read in Two Minutes

Most project updates answer "what did we do this week" when the client only wants to know one thing: do I need to do anything right now. Here is the structure that answers that, and the one that doesn't.

Elena PrenticeElena Prentice7 min read
A mailbox with its red flag raised, signaling something needs attention.

I've sent hundreds of these. For the first few years I wrote them the way most agency people do: a list of what we did this week, in the order we did it. Built the nav. Fixed the form bug. Had a call with the vendor. Started on the pricing page. It felt like progress because it was progress. It was also, from the client's chair, nearly useless.

The person opening that email isn't trying to understand your week. They're trying to answer one question in the time it takes to read it: do I need to do anything right now. If the update doesn't answer that in the first two lines, you've made them read the whole thing to find out, or, more often, they skim it, miss the one line that needed a reply, and you hear about it three days later in a tone that suggests they think you buried it on purpose.

The question under every update

Clients don't actually want visibility into your process. They want to know whether this is one of the weeks they can close the email, or one of the weeks they need to make a call before Friday. A good update sorts itself into one of those two piles before the client finishes the first sentence.

That sorting is the whole job. Everything else, the activity list, the Slack-style play-by-play, the screenshot of a board mid-edit, is you narrating your own competence to someone who already hired you and doesn't need convincing. Worse, it trains the client to skim. A skimmed update is exactly how a decision you needed gets missed, and then it's a delivery problem, not a writing one.

A structure that answers it

Five lines, in this order. If a line has nothing to say, cut it. Don't pad it.

  1. Outcome, what is true now that wasn't true last update, in the client's terms, not yours.
  2. Evidence, the one proof point that makes the outcome credible: a number, a link, a screenshot, a test result.
  3. Current risk, the thing that could slow this down, named plainly, even if it isn't resolved yet.
  4. Decision needed, the specific choice only the client can make, or "none" if there isn't one.
  5. Next milestone, the date they should next hear from you, and what they'll see then.

Notice what isn't in there: completed tasks, internal tool names, who was on which call, how hard the week was. None of that helps the client decide anything. It helps you feel like you documented the effort, which is a different goal, and usually the wrong one for this particular document.

What it looks like when it's wrong

Here's a version I would have sent five years ago, lightly disguised:

“Hi team, busy week. We completed the sprint planning for the checkout flow, synced with the design team on the modal states, pushed three PRs to staging, and had a good call with your ops lead about the return policy edge cases. QA found a couple of issues we're tracking on the board. Let us know if you have questions!”

Read that again as the client. What changed? Is it on track? Do they owe you anything? You genuinely can't tell. "A couple of issues we're tracking" could mean a typo or a launch blocker, and the client has no way to know which. So either they ignore it and it was serious, or they ask you to clarify, and you've both spent a round trip getting to information the first email should have carried.

The same week, rewritten

Same work, same week, different document:

“Checkout flow is functionally complete and in staging, you can test it here: [link]. QA flagged one issue: returns on partial refunds don't yet match your current policy, and we need your ops lead to confirm before we can close it. No other open risks. Next update Thursday, when we expect sign-off on returns and a go/no-go for next week's launch.”

Shorter, and it says more. The client knows the outcome, checkout is functionally done. They have evidence they can click. They know the one risk, by name. They know exactly which decision is theirs and which isn't. And they know when to expect the next thing. If they're busy, they can act on one sentence, confirm the returns policy, and ignore the rest without guilt, because the rest genuinely doesn't need them.

A single sheet of paper held next to a thick, overstuffed binder on a table.
One page that says what matters beats a binder that says everything.

Why agencies default to the long version anyway

The activity-list update is easier to write under deadline pressure, because you can generate it by copying your own task list. It also does something subtler: it reassures the writer. If the client can see how much you did, the thinking goes, they'll trust the engagement is worth the invoice. But a client who has to infer value from volume of activity is a client who hasn't been told what matters, and eventually asks "is this on track?" anyway, which means the long update never did the one job it was supposed to do.

The five-line version makes you decide what the outcome, the risk and the decision actually are before you write anything. That's a few extra minutes of thinking per update. It also happens to be a decent forcing function for noticing when a project doesn't have a clear outcome yet, which is useful information for you, not just the client.

Where the template needs somewhere to live

The hard part isn't writing one good update. It's writing the tenth one, three months in, when the project has three workstreams and the client has stopped reading closely because nothing in the last four updates required them to act. At that point the structure only holds if there's somewhere the client can check the current state between updates, instead of waiting until Thursday to find out whether the returns decision got made on a Tuesday nobody mentioned.

That's a visibility problem before it's a writing problem, which is part of why we built guest access the way we did in Team and Tricks. A client added as a guest sees exactly the projects or tasks you grant them, nothing else, without taking a paid seat. If they want to know what's true right now, they can look instead of asking. And when a decision genuinely needs a sign-off, it can go through a request with an approval attached, so the "yes, go ahead" is sitting in a thread rather than scrolled past in someone's inbox. For the update itself, you can even have TAI draft the progress report from the task's checklist and chat first, and edit it down to the five lines before it goes out, the structure still comes from you, the typing doesn't have to.

The Thursday email is then free to do what it's actually for: flagging the one thing that needs the client, not restating what they could already see for themselves.

The template works whether or not you're running anything beyond email. It works because it answers the one question the client is actually asking. Everything past that is either evidence they asked for, or activity they didn't.

Continue Reading