How to share an HTML report with your team
You generated an HTML report — from a dashboard tool, a notebook, an AI
agent, a custom script. Now you need your team to look at it and tell you
what they think. This is harder than it should be, and the default options
have structural problems.
The four default options (and what's wrong with each)
Email the HTML file
Drop it as an attachment, send it to a distribution list, wait. Once the
file is on someone's desktop, the conversation has nowhere to live except
reply-all. Feedback scatters across separate threads. Two weeks later
nobody can tell which version was the final one. There is no link to the
canonical artifact — only a chain of attachments.
Paste a screenshot into Slack
The most popular option. Also the worst. Screenshots lose detail — charts
pixelate, tables become unsearchable, links go dead. Feedback fragments
across thread replies, none of which are anchored to "the row in the funnel
that dropped 8%" or "the third paragraph of the executive summary." The
report stops existing as a thing; only the screenshot of the report
exists.
Rebuild it in Notion or Google Docs
Re-create the analysis inside a tool that has a comment layer. This loses
the original rendering — charts, scripts, custom layout, interactive
elements — and costs you the time to rebuild. The artifact you share is no
longer the artifact you generated.
Publish it to a dashboard tool
If your dashboard tool supports publishing, you get a link. But (a) most
dashboard tools won't accept arbitrary HTML from outside the tool, (b)
reviewers need an account in the dashboard tool, and (c) the comment surface
(if any) lives inside a BI workspace that non-data teammates won't open
like they would a document.
What sharing an HTML report should actually look like
Six properties, working backwards from how a team actually reviews
something:
- Faithful rendering. The HTML displays exactly as it was generated —
no reformatting, no restyling, no rebuilding inside another tool's
schema.
- Stable URL. Reviewers bookmark the link. When the report refreshes,
the link doesn't change.
- Anchored comments. A comment pins to a specific text selection or
table cell. Not to "the report" — to "this paragraph" or "this row."
- Anyone with the link can comment. A free Google or email sign-in — no
seat, no invite.
- Access control. Role-based — private to the team, link-only access
for outside reviewers, public if you want.
- A revision history. Every refresh appends a new revision; comments
from past revisions stay anchored to where they were.
Each of the four defaults above is missing at least three. Comma covers
all six.
How it works in Comma
- Have the HTML. From wherever — a dashboard export, a notebook
render, an AI tool's output, a custom report generator.
- Create a report. Paste the HTML, upload a file, or POST it to
/api/v1/reports. Three ways in, same result.
- Get the link. A stable URL like
https://commareports.com/r/rpt_…. Share it however you'd share any
link.
- Reviewers open it. They see the HTML rendered faithfully inside an
opaque-origin sandbox — no rebuilding, no styling drift.
- Reviewers leave anchored comments. Select a paragraph or a table
cell, pin a thread, optionally @ a teammate.
- You see the comments in place. Threaded, resolvable, persistent
across revisions.
The whole flow is Google-Docs-shaped. Applied to HTML that previously had
no comment layer.
Common shapes
Sharing a Claude or ChatGPT output
You asked Claude to draft an HTML eval report. The output is a real
artifact — not a Markdown summary, but a rendered document with tables
and styling. You want your eng-quality lead to look at it. Paste the HTML
into Comma, share the link, lead pins comments on the rows that look
wrong.
Sharing a dashboard for feedback
You generated a dashboard export from your BI tool. You want product, eng,
and design to look at it before the leadership readout. Upload the HTML
to Comma, send the link to all three, comments land anchored to the
specific charts they refer to.
Sharing a notebook output without standing up a notebook server
You ran a notebook locally. The output is HTML. You don't want to host a
notebook server just so two teammates can comment. Drop the HTML into
Comma, share the link, done.
Sharing an AI agent's report
A scheduled agent generates a weekly digest as HTML. Each run posts to a
Comma report as a new revision. The same link refreshes in place; comments
from last week stay anchored where they were.
How it differs from rebuilding in Notion / Google Docs
- Notion / Google Docs can't render arbitrary HTML faithfully. Charts,
scripts, custom layout — they don't survive the paste.
- Comma renders the HTML you actually generated. Inside an
opaque-origin sandbox so it can't reach your account. The artifact is
preserved; the comment layer attaches outside the iframe.
The trade-off: Notion and Google Docs are general-purpose document tools.
Comma is for HTML specifically. If your artifact is plain text or a wiki
page, use Notion. If your artifact is rendered HTML, Comma keeps the
rendering intact.
Sharing controls
- Anyone with link — easiest; readers need no account, commenters sign in free.
- Specific teammates — invite by email; threads attribute to their
identity.
- Private to workspace — Enterprise (teams and folders); reports stay inside the workspace
unless explicitly shared.
- Public — open to the internet; useful for blog-post-style reports.
Commenting is free and unlimited on every plan — invite as many reviewers
per report as you need, with no caps. Team adds workspace-level access
controls, folders, and pooled credits. See pricing →.
Try it
Free tier is enough to feel the surface end-to-end. Paste any HTML you
have lying around, send the link to one teammate, ask them to leave a
comment.
Create your first report →
Related