This article comes from a real project retrospective. Client information has been anonymized. It names no specific company, industry or date, and keeps only the facts that taught us something worth sharing.
A corporate client expanding into overseas markets asked us to build an enterprise knowledge base and organize its content. The brief sounded clear: take questions and answers scattered across documents, spreadsheets and the experience of long-serving staff, and turn them into an accurate, consistent, searchable body of knowledge for everyday internal use.
We started the way we knew best: inventory the existing material, verify every fact, standardize terminology and formatting, fill in what was missing, and deliver in batches for acceptance. Thousands of Q&A entries were checked one by one, and hundreds of source documents were reconciled. By the acceptance stage, every item on the checklist passed — the content was accurate, the formatting was consistent, and nothing was late.
By our own account, this was a solidly executed project.
At the time, the team was even discussing how to replicate the approach on the next project. Looking back, that confidence was precisely the danger: we trusted our own method so much that nobody asked one more question — who exactly is this method serving, what does their day look like, where do they get stuck, and when would they rather bypass what we built and go ask a veteran colleague instead?
Everything passed. The meeting said no.
At the formal acceptance meeting, the client lead spent a long time reading, then said, in effect: “It is all correct — but this is not what we wanted.”
It was an uncomfortable moment, and a hard one to argue with. Against the contract and the acceptance checklist, we had not actually failed any item. But the expression across the table was telling the truth, too.
Afterwards, instead of explaining ourselves, we walked the whole project back: how the requirements were set, who confirmed what along the way, who wrote the acceptance criteria, and who was supposed to use the result. Only then did it become clear that the problem was not whether the content was right. It was that we had misunderstood what “delivery” meant from the very beginning.
Three misalignments: we delivered correctness, not usability
1. We delivered “correct content”; the client needed something frontline staff would dare to use
We had spent most of our energy on accuracy: no wrong answers, no conflicting wording, no messy formatting. All of that matters. But the people meant to use this knowledge were frontline staff in live working situations. They were not facing an exam question — they were facing a customer waiting for a reply, or an on-the-spot judgement that had to be made immediately.
What they needed was not just the right answer, but also: how fast can I find it, which entry applies in which situation, and what do I do when nothing covers my case? We had designed for none of those real usage scenarios. The content was correct sitting in the repository. At the point of use, nobody felt confident enough to act on it directly. Correct content that nobody dares to use is worth zero.
2. The acceptance criteria measured documents, not business outcomes
Our acceptance criteria were thorough — but they were all about the document layer: enough entries, accuracy on target, formatting consistent. We met every one of them. Yet they could not answer the questions the client actually cared about: have frontline staff got faster at finding an answer? Has the share of questions answered correctly the first time gone up? Are fewer people coming back to ask the same question twice?
When the standard is wrong, the harder you work, the further you drift. We were measuring a business outcome with a ruler made for documents.
3. Throughout the project, we worked with the liaison — never with the actual users
Looking back at the communication record, we had worked mainly with the client’s IT and project contacts. They were professional and diligent, and they confirmed everything they were asked to confirm. But there was one group we never truly interviewed from start to finish: the frontline employees who would use this knowledge every day.
We knew nothing about how they search, where they most often get stuck, or what makes them hesitate before sending an answer out. The requirements grew in a meeting room, not at the point of use. That sentence at the acceptance meeting — “this is not what we wanted” — was, in effect, the end users speaking up for the first time. It just happened to arrive on acceptance day.
What we changed after this retrospective
The lesson was not cheap. Afterwards, we formally redefined delivery — from “content delivered” to “outcomes delivered” — in three hard rules:
- Define the users and the scenarios before producing any content. Before any knowledge or content project starts, it must answer: who uses this, in what situation, to accomplish what task, and by what standard will we judge whether it works? Without that step, nothing gets scheduled.
- Align acceptance metrics with the business side before the contract is signed. Alongside content metrics such as accuracy and completeness, business outcome metrics must be written in — lookup time, first-time-right rate, actual usage after launch — and confirmed by the business owners, not only by the liaison function.
- Revisit real usage data 30 days after launch. Delivery is not the finish line. A month after go-live, we review actual usage: which entries are used constantly, which were never opened, and where users worked around the system. Those findings drive a second round of fixes, and only then is the project truly closed.
Correctness is only the entry ticket. Clients never pay for “correct” itself. They pay for outcomes.
That sentence now sits on the first page of every project we start. It reminds us that a technology-led delivery naturally puts “we got it right” first, while a customer-value-led delivery has to put “did things actually get better for the people using it” first. The two differ only in the order of the questions you ask — but that order decides whether, at the acceptance meeting, you hear a signature, or “this is not what we wanted.”
If your team is building a knowledge base, content system or AI application, it is worth asking three questions at your next kickoff: who are the real end users? Do your acceptance criteria measure documents, or business outcomes? And 30 days after launch, who is responsible for coming back to check whether anyone is actually using it?
