The idea
A shared annotation layer that floats over the internal web apps your team already uses. Highlight a field in the billing admin, a column in the Metabase dashboard, or a step in a runbook, and attach a note that everyone on the team sees the next time they open that page. Notes are anchored to the content, not to pixel coordinates, so they survive a layout change. Think of it as team-wide sticky notes for tools you don't control and can't modify.
Why build this
Every company accumulates tribal knowledge about its own tooling: "this metric double-counts refunds," "don't touch this toggle without asking payments," "this column is in cents." That knowledge lives in Slack threads and in the heads of three people. It is never present at the moment someone is staring at the confusing field.
The pages that need annotation are exactly the ones you can't easily change — a vendor's admin console, a BI tool, a Grafana board, a Salesforce object page. An extension is the only mechanism that reaches all of them uniformly. Onboarding is the obvious wedge: a new hire opens the ops dashboard and immediately sees the six things everyone learned the hard way.
Stack sketch
- Extension: Chrome MV3, TypeScript, built with Vite + CRXJS. The overlay renders into a Shadow DOM root so host page CSS can't bleed in or out.
- Anchoring: W3C Web Annotation-style selectors. Store a text-quote selector (exact text plus prefix/suffix) with a CSS-path fallback and a character offset, and resolve with
dom-anchor-text-quote— the same approach Hypothesis uses. Highest-confidence match wins; unmatched notes go to an "orphaned" tray rather than disappearing. - Scoping: notes key on a normalized URL pattern, so
/customers/1234and/customers/5678can share a note when the team wants the note to apply to the page type, not the record. - Backend: Fastify + Postgres. Annotations are rows with a JSONB selector blob; full-text search over note bodies with Postgres
tsvector. - Auth: the extension calls your API domain and rides an existing session cookie, so you inherit your company SSO instead of building login into the extension.
- Realtime: SSE from the API for live updates; no WebSocket infrastructure needed at this scale.
Scope for v1
In:
- Chrome only, one workspace per install.
- Highlight text → add note. Notes support markdown and @-mentions that fire a Slack webhook.
- A per-page sidebar listing every note on the current URL, plus orphaned notes.
- A workspace-wide search page (web, not extension) over all note bodies and URLs.
- Domain allowlist, so the extension is inert everywhere except the hosts you configure.
Out: Firefox and Safari builds, threaded replies, PDF and canvas annotation, mobile, offline editing, permissions beyond "everyone in the workspace can read and write."
Where it could go
The obvious next layer is turning notes into checks. If a note says "this toggle should stay off," a scheduled headless run can open the page and assert it — the annotation becomes a lightweight monitor for tools with no API. That's a natural upsell and it reuses the anchoring engine you already built.
The second path is retrieval. Once you have a corpus of annotations bound to specific URLs and UI elements, you can answer "what do we know about the refunds dashboard?" by embedding note bodies and serving them into whatever assistant the team already uses. The value here isn't the model, it's that the corpus is grounded in exact places in exact tools.
Watch out for
Anchoring is the whole product, and it's harder than it looks: SPAs re-render, tables virtualize their rows, and a single copy change can orphan dozens of notes. Budget real time for a resolver that degrades gracefully, and make orphaned notes visible and re-attachable instead of silently dropping them.