What we learned putting Jira, GitHub, and Slack behind one search box

The question that started this was boring: "Why did we switch the payment retry logic from exponential backoff to a fixed interval?"

A teammate asked it in a stand-up. Nobody remembered. The person who made the change had left. It took someone forty minutes to reconstruct the answer, and the answer was sitting in plain text the whole time — one sentence in a Jira comment, a longer version in the pull request description, and the actual debate in a Slack thread from a Tuesday afternoon four months earlier.

None of those three tools is bad at its job. The problem is the seams between them. Jira knows what changed. GitHub knows how. Slack knows why. Nobody owns the sentence that ties all three together, and so that sentence doesn't exist anywhere you can search for it.

What we built

The idea was not clever. Pull everything into one place — Jira issues and comments, GitHub repos and PRs, Slack messages, meeting transcripts, Confluence and Notion pages — turn it into a searchable index, and let people ask questions in plain English instead of guessing keywords in four different search boxes.

The part that took real work was making the answers trustworthy. An answer with no source is just a confident guess. Every response the system gives now points back to the specific ticket, comment, or message it came from, so you can click through and check. If it can't find a source, it says so. That single rule — cite or admit you don't know — did more for adoption than any amount of model tuning.

What surprised us

Most questions are archaeology, not lookup. We assumed people would ask "what is the rate limit on the export endpoint." They mostly ask "who decided the rate limit should be 100, and what were they worried about." The valuable data isn't the current state of the system — that's in the code. It's the reasoning that produced the current state, and that reasoning lives in comment threads.

People stopped interrupting each other. The clearest signal wasn't a dashboard metric. It was that our busiest engineer's Slack DMs got quieter. Questions that used to start with "quick q, do you know…" now start in the search box, and only escalate to a human when the answer genuinely isn't written down anywhere.

The index is a mirror. When a question has no good answer, it's almost always because the decision was never written down — it happened in a call, or in someone's head. You end up with a running list of "things we apparently never documented," which is uncomfortable and useful.

What still doesn't work

Very recent changes. If something shipped an hour ago and the sync hasn't run, the system doesn't know about it. We have auto-sync on short intervals now, but there's always a window where the freshest information is still only in someone's head.

Questions that need judgment, not retrieval. "Should we refactor the notification service" is not a search query. The system can tell you every complaint anyone has filed about the notification service, which is genuinely helpful context, but it can't make the call for you and shouldn't pretend to.

Threads that trail off. Half of Slack is a debate that never resolves. The system will faithfully surface all six positions and no conclusion, because there wasn't one. That's an accurate answer to "what did people think," and a frustrating answer to "what did we decide."

Was it worth it

For us, yes, and the reason is narrow. We're a small team with a lot of context and not much of it written down formally. The cost of that context being unsearchable was a steady tax on the two or three people who happened to hold it in their heads. Moving even part of that load into something anyone can query bought those people their afternoons back.

If your team already writes thorough design docs and keeps them current, you have less to gain here. If your team's real decision record is a scatter of Jira comments and Slack threads — and most teams' is — then the win is just making that record searchable in one place instead of four.

We're still finding the edges of what this is good for. The payment retry question, for the record, got answered in about eight seconds the second time someone asked it. The change was made because the payment provider's own retry logic was already doing exponential backoff, and stacking ours on top produced multi-minute gaps that tripped a separate timeout. It was in the Slack thread all along.

Want to try this on your own tools? Connect Jira, GitHub, and Slack in a few minutes and ask it something you already know the answer to — that's the fastest way to see whether it's useful.