Cal.com

Scheduling infrastructure for everyone — until April 2026. Here’s what actually happened and what it means for self-hosters.

TL;DR

• What it is: Open-source (now partially closed-source — more on this below) scheduling platform originally positioned as the self-hostable Calendly replacement. The community fork is now called Cal.diy [1].
• Who it’s for: Individuals who want a free, self-branded booking page; teams escaping Calendly’s per-seat pricing; developers who want scheduling infrastructure they can embed in their own product.
• Cost savings: Calendly Professional runs $12/seat/month and scales with headcount. Cal.com’s individual tier is free. Self-hosting via Cal.diy runs on a VPS for $5–15/month for a solo founder or small team.
• Key strength: 40,610 GitHub stars, genuinely polished booking UX, and the most complete scheduling feature set in the self-hosted category — round-robin, routing forms, payments, HIPAA, 65+ languages, webhooks [4][README].
• Key weakness: As of April 15, 2026, Cal.com moved its production codebase to a private repository. The public repo is now calcom/cal.diy. If you were betting on the upstream staying open, the terms just changed [1].

---

What is Cal.com

Cal.com started in 2021 with a clear pitch: “The open-source Calendly successor.” It gives individuals and teams a scheduling page where people book time with you — connect your calendar, set your availability, share a link, done. The product is Calendly but with self-hosting, white-labeling, API access, and source code you can read and fork.

The project grew fast. 40,610 GitHub stars as of this writing puts it in the same weight class as major open-source infrastructure tools — well above any other scheduling project in the self-hosted space [README]. It was #1 Product of the Month on Product Hunt and reached #1 on Hacker News twice [README]. The company describes its mission as connecting a billion people by 2031 through calendar scheduling [1].

What made it credible beyond the marketing: the feature depth. This isn’t a Calendly clone with a Docker container bolted on. It ships with round-robin scheduling, collective events, routing forms, Stripe and PayPal payment processing, automated workflows (SMS + email reminders), native video conferencing (Cal Video), webhooks, a public API, embeddable React components, HIPAA compliance for healthcare use cases, and an app store of integrations [4][website]. It’s closer to scheduling infrastructure than a booking page.

But the big story as of April 2026 is the licensing shift. Cal.com moved its production codebase from a public GitHub repository to a private one. What remains public — as calcom/cal.diy — is a community-maintained fork described as “the open-source, self-hostable, community-driven version of Cal.com” [1]. This is a meaningful change for anyone who was treating the GitHub stars as a proxy for long-term open-source commitment.

---

Why people choose it over Calendly, Acuity, and Google Calendar

The comparison that matters most for this audience is Cal.com versus Calendly, because that’s the migration most people are actually making.

Versus Calendly. Calendly’s Essentials plan starts at $8/seat/month and Professional is $12/seat/month — per seat, billed annually [3]. If you’re a team of five running a sales or recruiting operation, you’re at $60–$80/month before you’ve added a single feature. Cal.com’s individual tier is free with no artificial limits on event types. The self-hosted version (Cal.diy) runs on your own VPS. Several reviewers on aipure.ai point to automated workflows and team routing as the specific features that justify switching — features that are gated behind Calendly’s paid tiers [4].

Versus Google Calendar. The “saas_competitor” in Cal.com’s own profile lists Google Calendar, which undersells the difference. Google Calendar doesn’t have a public booking page, routing logic, payments, or embeddable components. It’s a calendar. Cal.com is scheduling infrastructure. The real competition is Calendly, HubSpot Meetings, or Acuity Scheduling.

Versus Acuity Scheduling. Acuity (owned by Squarespace) runs $16–$61/month and targets service businesses — spas, coaches, consultants. Cal.com covers the same use cases with HIPAA, multi-language support, and a developer API. The pricing gap is significant for solo operators.

On the API-first angle. The feature that separates Cal.com from all the SaaS alternatives is the scheduling components: React atoms you can drop into your own app, an OAuth flow to let your users connect their own calendars, and an API that lets you build scheduling into a product you’re selling to others [website]. This is the “infrastructure for everyone” positioning — not just a booking page, but something you embed in your SaaS. That use case doesn’t exist in Calendly, Acuity, or any hosted alternative.

On data ownership. The same privacy argument that applies to workflow automation applies here. Calendly processes every booking event, has your calendar data, and can raise prices or change terms. Cal.diy self-hosted gives you the booking flow, the calendar sync, and the reminders — running on your own infrastructure [4].

---

Features: what it actually does

Based on the README, website scrape, and third-party reviews:

Core scheduling:

• Visual availability editor with buffers, minimum notice periods, and daily/weekly/monthly booking limits [4][website]
• Customizable booking link (cal.com/yourname) [website]
• Multi-timezone support with automatic detection [4]
• 65+ language support [4]
• Overlay-my-calendar view for bookers [website]

Event types:

• One-on-one, collective (multiple hosts), round-robin, group events [4]
• Routing forms — logic-based event type routing based on booker answers [website]
• Instant Meetings — meet-now link generation [website]
• Dynamic Group Links — multi-person booking flows [website]

Integrations:

• Calendar sync: Google Calendar, Outlook, iCal, Office 365 [4]
• Video: Cal Video (native), Zoom, Google Meet, Microsoft Teams, Daily.co [4][README]
• Payments: Stripe, PayPal [4]
• CRM: HubSpot, Salesforce (via app store) [website]
• Meta Pixel, Zoho Bigin, and other apps via the App Store [2]
• Webhooks for custom integrations [website]

Workflows and automation:

• Automated SMS and email reminders [4][website]
• Disable default confirmation emails when custom workflows are active [2]
• Out-of-office scheduling [website]

Developer / embed:

• Public REST API [website]
• Scheduling React components (Cal Atoms) [website]
• OAuth client creation for user-level calendar integration [website]
• Embeddable booking widget [website]

Enterprise features (some gated):

• SSO [features/canonical]
• HIPAA compliance for healthcare [4]
• Team-level routing and access controls [4]
• Audit logs and SCIM — data not confirmed available in Cal.diy vs. cloud tiers

The feature list is genuinely impressive for a free self-hosted tool. The weakness isn’t missing features — it’s that the split between Cal.com cloud, Cal.com Enterprise, and Cal.diy community fork is now less clear after the April 2026 repository change [1].

---

Pricing: SaaS vs self-hosted math

Cal.com Cloud:

• Individual: Free, no credit card required [website]
• Teams and Organizations: pricing not published on homepage at time of this review; a demo is offered for enterprise [website]
• Enterprise: contact sales

The individual free tier is genuinely unlimited — no artificial cap on event types or bookings that forces an upgrade [4][website]. This is the strongest free tier in the scheduling space.

Cal.diy (self-hosted, community fork):

• Software: $0, AGPLv3 license [README]
• VPS: $5–15/month (Hetzner, DigitalOcean, Contabo)
• PostgreSQL and required dependencies: bundled in Docker Compose or external managed DB

Calendly for comparison:

• Free: 1 event type, unlimited bookings, basic integrations
• Essentials: $8/seat/month (annual) — multiple event types, integrations
• Professional: $12/seat/month — workflows, routing, payments
• Teams: $16/seat/month — team features, pooling
• Enterprise: contact sales, SOC 2, SSO, SAML

Concrete savings math:

Say you’re a solo consultant running 3 event types (15-min discovery, 30-min strategy, 60-min retainer call) with automated reminder workflows and Stripe payments. On Calendly Professional that’s $12/month for one seat = $144/year. On Cal.com individual cloud, that’s $0. Self-hosted on Cal.diy on a $6 Hetzner VPS: $72/year for the VPS, shared with anything else you’re running.

For a team of 5 in sales doing demos: Calendly Teams = $80/month = $960/year. Cal.com cloud for teams — pricing not publicly listed, but the individual tier is free and team plans are competitive. Self-hosted: still ~$10–15/month for the VPS regardless of headcount.

Caveat: the pricing math only holds if you can deploy Docker. If you can’t, you’re on the free cloud tier or paying someone once to set it up.

---

Deployment reality check

Cal.com is a full Next.js monorepo. The README lists the tech stack: Next.js, tRPC, React, Tailwind CSS, Prisma, PostgreSQL [README]. This is not a simple single-binary install — it’s a real application with a real dependency graph.

What you actually need:

• Node.js (specific version per README) [README]
• PostgreSQL [README]
• An SMTP provider for email confirmations
• A domain + reverse proxy (Caddy or nginx) for HTTPS
• Docker and docker-compose for the containerized path
• A calendar OAuth app (Google Cloud Console or Azure) to enable calendar sync

What can go sideways:

• The calcom/cal.diy split is new as of April 15, 2026 [1]. Existing self-hosters who cloned calcom/cal.com need to understand which repo they’re tracking now and what the maintenance trajectory of cal.diy looks like without the full company behind it.
• The app suffered from cold start times of 7–30 seconds in earlier versions, addressed in v2.9 through tRPC endpoint unbundling, pre-fetching, and caching [2]. Newer versions are significantly better, but the underlying Next.js architecture means cold starts on low-memory VPS instances remain a real concern.
• Calendar OAuth setup requires creating OAuth credentials in Google Cloud Console or Azure AD — this is the step that trips up non-technical users. It’s documented, but it’s not a five-minute process.
• The AGPLv3 license means if you embed Cal.diy in a product you distribute, you must open-source your modifications. MIT it is not. This matters if you’re building a white-label scheduling product for clients [README].

Realistic time estimate for setup: 1–3 hours for a developer familiar with Docker and DNS. Half a day to a full day for a non-technical founder following a guide, not including time to set up Google OAuth. Factor in external managed PostgreSQL (Railway, Render, Neon) if you want to skip database administration.

The official Cal.com blog links to Railway, Northflank, and Render for managed Postgres setups [README], which is a reasonable signal that the company knows their users don’t always want to manage their own database.

---

Pros and Cons

Pros

• Free individual tier — genuinely unlimited for solo use on hosted cloud. No Calendly-style upgrade pressure for basic features [website][4].
• 40,610 GitHub stars — the most validated scheduling tool in the self-hosted space by a factor of several times [README]. Community size translates to available guides, Stack Overflow answers, and integrations.
• Feature depth — round-robin, routing forms, payments, video, HIPAA, 65+ languages, webhooks, embeddable components. Comparable to or better than Calendly Professional on features [4].
• Developer-ready API and components — the only scheduling tool in the open-source space with embeddable React atoms and an OAuth flow for building multi-tenant scheduling into your own product [website].
• White-label capable — custom domain, custom branding, no Cal.com watermark on paid/self-hosted tiers [README][website].
• App Store integrations — Meta Pixel, Zoho Bigin, Stripe, PayPal, video conferencing, and growing catalog [2][4].
• Active engineering culture — the blog shows real incident reviews, CI optimization work (30min → 5min), and regular releases [1]. This is a team that ships and is transparent about failures.

Cons

• April 2026: moved production codebase to private repo — the main calcom/cal.com repository is now a community fork (cal.diy), not the canonical production codebase. Cal.com the company develops privately. This is a significant change in the open-source commitment [1].
• AGPLv3, not MIT — copyleft license. If you distribute a product that incorporates Cal.diy, your modifications must be open-sourced. This is a real restriction for agencies or SaaS builders [README].
• Complex monorepo setup — this is not a lightweight tool. Next.js + tRPC + Prisma + PostgreSQL + OAuth credentials + SMTP = several moving parts to get running [README].
• Cold start history — older versions had 7–30 second cold starts. Addressed in v2.9, but worth validating on your specific VPS before committing [2].
• Team pricing is opaque — the cloud tier for teams doesn’t show pricing publicly; you have to book a demo [website]. This is a minor friction point for buyers trying to compare options.
• Cal.diy maintenance uncertainty — the community fork was just created in April 2026 [1]. It’s unknown how actively it will be maintained now that the company’s development is private. This is the biggest long-term risk for self-hosters.

---

Who should use this / who shouldn’t

Use Cal.com (cloud free tier) if:

• You’re a solo founder, freelancer, or consultant who needs a booking page and you want something better than a Google Calendar link. The free individual tier covers everything you need.

Use Cal.diy (self-hosted) if:

• You’re comfortable with Docker and want full data ownership and zero ongoing SaaS cost.
• You need white-labeling or embedding in your own product and understand the AGPLv3 implications.
• You’re building multi-tenant scheduling infrastructure — the OAuth and components path is unique in this category.

Wait and watch if:

• You were planning to self-host and rely on upstream development for security patches and new features. The cal.diy fork was created 4 days before this article was written [1]. Give it 3–6 months to see if the community maintainers are active before betting your infrastructure on it.

Skip it (use Calendly) if:

• You’re not technical and need scheduling working today without setup time. Calendly’s free tier is enough for basic use, and the paid tiers are reasonable for one or two seats.
• Your team is already embedded in Google Workspace and Google Calendar appointment scheduling covers your use case.

Skip it (use a different self-hosted option) if:

• You need a simpler deployment — something closer to a single Docker image with no external dependencies. Cal.diy is powerful but not simple.
• You need MIT licensing to build a commercial product on top without legal review.

---

Alternatives worth considering

• Calendly — the incumbent. Easiest setup, largest integration ecosystem, per-seat pricing that gets painful at scale, fully closed source. The baseline everything else is compared to.
• Zcal — lightweight alternative with a simpler setup than Cal.diy. Fewer features, but if you just need a booking page and don’t need round-robin or routing forms, it’s worth evaluating.
• Rally — newer open-source scheduling tool. Less mature than Cal.diy, but fully MIT-licensed and simpler to deploy.
• Formbricks (forms + scheduling) — if your booking flow is embedded in a survey or qualification form, Formbricks handles both with a simpler stack.
• HubSpot Meetings — free tier exists, deeply integrated with HubSpot CRM. Only makes sense if you’re already in HubSpot.
• Acuity Scheduling — better for service businesses (salons, coaches) that need class/service management. $16–$61/month, fully hosted, no self-host option.

For a non-technical founder comparing options: the realistic shortlist is Cal.com free tier vs. Calendly free/Essentials. If you need team features or embedding, the calculus depends on whether cal.diy’s maintenance trajectory stabilizes over the next few months.

---

Bottom line

Cal.com built the most credible open-source Calendly replacement in the market, backed by genuine feature depth, 40K+ GitHub stars, and a company that ships real engineering work. For individual use, the free cloud tier is the easiest win in this category — no setup, no cost, better features than Calendly’s free plan. For self-hosting, it was the obvious choice in the scheduling space until April 15, 2026, when the company moved its production codebase private and handed off the public repo to a community fork called Cal.diy.

That fork may turn out fine — the codebase is there, the community is large, and the bones are solid. But it’s four days old at time of writing. If you’re building scheduling infrastructure for a client or product, give the fork a quarter to demonstrate active maintenance before committing. If you just need a booking page, the free cloud tier is still the most capable free scheduling tool available.

---

Sources

1. Cal.com Engineering Blog — “Moving to closed-source: the technical changes” (April 15, 2026). https://cal.com/blog/category/engineering
2. Cal.com Blog — “Cal.com v2.9” by Ciarán Hanrahan (May 15, 2023). https://cal.com/blog/v-2-9
3. VC Stack — “Cal.com — Features, Reviews, Alternatives”. https://www.vcstack.io/product/cal
4. AIPure.ai — “Cal.com: Reviews, Features, Pricing, Guides, and Alternatives” (Updated Jul 16, 2025). https://aipure.ai/products/cal

Primary sources:

• GitHub repository and README: https://github.com/calcom/cal.com (40,610 stars, AGPLv3 license)
• Cal.diy community fork: https://github.com/calcom/cal.diy
• Official website: https://cal.com
• Pricing page: https://cal.com/pricing