# How to Vibecode Cal.com — Can You Do It Yourself?

> Scheduling infrastructure for everyone

- Site: https://cal.com
- Category: SaaS / Scheduling
- Verdict: **Solid side project** (68/100 vibecodeable)
- Estimated effort: 2-3 weeks of focused development and debugging

## Verdict

Build a personal 1-on-1 scheduling MVP in a weekend, but prepare for multi-calendar race conditions and timezone headaches if you expand to teams.

Replicating a solo scheduling link with Google Calendar integration is straightforward with an AI coding agent, but real Cal.com parity hits a wall when dealing with bi-directional calendar webhooks, synchronization retries, and daylight saving edge cases. If you just want a booking link, use the free tier; build this if you want a deep dive into complex relational scheduling data models.

### What you can't replicate

- Pre-existing OAuth verifications with Google and Microsoft
- Enterprise HIPAA/SOC 2 compliance infrastructure
- Native mobile apps and extensive 100+ app store ecosystem

## What it does

Developer-focused, customizable scheduling infrastructure and online booking platform with calendar syncing and routing.

### Core features

- Two-way calendar sync (Google/Outlook)
- Dynamic timezone slot generation
- Custom booking page with event types
- Automated email/SMS reminders via cron
- Round-robin and team scheduling logic
- Custom domain and booking slug routing
- Stripe payment integration for paid bookings
- Webhook delivery and API v2 endpoints

## The business

### Pricing

- Individuals: $0 — Free forever plan for individuals
- Teams: $12/mo — Collaborative scheduling for teams (billed annually)
- Organizations: $28/mo — Enterprise-grade control and security (billed annually)
- Enterprise: Custom — Dedicated infrastructure and support

### Funding

$32.4M raised.
- Seed Round ($7.4M, Dec 2021)
- Series A ($25M, Apr 2022)
Investors: Seven Seven Six, Obvious Ventures, OSS Capital, Remote First Capital, Alexis Ohanian

Founded 2021.
Team size: 44.

## The hard parts

- Preventing double-booking race conditions across disparate calendar APIs
- Complex timezone matrix calculations accounting for daylight savings shifts
- Weighted round-robin distribution fairness algorithms for teams
- Enterprise compliance (HIPAA data isolation, SOC 2, SAML SSO)

## How to vibecode Cal.com

### Prerequisites

- Node.js (free): Runtime environment for Next.js application stack
- GitHub (free): Code repository hosting and version control
- Google Developer Console (free): Required to set up OAuth credentials for Google Calendar integration

### Recommended AI tools

- Claude Code: Best-in-class terminal agent for scaffolding complex full-stack multi-file applications and handling test-driven loops.
- Cursor: Ideal for fine-tuning frontend scheduling UI components and inspecting diffs interactively.

### Stack

- Frontend: Next.js (App Router, Tailwind CSS, Shadcn UI)
- Backend: Next.js Server Actions & API Routes
- Database: Supabase (PostgreSQL with Prisma ORM)
- Auth: Supabase Auth
- Payments: Stripe (skipped for personal MVP)
- Other: date-fns-tz for timezone calculations, Resend for transactional reminder emails

### Hosting

- Vercel (Frontend and API hosting with zero-config edge deployments): $0-20/mo
- Supabase (Managed PostgreSQL database and authentication layer): $0-25/mo

### Build guide

1. **Project Scaffolding & Database Schema** — Initialize the Next.js project with Tailwind CSS, configure Prisma with Supabase PostgreSQL, and define core models for Users, EventTypes, Bookings, and Availability.

```
Create a new Next.js project using App Router, TypeScript, and Tailwind CSS. Integrate Prisma ORM connected to a Supabase PostgreSQL instance. Build out the relational database schema in prisma/schema.prisma with models: User (id, email, username, timezone), EventType (id, userId, title, slug, lengthInMinutes, description, price), Availability (id, userId, dayOfWeek, startTime, endTime), and Booking (id, eventTypeId, userId, attendeeName, attendeeEmail, startTime, endTime, status, uid). Ensure proper foreign key constraints, indexes on slug and userId, and run the initial migration.
```

2. **Authentication & User Dashboard** — Implement authentication using Supabase Auth and construct a dashboard interface for users to manage their profiles, custom links, and basic settings.

```
Implement authentication in Next.js using Supabase Auth with email and password sign-up. Create protected dashboard routes under /settings and /dashboard. Build a clean UI using Tailwind CSS and Shadcn UI components where a user can view their unique booking URL (e.g., app.domain.com/username), edit their default timezone, and manage basic account parameters stored in the database User table.
```

3. **Event Type Management & Availability Rules** — Build the event type builder allowing users to configure meeting lengths, descriptions, buffer times, and recurring weekly availability.

```
Build an event type management interface in the dashboard. Allow users to create, update, and delete event types (title, duration in minutes, slug, price, buffer times before and after events). Implement an availability matrix component where users can define working hours per day of the week (e.g., Monday 09:00 to 17:00). Store these rules in the database and handle validation so overlapping ranges cannot be saved.
```

4. **Public Booking Page & Timezone-Aware Slot Engine** — Develop the public booking route that renders available time slots dynamically by calculating user availability, existing bookings, and visitor timezone offsets.

```
Create a dynamic public booking route at /[username]/[eventSlug]. Build a responsive calendar and time slot selection view. Implement a robust backend slot-generation algorithm that takes a user's weekly availability rules, checks existing conflicting bookings in the database, accounts for buffer times, detects the visitor's local timezone via Intl.DateTimeFormat, and renders available bookable slots in 15- or 30-minute intervals. Ensure daylight saving time shifts are correctly calculated using date-fns-tz.
```

5. **Booking Creation & Email Notification Pipeline** — Handle booking submissions, enforce transaction locking against double-booking races, and trigger automated confirmation emails via Resend.

```
Implement the booking confirmation handler when a visitor selects a slot and submits their name and email. In a database transaction, re-verify slot availability to prevent race conditions and double bookings. Create a new Booking record with status 'ACCEPTED'. Integrate the Resend API to send automated email confirmations to both the host and the attendee containing meeting details, cancellation links, and ICS calendar invites.
```

6. **Google Calendar Integration** — Integrate Google Calendar OAuth flow to read external calendar busy times and insert confirmed bookings into the user's primary calendar.

```
Implement Google Calendar OAuth connection in settings. Store OAuth refresh and access tokens securely in a CalendarCredentials database model. Build a background sync utility that queries the Google Calendar FreeBusy API for a given date range when rendering booking slots, merging external calendar busy periods with internal app bookings. Automatically create a calendar event via the Google Calendar API when a new booking is successfully confirmed.
```

### Cost vs paying

**Starting costs (one-time):**

- Custom domain name (optional): $12/yr
- Total: ~$12 one-time

**Ongoing costs (monthly):**

- Supabase Pro (optional free tier available): $25/mo
- Vercel Hobby / Pro: $0-20/mo
- Total: ~$0-25/mo

- Paying for the SaaS instead: $12-28/mo
- Build time: 35-50 hours
- AI tool credits: $20 (Claude Pro or Cursor Pro)
- Break-even: N/A (built for personal learning and self-hosted control)

## Sources

- [Cal.com Homepage & Context Scrape](https://cal.com)
- [Cal.com Pricing Page](https://cal.com/pricing)
- [Cal.com API v2 Docs](https://cal.com/docs)
- [Tracxn Company Profile - Cal.com](https://tracxn.com/d/company/cal.com)