Last time almost this time of last year in 2025, the article made the case for Excel as the consultant's quiet advantage — clarity over complexity, tables over dashboards.

This time, the same tool shows up somewhere less obvious: not making ideas easier to present, but keeping a team's memory straight when a design decision has passed through too many hands to trust.

Five places. Five versions of the truth.

• A walkthrough

• A Figma comment

• A Teams thread

• An unminuted call

• A delivery partner's own running doc

Feedback scattered across all five — and somewhere in the middle of this, a stakeholder was frustrated, loudly, because the screens still didn't reflect what they were "sure" they'd already said.

Which version is actually agreed?

No one could quickly confirm what was actually decided. And when no one can confirm that fast, the heat doesn't land on the process. It lands on the designer holding the file. There's one phrase that captures it: Business is frustrated.

If this scene feels familiar, it should. Most designers working on enterprise projects have sat in that exact seat at least once — there's no denying it.

This isn't an article about Excel being clever. It's about what happens when a good idea has passed through enough hands that nobody remembers which version is real — and why one plain, boring artifact is usually what saves the project.

The Problem

Every enterprise design project reaches this point. Not because anyone did anything wrong — because enough people cared enough to weigh in.

And in most rooms, one voice carries more weight than the rest. It's rarely the loudest title in the room — enterprise app reviews don't usually run on hierarchy alone. It's mostly the know-it-all: the one who's read everything, who's usually right, and who's stopped listening because being usually right stopped feeling like a reason to check. They remember a decision a certain way and state it with total conviction. The room defers — not because it's accurate, but because it's assertive, and assertive is easy to mistake for correct when nobody has a faster way to check.

That's precisely when group memory silently skews. The version that survives isn't the one that's true — it's the one delivered with the most confidence, regardless of which of the five places it actually came from.

Didn't we already decide this?

That question — asked in some form, in nearly every project — is the tell. It means the team is no longer designing. It's re-litigating, usually against whichever voice spoke last with the most conviction, with the designer left to arbitrate.

The Shortcut

The instinct is always the same: fix it with a better tool. A sleeker dashboard. Another Jira board. A new "single source of truth" platform that promises to finally get everyone aligned.

Someone sets it up. A few people use it for a week. Then Figma comments come back, because that's still where the actual conversation about the actual screen happens. The new tool becomes one more place to check. Place six.

The gap was never the software. It was the habit of checking one place before assuming your version was the current one.

The Assumption Gap

Here's what nobody stopped to ask before reaching for a new tool: does this need a smarter system, or does it need one artifact people will actually open first?

What if the fix wasn't smarter software — just fewer places to look?

That question sat for a while. It doesn't get answered with a platform migration. It gets answered by watching what a team already trusts enough to check before anything else — and building there instead of somewhere new.

For one project drowning in exactly this — five places, one contradicted screen, and a know-it-all voice who kept overriding the record with unwavering certainty — the answer turned out to be a spreadsheet nobody had to be trained on.

The Consequence

Three columns doing the real work. Observation. Viewpoints logged, dated. UX resolution note.

The resolution note is where it actually pays off. Take one row from that Excel tracker:

Anyone landing on that row, regardless of which of the three conversations they'd been in, could see not just what was decided but why the 4th's version didn't hold — something solid to point to instead of relitigating it.

The disagreement wasn't the problem. Losing track of when it changed was.

Not exciting. Not a platform. Just a tracker that linked every piece of scattered feedback to one agreed outcome, updated the moment a decision actually landed — not the moment someone claimed it had.

The shift wasn't in the tool. It was in the question the team started asking. Before: didn't we already discuss this? After: what's the current agreed direction — and what changed it?

And when the know-it-all in the room stated a decision that didn't match the row on the sheet, the team finally had something steadier than conviction to point to. Not a confrontation — just a dated column and a simple timeline everyone could check before agreeing.

Same team. Same stakeholders. Same volume of feedback. One place it all had to pass through before it counted as decided.

The Real Cost

Five places of contradicting feedback, collected over time, collapsed into rows that took seconds to scan — not because Excel is powerful, but because a stakeholder under pressure needs an answer they can read at a glance, not a thread to reconstruct.

Rows and columns don't ask anyone to interpret. They just show what's true, right now.

Modern platforms genuinely solve real problems here — live sync, automation, integrations across dev and design and delivery. That's not in question. But adoption fails when a tool asks people to change behavior before it's earned their trust. A frustrated stakeholder isn't going to learn a new interface mid-meeting — they're going to ask the nearest person, usually the designer, who needs an answer fast, not a login. Or the frustration spills over.

The tracker won for a reason that has nothing to do with Excel's feature set. It asked nothing of anyone. It just answered one question, in a format everyone already knew how to read on sight.

Governance isn't documentation. It's reducing ambiguity fast enough that the next heated comment has somewhere accurate to land. And that's where the Excel tracker does the job well.

The Newest Version of the Shortcut

Today there's a newer temptation, and it's more persuasive than another dashboard: AI meeting agents. They record and transcribe every review, call, and walkthrough — searchable, indexed, seemingly solved.

But recording a conversation isn't the same as reaching a decision. A full transcript holds every side-comment and half-formed idea, right alongside what actually mattered. Finding the line that's the current, agreed position — the way the "View" link moved from cut, to reinstated, to referenced-but-not-resolved — takes someone reading with intent. A summary doesn't know which viewpoint should win. It just knows what was said.

Left unchecked, more captured audio just becomes a sixth place to contradict the other five.

The resolution note in that tracker didn't come from a transcript. It came from someone who understood the review logic well enough to know which viewpoint held — and wrote that down in one sentence a room could trust. That's judgment. Automation can index every word and still leave a team no closer to knowing what was actually agreed.

And when there's a disconnect between conflicting threads, the tracker wins again — for the same reason it always did.

The Question Worth Carrying

Back to that room — five places, one contradicted screen, and a designer absorbing the frustration that should have been distributed across the whole team's memory, not just one person's inbox.

Nielsen Norman Group has long argued that shared documentation of why a decision was made — not just what was decided — is what lets teams move faster with more confidence. The tracker did exactly that: it held the reasoning, not just the outcome, which is the one thing a confident voice in the room can't out-argue.

So the next time a decision starts drifting across five places, the real question isn't which tool to add.

It's this: is your team missing a tool — or missing the one place everyone already trusts enough to check first?

Design decisions rarely fail from bad ideas. They fail from bad memory.