We had a prod issue last year — one of those gnarly blended things where a malformed Cloudflare rule quietly triggered some 403s on our legacy doc server. We figured it out via a Slack thread… which no one bookmarked, because it felt like “oh yeah, we’ll move this to Notion later.” Never happened. Three months later: same bug. Same rabbit hole, different guesswork. The thread? Buried. Search? Worthless unless you remember the exact phrasing we used.
Slack’s ephemeral design actively works against long-term knowledge. Threads collapse by default, past discussions get truncated unless explicitly pinned, and private-channel pearls of wisdom can never be surfaced in broader company wikis. Even integrations like Slackbot reminders or GDrive previews don’t fix the deeper issue — Slack is immediate, not archival.
If you’re using Slack as your org’s default knowledge dumping ground, you’re tempting fate. Use it for pointers, sure — “Hey this came up, check the wiki here” — but putting full incident logs or architecture decisions in a thread is asking to re-learn the hard way next quarter.
Confluence Is Where Good Ideas Get Mummified
The first time I tried to update a single bullet point in our Confluence stack, I found myself in edit mode for 8 minutes just waiting for one of the macro widgets to load. That moment broke something in my soul. To this day, I keep a separate “shadow doc” in Google Docs because I trust it more to survive versioning hell.
Confluence tries to solve for permanence and role-based access, but it’s the opposite of frictionless. Page trees become graveyards. Your cross-team tags? They aren’t even visible unless folks bookmark your space. And because formatting is so cagey (especially around code blocks or nested bullets), people resort to screenshots of terminal logs pasted into public-facing documents. Which, yes, are then unsearchable.
One bug I keep running into is with @mentions inside nested expanders. They silently fail to notify users unless the expander is expanded when the page is published. I only caught that because someone told me about a page I supposedly tagged them in, but they never got any ping or email. Brutal.
Google Drive Sprawl and the Illusion of “Shared”
There’s a folder in our shared Drive labeled “2022 Prod Learnings (OLD)” and inside are seven subfolders with names like “2nd Try” and “No Touchie FINAL_REALLYfinal.” If you think your knowledge hub is your GDrive, I respect your optimism, but no.
The catch with Google Drive — especially in orgs without clear taxonomies — is that permissions drift over time. Files get copied-saved-shared, and eventually, the filename’s accurate but the sharing settings are totally off. You think you’ve shared a key onboarding doc with a new engineer, and they can’t even open it without asking three people. Or worse, they find a slightly modified version with stale instructions and follow those instead.
I’ve bookmarked one really helpful Stack post on this: if you use the Drive API, you can actually listPermissions for documents recursively to audit access visibility — but good luck convincing someone to set that up proactively instead of in response to a facepalm.
Real Drive Pain You Might Miss
Commenting access doesn’t grant mention visibility unless a file is opened once by the user
Starred items are user-local, not org-wide — you can’t create “pinned” views for a team
“Shared with me” doesn’t show files you were ever removed from, even if re-shared later
Files in multiple folders only respect the original parent folder’s visibility for some integrations
Drive Search ignores PDFs unless OCR automatically detects them — and it fails on dark mode screenshots
Notion’s API Doesn’t Support Everything You Expect
Back in March I tried to automate page creation from a GitHub Action — we wanted changelogs to dump into a central product updates section. Easy, right? The Notion API docs say you can create pages, update content, embed stuff. But you know what they skip? That the API won’t render toggle lists *with nested code blocks* correctly unless you use a very specific block hierarchy. And none of that’s documented.
I burned maybe two days just trying to replicate a format we’d built manually using the UI. Eventually had to reverse-engineer a working page block by dumping its JSON through the unofficial CLI, then duplicating its tree via script.
The deeper issue is that Notion’s API is still evolving rapidly, and a lot of things that look customizable in the UI don’t map correctly to the backend structure. Inline tables have limited querying logic. Linked databases can’t be created via API calls. Auto-generated recent edits views? Not scriptable.
If you want consistent JSON output, cache your block structures once created and reuse those IDs — creating fresh versions every time leads to weird flakiness when Notion updates its formatting engine.
Looms You Never Rewatch
I once recorded a seven-minute Loom explaining our newest custom ECS deploy dance… then immediately forgot where I posted it. Two weeks later, I reuploaded it, re-explained it worse, posted *that* one in our implementation Slack, and only found the original when someone DM’d me confused why there are two conflicting videos in circulation. So yeah. Loom’s discoverability is trash unless you embed it somewhere searchable.
Also — and this is subtle but wild — the auto-captioning doesn’t always index tech terms correctly. I once said “bastion tunnel” and the transcript heard it as “passion funnel.” Which… I guess is one way to describe our infra.
There’s no way to bulk-reassign visibility or expire outdated Looms without going video by video. It’s like they assume every video is always up to date, which is hilarious in a CI/CD scenario. We’re now putting transcript-enabled Looms into a custom Airtable index with Chase’s GPT wrapper for internal QA flagging. It’s duct-tape, but it’s better than trusting search.
People Learn by Asking Dumb Questions, Not Reading Tagged Docs
The knowledge graph wall-of-links won’t ever beat asking Joe from SRE “hey I broke the ingress again, what the hell did I do wrong?” There’s a weird platform assumption that once documentation exists, it’s read. It rarely is. Especially in orgs with lots of junior engineers who don’t want to look dumb.
I had this moment with a newer dev where they said, “I Googled how to tail logs on ECS for fifteen minutes, then just screen-shared with my roommate who works at Shopify.” That’s what people actually do. They escalate sideways. Because our own internal search was trained on JIRA titles and didn’t rank the internal ‘runbook’ page above a random stale ticket from 2021.
Even structured Q&A tools (we tried Stack Overflow for Teams briefly) suffer unless you forcibly incentivize answers. The funniest thing? Our most helpful answers came from interns who were bored and overexplaining every topic just to seem smart. The lead devs? Silent.
Integrations That Claim to Sync But Don’t Get the Point
I saw a doc tool pitch where they demoed automatic syncing between GitHub PRs and Confluence release notes. It looked clean — pull request titles flowing into a page with neat changelogs. Problem is, they assumed each PR described user-facing context, which in our monorepo setup is a joke. Many PRs just say “fix spec edge case” or “add helper V3.” None of that helps downstream users.
True knowledge sharing means reframing technical actions into domain-relevant takeaways. Which no sync tool does unless you manually layer translation. And then it’s not saving time.
Weirdest bug I’ve seen: one tool injected GitHub PR links into a Confluence page inline, but the preview image broke if the user wasn’t logged into GitHub *via Atlassian cloud auth.* So people just saw empty boxes with tooltips that said “Unknown user object.” Looked like a security vulnerability but it was literally auth mismatch. Took me hours to pin down.
