0saas

Job ticket 602318 · consumer · appointment card · no subscription

Calendly charges for opinions about your calendar. Write them down once instead.

This page is the appointment card. You describe the week you actually have; a free-tier model returns a booking policy sheet — who gets what slot, and why — plus the copy your booking page should carry and a prep agenda per meeting type, rendered as files you paste into Calendly's settings, a plain calendar, or an email signature. No booking engine, because the engine was never the part you were paying for.

Calendly is a trademark of Calendly, LLC. This is an independent, unaffiliated comparison built on Calendly's own published pricing page, linked below and re-read every thirty days.

Appointment card — rendered in this browser

Source: noneRendered: 0Uploaded to 0saas: nothing

Sample data is illustrative, not a claim about Calendly. Every Calendly figure on this page comes from the linked pricing page, read 2026-09-27.

The prompt pack

Two prompts, each mapped one-to-one onto a Calendly feature you are currently rationed on. Run them from this page with a free key, or copy them into any free chat model — the text is identical either way, and it is printed in full at the bottom of this section so it survives this site.

Loading the pack from tools.json… If this fails, the full prompt text is still readable below.

One-time unlocks only, never a subscription. If a price ever appears here it was read from Stripe in that request, not typed by hand. An unlock is client-side gating, not secure payment verification: it is stored in this browser and cannot prove payment to anyone else.

What Calendly's own pricing page says

Read from calendly.com/pricing on 2026-09-27. Fields we could not read are marked unconfirmed rather than filled in with a plausible number.

Calendly Standard free vs Standard paid vs this page — verified 2026-09-27
The jobCalendly (free forever)Standard (US$10/seat)This page + a free-tier model
PriceUS$0 — 1 event type, 1 calendar connectionUS$10 per seat / month, billed annually (Teams US$16)US$0 forever. A free-tier key costs nothing; the prompts are yours.
More than one kind of meetingOne event type, full stopUnlimited types, availability rules, round-robin routingA policy sheet that says what each meeting type IS — paste the rules into the free plan's notes or run them from an email signature
Callers picking the right slot themselvesBooking page copy you write by hand, one boxCustom questions, conditional logic, remindersPrompt 1 emits signage lines written for strangers, in the same table — the copy does the routing before the calendar does
Walking into a prepared meetingNot a Calendly feature at any tier we readForms and workflows on higher tiersPrompt 2 drafts the prep packet per meeting type; the invitee and you get the same document

What this replaces, and what it does not

A displacement claim you cannot substantiate is a lie with good typography. This is the whole scope, including the parts where Calendly wins.

Replaced: the multi-event-type decision layer

The who/what/why table prompt 1 writes is the admin panel's content — as a file, at US$0, versionable, and readable by the people you decline.

Replaced: booking-page copy and screening questions

The signage block is written to be pasted into the free plan's description field; the intake-email rule becomes text, not a workflow.

Replaced: per-meeting-type prep

Prompt 2's packet ships goal, bring-list, checklist, time-box, and the reschedule rule — the human part Teams-tier automations wrap around scheduling.

NOT the booking engine

No availability holding, no invites, no two-way calendar sync, no no-show handling. Rebuilding those correctly is a product, not a page, and we refuse to pretend otherwise.

NOT payments or round-robin

Taking card payments on bookings and routing across a team are billing-grade features; this page writes the policy they implement, nothing more.

NOT a monthly-price claim

The numbers here are the annual-view seat prices Calendly displays as US$10/US$16 with save badges; the monthly-billing figures never rendered in our fetch and stay unconfirmed.

The prompts, in full, as text

Copy these into any model. They are the product; the page around them is convenience. Each block is the exact system prompt the interactive runner sends, plus the user-message template.

Prompt 01 — 1. Scheduling policy sheet · calendly-policy-sheet v1.0.0 · best ally: Google Gemini API — Free usage tier · gemini-2.5-flash-lite

Replaces: Calendly's paid multiple-event-types and availability-rule admin: the 'who can book what, when, and with what buffer' table.

Why this model: A policy table is a translation task with strict columns — every row must carry condition and action or it is decoration. Flash-lite's JSON mode keeps rows aligned where chat models drift into advice. Fallback ally: OpenRouter — :free model variants.

System prompt (1493 chars):

You are a scheduling clerk. You take someone's described working week and return a booking policy table: every rule explicit, every exception named, no invented authority.

Return ONLY one JSON object. No markdown fences, no commentary.

{
  "title": string (max 8 words),
  "columns": [
    { "label": "situation" }, { "label": "who can book" }, { "label": "what they get" }, { "label": "the rule behind it" }
  ],
  "rows": [
    [ string (situation, <= 10 words), string (who, <= 6 words), string (slot length + window, <= 12 words), string (the reason, <= 15 words) ]
  ],
  "signage": [ string (a line to put on the booking page or email signature, <= 20 words, one per policy that callers must know) ]
}

Hard rules:
1. 4 to 10 rows. One row per distinct decision; if two situations share a rule, merge them and say so in the rule column.
2. Every slot length must come from the description or be a stated default you flag as '(default)'. Never invent hard availability (no 'I block Fridays') the description did not grant.
3. The rule column answers WHY, in working language ('needs a note-first context dump') — not politeness.
4. signage lines are written for strangers to read: no in-jokes, no internal terms, each one copy-pasteable as-is.
5. If the description leaves a real gap (e.g. no mention of no-shows), add exactly one row for it with who='you' and situation='OPEN QUESTION — ' prefixed, and the row's rule states what to decide.
6. Write in the language of the description.

User message template:

How my week actually works, and who keeps trying to book me: {{week_reality}} What I want the back-and-forth to stop being: {{intent}}

Variables:

  • {{week_reality}} — Your week in plain words (max 900 chars) sample data shipped with the tool
  • {{intent}} — The outcome you're protecting (max 400 chars) sample data shipped with the tool

Output schema (the answer must match this exactly):

{ "type": "object", "required": [ "title", "columns", "rows", "signage" ], "properties": { "title": { "type": "string" }, "columns": { "type": "array" }, "rows": { "type": "array", "minItems": 4, "maxItems": 11 }, "signage": { "type": "array", "minItems": 1 } } }

Decoding: temperature 0.35 · max 1200 output tokens · responseMimeType application/json · budget ~700 in / ~700 out per run · cost per run: 1 request. Inside every free tier's daily headroom; the relay floor spends nothing at all.

Prompt 02 — 2. Meeting prep agenda · calendly-prep-agenda v1.0.0 · best ally: OpenRouter — :free model variants · meta-llama/llama-3.3-70b

Replaces: The per-event-type prep Calendly's Teams/Enterprise tier wraps in workflows (routing questions, pre-meeting forms, reminders with context): the agenda an invitee should get and the prep you should not have to re-write every time.

Why this model: Agendas are prose with a promise in them — the model must ask the questions your meeting actually needs without slipping into corporate filler; OpenRouter's free rotation gives the roomiest everyday quota for iterating one agenda until it is usable. Fallback ally: Groq Cloud — free tier.

System prompt (1496 chars):

You draft one meeting prep packet: an agenda the invitee receives, plus the questions the organizer should ask up front. You write like a person who respects both sides' time.

Return ONLY one JSON object. No markdown fences, no commentary.

{
  "title": string (max 8 words, e.g. '20-minute fit call — Meridian brief'),
  "blocks": [
    { "type": "h2", "text": string },
    { "type": "p", "text": string },
    { "type": "ul", "items": [string] },
    { "type": "todo", "items": [string] },
    { "type": "callout", "text": string }
  ]
}

Hard rules:
1. Exactly 6 to 12 blocks. The packet must contain, in order: the goal of the meeting (p), what the invitee brings (ul), what the organizer will have ready (ul), a two-to-four-item pre-meeting checklist (todo), the time-box agenda as numbered h2+p pairs, and one callout naming what happens if either side shows up unprepared.
2. Every time-box sums to the meeting length the description gives; if no length is given, ask nothing and use 30 minutes marked '(default)'.
3. No filler lines. 'Introductions' is banned; every agenda item must name the decision it feeds.
4. The ul of what the invitee brings must be things they can actually produce from memory or a folder — never 'a clear agenda' or other abstractions.
5. The callout is specific ('we reschedule once; a third time we part ways') only if the description supports it; otherwise it states the reschedule rule as the description's own.
6. Write in the language of the description.

User message template:

The meeting type, who usually ends up in it, and what a good outcome looks like: {{meeting}} Anything the invitee must do before showing up: {{prework}}

Variables:

  • {{meeting}} — The meeting type (max 800 chars) sample data shipped with the tool
  • {{prework}} — Required before the call (max 400 chars) sample data shipped with the tool

Output schema (the answer must match this exactly):

{ "type": "object", "required": [ "title", "blocks" ], "properties": { "title": { "type": "string" }, "blocks": { "type": "array", "minItems": 6, "maxItems": 12 } } }

Decoding: temperature 0.6 · max 1100 output tokens · responseMimeType application/json · budget ~550 in / ~650 out per packet · cost per run: 1 request; OpenRouter's free models meter per-day at generous counts for a two-prompt-a-week habit.

Questions worth asking before you cancel

If this doesn't book anything, what is the point?

Because the expensive part of scheduling is not the calendar math, it is the negotiation. A written policy plus booking-page copy ends most of the negotiation; the free plan's one event type stops mattering when the rules live in your words instead of their admin panel.

Why is US$10 labeled 'as displayed'?

Every price on this page is the annual-billing view of calendly.com/pricing as fetched on 2026-09-27 (Standard US$10, Teams US$16 per seat, Enterprise from US$15,000/yr, with the page's own save badges). The monthly toggle's numbers did not render in the text we captured; claiming them would be a guess, and guesses do not get a tag.

Can I use this without Calendly at all?

Yes — that is the intended escape hatch. The policy sheet works with plain calendar invites and an email signature; plenty of people never need a booking URL once their rules are written down.

What does the prep packet do that my head doesn't?

Two things: it makes the pre-meeting checklist identical for both sides, and it puts the reschedule rule in writing, where refusing can be about the policy instead of about you.

Nothing is loaded from X or LinkedIn until you click, and no share is counted, logged or reported back to us — the buttons are plain links to each network's own share page.

Next on the ledger