What's the difference between a routine and a scheduled email?

A scheduled email sends a static snapshot to inboxes. A routine re-runs the skill that produces the report and posts the new HTML as a revision on a live, shareable, commentable document. The link doesn't change; only the content underneath refreshes. Comments persist across revisions.

Can I migrate my existing Python cron script?

Usually yes. Wrap the script as a Claude skill (or call the script as a step in a skill) and wire it as a routine. Comma handles the schedule, the credential, the cost ceiling, and the posting. You stop maintaining cron, secret rotation, and the email destination.

Where does the report end up?

On a Comma report — a faithfully rendered HTML document with anchored comments, role-based access, and revision history. Same shareable link every time. Reviewers see the diff between revisions.

Automated HTML report delivery, refreshed in place

You have a recurring report. Maybe it's a weekly analytics digest, a daily ops summary, a monthly board update. Today it's a Python script that emails a PDF, a Slack message with a screenshot, or a cron job nobody owns. Tomorrow, it's a routine.

The job

Take a report you currently send by hand (or by brittle script). Move it onto a hosted schedule. Make the new revision land in a place your team actually opens — a document, with comments, with history — not a Slack channel that goes unread.

That's what scheduled HTML reports look like as a Comma routine.

Why HTML, not PDF or email

PDFs lose the link between the report and the conversation around it. Email attachments lose version control. Screenshots in Slack scatter feedback across threads.

HTML, rendered as a document with anchored comments, is the format that keeps the report and the discussion in one place. When the routine fires again next week, the next revision lands on the same document. Comments from last week persist. The team sees a diff, not a fresh inbox.

What replaces what

What you have now	What the routine replaces
Python script + crontab on a laptop	Comma-hosted schedule, no laptop
GitHub Action emailing the team	Routine posting a new revision on a Comma report
Slack screenshot every Monday	Same shareable link with a new revision and live comments
PDF attachment with version-number-in-filename	Revision history on one canonical artifact
"Hey can you re-run the report?"	The schedule already did

Three patterns

1. Replace the Monday morning script

You have a script that runs by hand every Monday. The output gets pasted into a Notion page, a Slack channel, or a Google Doc. Feedback gets lost.

Wrap the script as a skill. Wire it as a daily or weekly routine. The HTML posts to a Comma report. Reviewers comment in-place. Next week's revision lands at the same URL.

2. Replace the email-to-the-team digest

You have a service that emails a digest every morning. People stop reading it after week three.

Replace the email rail with a routine that posts the new HTML revision on a Comma report. Subscribers get a notification with a link, not an attachment. The diff between this revision and yesterday's is visible in the report itself.

3. Replace the "I'll just rerun it later" workflow

You have a notebook or dashboard you re-run by hand when someone asks. There is no schedule. Sometimes it's stale; sometimes it's twelve days old.

Wire it to a routine on a cadence that matches the underlying data refresh. The team gets the same link they had before. The artifact is current.

What you give Comma

A skill. The Markdown instruction-set for how to regenerate the report. The skill can call your warehouse, your eval harness, your internal API, or just produce an HTML report from a prompt.
A target report. Either a new placeholder, or an existing report where the routine should append revisions.
A cadence. Monthly (Free), daily (Pro), hourly (Team), or sub-hourly (Enterprise).
A cost ceiling. Per-plan monthly Bedrock cap by default; tighten per routine if you want.

What Comma handles

The cron schedule.
The skill execution against AWS Bedrock.
The cost cap.
The scoped credential.
The posting of the new HTML as a revision.
The notification to reviewers.
The run history and audit trail.

Cadence by plan

Plan	Cadence floor	Use case shape
Free	Monthly	Monthly check-ins, retros, board prep
Pro $15/mo	Daily	Daily eval, daily ops summary, daily digest
Team $75/seat	Hourly	On-call dashboards, refresh-on-tick reports
Enterprise	Sub-hourly	Custom; needs the right SLA shape

Anatomy of a scheduled report routine

Routine:
  report:       rpt_weekly_analytics
  skill:        analytics-monday-digest.md
  cadence:      weekly (Monday 09:00 UTC)
  cost cap:     $2.00 per run
  notify:       weekly-digest@team
  rail:         metered (Pro) | BYOK (Team)

Run output: a fresh HTML report, posted as revision N+1 on rpt_weekly_analytics. Anchored comments from revision N persist. Diff against the previous revision is one click.

The honest scope

Routines are good at:

Re-running a focused, well-defined skill.
Posting the output to a Comma report.
Capping the cost.
Surviving as part of an ops rotation without anyone babysitting it.

Routines are not for:

Multi-hour pipelines. Use a real orchestrator.
Side-effects beyond Comma. Routines post to a report. They are not a general-purpose cron.
Warehousing your data. The skill fetches what it needs at run time.

If your need fits in "a focused script that produces an HTML report on a cadence," routines fit. If it doesn't, they won't pretend to.

Try it

The shape is identical at every plan. Start on Free with a monthly cadence and the actual script you'd run by hand. The next time you'd have run it, the routine will already have.

Create your first routine →