Cross-timezone booking that respects working hours.
Cross-timezone slots that respect working hours. Team round-robin without per-user pricing.
Global teams lose 7+ hours a week (Ideabrowser #2161 TimeSync market signal) to cross-timezone scheduling. A sales rep in New York trying to schedule a prospect in Sydney. A design team coordinating a cross-functional review across EMEA, APAC, and the Americas. A founder hiring their first engineer in Europe. Current tools either show "everyone's availability" as a raw union (Calendly group polls, When2Meet) or pick a slot without considering that 6am for Singapore is a terrible time to think clearly.
Calendly dominates the scheduling-link category with 20M+ users and a $3B+ valuation, but charges $10–$20 per user per month. For a 10-person team that's $1,200–$2,400/year just for booking links. SavvyCal and Cal.com chip at the edges with better UX and lower pricing, but the "AI conflict resolver that understands working hours" is not yet a standard feature. The wedge is opinionated defaults: never suggest outside a person's working hours, never suggest back-to-back meetings, always prefer slots after lunch.
The second wedge is flat-team pricing. Calendly charges per user even for a round-robin routing group where technically only one person takes the meeting. For a growing company that's pricing friction. Charging $49/mo flat up to 10 team members undercuts Calendly by 80% at team size 10. Cal.com's self-hosted angle is technical overhead that most teams don't want; managed hosted + AI features + flat pricing is the sweet spot.
A Calendly-class scheduling SaaS with three opinionated improvements. One: AI slot suggestion that respects working hours by timezone (never shows 6am Sydney as a "free" slot even if the calendar is empty). Two: team round-robin that distributes incoming bookings across configured teammates based on load balance (not just availability). Three: embeddable widget that drops into any website without iframe hell. Flat pricing: free solo, $19 Solo Pro, $49 Team up to 10 members.
Connect calendar
Google / Outlook / iCloud. Set working hours per day.
Share link
Booker picks a slot in their own timezone. AI respects yours.
Auto-confirm + Zoom
Calendar event created both sides; Zoom/Meet link attached.
The AI conflict resolver uses a simple rule engine + LLM judgment. Rules: within working hours, not back-to-back, not 30 minutes before end-of-day. LLM: for hard cases, "suggest 3 slots where both attendees will have reasonable energy." Over time, user feedback tunes the system ("never Mondays before 10am" as learned preference). This is a genuine differentiator that the incumbents haven't shipped because they optimize for enterprise compliance, not individual ergonomics.
The online scheduling software market is $5.5B in 2024, projected to $13B by 2030 at 15.6% CAGR (Grand View Research). Calendly is the clear category leader with a $3B+ valuation (2021 Series B at $3B). Cal.com raised $32M Series A+ (2023) as the open-source challenger. The market validates big outcomes; the question is whether a focused AI + flat-pricing entrant can carve out 1–2% share.
Stage: mature but AI-disrupted. Calendly is entrenched. SavvyCal serves power users. Cal.com serves developers. Motion and Reclaim focus on calendar defragmentation (related but different). A flat-priced, AI-conflict-aware entrant has a 12–18 month window before Calendly bolts in AI suggestions as table stakes.
Five competitor classes: Calendly + Cal.com (category leaders), SavvyCal (premium UX), Motion + Reclaim (AI calendar defrag adjacent), native calendar group-find-time (Google/Outlook built-in), and Doodle/When2Meet (legacy polls). None combine AI slot suggestions with flat-team pricing and an embeddable widget.
Category leader. 20M+ users, $3B valuation. Deep Salesforce/HubSpot integrations. Per-user pricing scales linearly; enterprise focus. Round-robin requires Teams plan at $16/user/mo.
$10 Standard → $16 Teams → $20+ Enterprise per user/mo
Open-source + hosted. Developer darling, 30K+ GitHub stars. Flexible but requires setup. AI features nascent. Hosted pricing is per-user. Self-hosting has ops overhead most SMBs avoid.
Free self-hosted; $12/user/mo Teams hosted
Premium UX challenger. Overlay feature (see booker's calendar + your calendar at once) is beloved. Priced higher per-user than Calendly; no flat-team tier. No AI slot suggestions yet.
$12 Basic → $20 Premium / $40 Team per user/mo
AI calendar tools but focused on defragmenting existing calendars and auto-scheduling tasks. Not primarily booking-link tools. Pricing $34–$49/user/mo — overkill for teams that just want scheduling.
Motion $34/user/mo; Reclaim.ai $10–$18/user/mo
Flat $49/mo up to 10 team members. AI slot resolver that respects working hours and energy patterns across timezones. Embeddable widget that works without iframe contortion. Tagline: "Scheduling that feels like it thought about your 8am, not just your calendar."
Flat pricing, not per-user. Free tier for solo indie; Solo Pro for single users who need the advanced AI; Team for small companies. LLM cost per booking is minimal (<$0.005); infra dominated by calendar API quota. Gross margin stays above 93% at scale.
$0
1 event type, 1 calendar, 10 bookings/mo, “Powered by” footer
$19/mo
Unlimited event types, multi-calendar, AI slot resolver, embeddable widget, custom branding
$49/mo
Up to 10 members, round-robin routing, team calendars, Salesforce/HubSpot integrations, SSO
Infra cost/tenant
~$0.60/mo
Gross margin Solo
~96%
Target CAC
$30–$60
Free → Solo conv.
5–9%
MRR path: 200 Solo + 30 Team = $5.3K/mo. 1K Solo + 150 Team = $26.4K/mo. At 4K Solo + 600 Team = $105.4K/mo ($1.26M ARR). Switching costs are high once users bake the scheduling link into email signatures, website footers, and CRM workflows.
Calendar OAuth + slot computation + AI layer. The hardest part is handling calendar API quotas and correctly computing free/busy across attendees in different timezones. Rest is SaaS plumbing.
Admin + booker-facing pages. /[username]/[event-type] public booking URLs as Server Components for fast first paint and SEO.
Tables: users, teams, calendars, event_types, bookings, routing_rules. RLS per-user and per-team.
Google Calendar API v3 + Microsoft Graph API. OAuth with calendar scopes. Use freebusy endpoints for availability computation; events.insert on booking. Handle token refresh per tenant.
When multiple valid slots exist, Claude ranks them considering working hours, both-party timezones, prior bookings patterns, and user-supplied preferences ("never before 10am Mondays"). Invoked only for Pro+ tiers to preserve margin.
Zoom OAuth for auto-creating meeting URLs on booking confirmation. Google Meet link is free with Google Calendar invites. Microsoft Teams via Graph API for Outlook users.
Stripe Checkout for Solo/Team. Widget served from Cloudflare CDN as a Shadow-DOM iframe embed; one-line <script> install for any website.
Copy and paste these into Claude, Cursor, or your favorite AI tool.
Create a Next.js 14 App Router scheduling SaaS. Supabase backend. Schema: - users(id, email, username, timezone, working_hours JSONB, plan, stripe_customer_id) - calendars(id, user_id, provider ENUM[google,outlook,icloud], access_token_encrypted, refresh_token_encrypted, calendar_id_external, is_primary bool, is_availability_source bool) - event_types(id, user_id OR team_id, slug, title, duration_min, buffer_min, min_notice_hours, max_advance_days, location_type ENUM[zoom,meet,phone,in_person], location_config JSONB) - bookings(id, event_type_id, invitee_email, invitee_name, invitee_timezone, start_at, end_at, meeting_url, status ENUM[confirmed,canceled,rescheduled]) - teams(id, name, plan) - team_members(id, team_id, user_id, role) - routing_rules(id, event_type_id, strategy ENUM[round_robin,load_balanced,collective], member_ids JSONB) OAuth flow: - /api/calendars/google/connect redirects to https://accounts.google.com/o/oauth2/v2/auth with scopes 'https://www.googleapis.com/auth/calendar.events https://www.googleapis.com/auth/calendar.readonly'. - Callback stores refresh_token encrypted via Supabase Vault. - Similar for Microsoft Graph with scopes 'Calendars.ReadWrite offline_access'. Availability computation: - For a booking request, fetch freebusy for each attendee from their calendars (cached 5 min). - Apply user.working_hours by day of week. - Subtract existing bookings from local DB (not-yet-synced double-booking protection). - Generate candidate slots matching event_type.duration_min at event_type.buffer_min spacing. - Filter: min_notice_hours satisfied, max_advance_days respected.
Build the AI slot ranking feature for Pro+ tiers. When a booker arrives at a booking page, we have: - List of 50+ candidate slots from availability computation. - Attendee timezones (user's known tz; booker's tz from browser). - User working_hours preferences. - User's learned preferences (e.g., stored tags like "avoid Mondays before 10am", "prefer afternoons"). Ranking via rule engine + Claude: 1. Rule pass: filter slots that violate hard rules (outside working hours either side, weekends if not allowed, less than buffer_min after a prior meeting). 2. Score pass: assign numeric scores by heuristic: - +10 mid-morning (10am-11:30am local) - +5 early afternoon (1:30pm-3pm) - -5 end-of-day (within 30 min of working_hours end) - -15 first-thing (within 30 min of working_hours start) - -10 back-to-back with adjacent meeting - -20 cross-timezone mismatch (one side outside normal working hours) 3. Claude pass (Pro+ only): top 10 scored slots passed to Claude with user's preferences: "Given these 10 slots and this user's stored preferences {preferences}, rank the top 5 for this meeting. Consider the booker is in {booker_tz} and user is in {user_tz}. Return JSON: {rankings: [{slot_start, reason}]}." 4. Show top 5 in the booking UI with an optional 'why?' tooltip explaining the AI's reasoning. Feedback loop: - If user deletes/reschedules a booking with source='ai_suggested', note in preferences ('dispreferred Tuesday 4pm'). Claude reads preferences back next time. - Rate limit Claude calls: cache per (user, booker_tz, date_range) for 10 min to avoid thundering herd on popular booking pages.
Implement team round-robin routing and the embeddable widget. Round-robin routing: - event_types with team_id and routing_rules with strategy='round_robin' use the following logic: 1. On booking request, query all team_members assigned in routing_rules.member_ids who are in team_id. 2. Fetch each member's availability for requested slot. 3. Load last-booked-at timestamp per member (from bookings table). 4. Assign to member with OLDEST last-booked-at among available members (load balancing). 5. Create booking with that member as host. - Strategy 'collective': require ALL team members available. Strategy 'load_balanced': weight by capacity_per_day setting per member. Failover: if chosen member unexpectedly declines (e.g., their calendar changed between query and commit), auto-reroute to next-best member before returning error to booker. Embeddable widget (scheduler.js): - ~30KB vanilla JS bundle hosted at https://cdn.product.com/scheduler.js. - Embed:
- On load, scans for data-scheduler divs; for each, injects a Shadow DOM iframe pointing to https://product.com/embed/{user}/{event}. - Iframe is styled to be transparent; host page CSS doesn't leak in (Shadow DOM isolation). - postMessage bridge: iframe emits 'booking_confirmed' event on completion; host page can listen and trigger confetti, redirect, or analytics. Test matrix: plain HTML, WordPress, Webflow, Framer, Next.js site. Must work without hosting-platform-specific workarounds. Embed analytics: track (tenant, host_domain, date, views, bookings) to a lightweight events table. Show embed performance in /admin/embed for the user.Verify Calendly, Cal.com, and SavvyCal pricing on live pages before marketing claims.
Book a consult and let's turn this idea into your MVP.
Book a Consult (opens in new tab)