At 50 weekly bookings, any calendar tool works. At 200, you start hitting invisible walls: payment processor thresholds, per-booking fee structures that blow your unit economics, API rate limits that kill team coordination, and reconciliation bottlenecks that break your accounting sync. This is where Calendly and Acuity stop scaling and you have to choose differently. The per-booking pricing trap Calendly charges a flat monthly fee ($20–$25 for Professional, $50 for Teams) that covers unlimited bookings—which sounds infinite until you layer in payment processing. Calendly doesn't collect payments natively; you're routing through Stripe, Square, or PayPal, and each platform caps transaction volumes differently. Stripe's standard tier supports unlimited transactions, but if your payment patterns flag as unusual—sudden volume spikes, high transaction density—they can freeze your account for review. At 200 weekly bookings with average session fees ($50–$150), you're moving $10k–$30k monthly through payment processors that assume gradual growth, not sustained high volume. Acuity (now Squarespace Scheduling) charges per booking: $0.50–$1.00 per appointment depending on your plan. At 200 weekly slots (800 monthly), you're adding $400–$800 monthly on top of the base plan. That math breaks fast when you're already paying a SaaS subscription. The real cost isn't the calendar tool. It's the payment processor's volume limits and the fee compounding. A team handling 200 weekly bookings at $75 average value pays roughly $2,400 monthly in Acuity booking fees alone, before platform subscription. Team scheduling conflicts and double-booking at scale Calendly and Acuity were designed for solopreneurs and small teams. Their conflict detection assumes a single calendar or a handful of linked calendars. At 200 weekly bookings across a team of 5–10 people, conflicts don't vanish—they multiply silently. Calendly's team feature allows one owner calendar per event type, and you route bookings based on round-robin or manual routing. But if two team members take a lunch break, attend an all-hands, or block focus time, Calendly doesn't auto-adjust availability across the group. You end up managing availability manually, defeating the purpose of automation. The client books a 2pm slot with Sarah, but Sarah's in a meeting—now you've got a bounce-back email and a manual reschedule. Acuity's group scheduling is slightly better but still manual: you create a group calendar and assign team members, but their personal calendar conflicts (Google Calendar, Outlook) don't feed into Acuity in real time. You're polling, not syncing. At 200 bookings a week, one missed conflict per day means 5 rescheduled appointments and 5 angry clients. Orin's booking system syncs live with team members' personal calendars and respects their work hours, breaks, and meeting blocks. When Sarah books lunch in Outlook, Orin automatically removes that slot from her availability. Calcom offers similar real-time sync, which is why both tools scale where Calendly plateaus. API reliability and data export at high throughput Calendly's API has a strict rate limit: 40 requests per minute, or 2,400 per hour. Sounds generous until your team integrates booking data with a CRM, accounting software, and team chat. A CRM sync that polls for new bookings every 5 minutes, a payment reconciliation job that runs every hour, and real-time Slack notifications can burn through your quota in minutes. At 200 weekly bookings, your integration stack is hammering Calendly's API constantly, and you'll see timeouts or degraded sync. Acuity's API is less documented publicly, but their webhooks (event-driven notifications) are the workaround. Webhooks are faster than polling, but Acuity's webhook delivery isn't guaranteed if your infrastructure can't accept them reliably. If your CRM's webhook receiver goes down for an hour, Acuity doesn't retry—bookings sync later or not at all. Calcom and Orin both use event-based webhooks with retry logic, meaning if your CRM API is temporarily unavailable, they keep trying for 24–48 hours. This matters when you're moving 40+ booking events per day into your downstream systems. Payment processor reconciliation and monthly settlement limits Calendly and Acuity don't collect payments directly. You're taking payments via Stripe, Square, or PayPal, then trying to reconcile those transactions with your booking record. At 200 weekly bookings, reconciliation becomes a nightmare: Timing mismatch: A client books on Monday and pays on Tuesday. Your calendar records the booking Monday; Stripe settles the payment Wednesday. Your cash flow and accounting records diverge. Partial payments and refunds: A client books two sessions, pays for one, then cancels one. Calendly doesn't track partial or pro-rata refunds automatically. You're manually coding refund entries into Xero or QuickBooks. Stripe payout delays: Stripe holds 1–2% of your volume in reserve and settles payouts