The Answer Is in a Slack DM from 2023. Nobody Can Find It.

The answer to why the billing service charges at UTC midnight — not at the customer's local midnight, not at the org's configured timezone — is in a Slack thread from eighteen months ago. Four engineers were in that thread. Three of them remember the conversation. The one who remembers it most clearly left the company six months ago. The PM who needs the answer right now has searched Slack for twenty minutes and found 847 results for "billing UTC." The answer is in there somewhere. It might as well not exist.

Slack is an inbox, not a knowledge base. Messages are written with the assumption that the reader is present and in context. The thread that explained the UTC decision made complete sense on the day it was written — the participants knew what they were discussing, what constraints existed, what alternatives were rejected. Read eighteen months later by someone without that context, the thread is cryptic at best and misleading at worst. It was never written to be discovered. It was written to be read that day.

Why teams use Slack as institutional memory

Nobody chooses Slack as an institutional memory system. It happens because Slack is where decisions get made, and "write it down somewhere more permanent" is always a lower priority than the next thing. The decision gets made in a DM or a thread, everyone involved understands the outcome, and the documentation step that was supposed to follow never happens.

The engineers on the thread know the decision was made and don't need the documentation. The people who would benefit from the documentation — future engineers, non-technical team members, engineers on other teams — weren't in the thread and don't know to look for it. By the time someone needs the answer, the context is scattered across people's memories and a Slack thread that's functionally unfindable.

Where system knowledge actually lives in most teams:
  -> Slack DMs (unsearchable to most, archived and lost)
  -> Slack threads in channels (searchable but context-dependent, rotates out)
  -> Meeting recordings (unwatched after 2 days)
  -> Engineers' heads (leaves with them)
  -> Wikis (written once, stale within a sprint)
  -> JIRA comments (describes the ticket, not the system)
  -> Code comments (partially useful, often outdated)
  -> The codebase itself (accurate, always current, not queryable without tools)

What happens when institutional knowledge isn't recoverable

Teams with large amounts of knowledge locked in Slack make decisions in a vacuum. A new engineer changes the billing charge timing without knowing why it was set to UTC midnight — and creates a customer-impacting bug that takes three days to trace back to a decision made before they joined. A PM proposes a feature that was discussed and rejected eighteen months ago for reasons nobody remembers, and the engineering time to evaluate it is spent re-arriving at the same conclusion.

The cost of undiscoverable institutional knowledge is not dramatic and visible — it's diffuse and invisible. Decisions get re-made. Mistakes get repeated. Context that would have prevented a wrong turn never arrives in time because nobody knew it existed.

Why Slack search doesn't recover tribal knowledge:
  "Why does the billing service charge on UTC midnight?"
  -> Search: "billing UTC midnight" → 847 results
  -> Correct thread: from 14 months ago in #platform-eng
  -> Finding it: 20–40 minutes if you know it exists
  -> Finding it if you don't know it exists: effectively impossible
  -> For someone who joined after the thread: genuinely inaccessible

  The answer existed. It was written. It's gone.

What the codebase preserves that Slack doesn't

The codebase preserves the outcome of every decision. The billing service charges at UTC midnight because that's what the code does — and the commit that introduced it has a commit message, a PR description, and potentially a linked Jira ticket. The reasoning may be partial, but it's attached to the code change rather than buried in a chat thread. The context that survives organizational change is the context attached to the artifact that also survives.

When codebase queries replace Slack searches for system behavior questions, the answer quality improves. Kognita surfaces what the code does now and the recent commit history around it. This doesn't recover the full verbal context from eighteen months ago — but it answers the factual question accurately, which is usually what someone needed in the first place.

Final take

Slack is where decisions happen. It is not where knowledge lives. The distinction matters because decisions need to be findable for years, and Slack search fails at that task by design. The codebase is not a perfect institutional memory — it shows what was decided, not always why. But for factual system questions, it's orders of magnitude more reliable than searching for a thread from two years ago. That's the knowledge worth preserving and surfacing.

The answer to your system question was written once. It's in a Slack DM. You'll never find it. The codebase has a partial answer that's current and accurate. Start there.