# How to Vibe Code Your Own YouCanBookMe (and Stop Paying for It)

> Online scheduling and calendar management for businesses

- Site: https://youcanbook.me
- Category: Scheduling SaaS
- Verdict: **Solid side project** (68/100 vibecodeable)
- Estimated effort: 2-3 weeks part-time

## Verdict

You can build a functional personal scheduling clone, but integrating bi-directional calendar free/busy sync reliably across Google and Microsoft APIs will test your debugging patience.

Building a clean booking page UI with customized questions and Stripe checkout is straightforward with AI assistance. The real friction surfaces when syncing slot availability against external calendar APIs while handling timezone conversions, booking locks, and webhook reconnections. For personal use, paying a few dollars a month for a polished SaaS is vastly more efficient, but vibecoding this makes for an engaging technical challenge.

### What you can't replicate

- Institutional integration trust with Google and Microsoft OAuth ecosystems
- Extensive pre-built enterprise workflow triggers across thousands of external apps

## What it does

Customizable public booking pages with real-time calendar synchronization, automated notifications, payment processing, and team scheduling.

### Core features

- Bi-directional calendar sync with Google, Outlook, and Apple
- Dynamic timezone calculation across global bookers
- Customizable booking page builder with branded forms
- Automated email and SMS confirmations and reminders
- Stripe payment integration for paid appointments
- Team round-robin scheduling and mutual availability checks

## The business

### Pricing

- Free: $0 / month
- Professional: ~$10 / month
- Team: ~$16 / member / month

### Funding

$150.00K raised.
- Bootstrapped
Investors: Self-funded, Acquired by Capacity (Feb 2025)

Founded 2011.
Team size: 30-35.

## The hard parts

- Managing complex calendar free/busy sync race conditions across Google Calendar and Microsoft Graph APIs
- Robust timezone math across daylight saving time shifts for hosts and bookers
- Durable execution of multi-step reminder workflows without dropping notifications
- Handling webhook retries and synchronization edge cases when external calendars update

## How to vibe code YouCanBookMe

### Prerequisites

- Node.js (free): Required runtime for running the full-stack Next.js application framework.
- GitHub (free): Source code management and continuous deployment pipeline integration.

### Recommended AI tools

- Cursor: Ideal for iterative frontend development of booking pages, form editors, and calendar views with fine-grained diff review.
- Claude Code: Powerful terminal coding agent for scaffolding complex database schemas, API routes, and calendar synchronization logic.

### Stack

- Frontend: Next.js
- Backend: Next.js API Routes
- Database: Turso
- Auth: better-auth
- Payments: Stripe
- Other: Resend

### Hosting

- Vercel (Hosting the Next.js frontend, serverless API functions, and handling custom domain routing for booking pages.): $0-20/mo
- Turso (Relational data storage for users, booking pages, appointment types, and booked slot records.): $0/mo

### Build guide

1. **Project Scaffolding and Database Schema** — Initialize the Next.js project with Tailwind CSS, configure Turso database connectivity, and implement user authentication using better-auth.

```
Create a new Next.js 16 project with TypeScript and Tailwind CSS 4. Set up better-auth with email/password authentication backed by a Turso SQLite database using the libSQL client. Define database schemas in a `db/schema.ts` file for users, booking_pages (id, userId, slug, title, description, duration, bufferTime, timezone, price), appointment_types, and bookings (id, pageId, bookerName, bookerEmail, startTime, endTime, status, stripePaymentId). Ensure all foreign keys are properly indexed and establish clean environment configuration templates.
```

2. **Booking Page Builder and Management Dashboard** — Build an administrative dashboard allowing users to create, configure, and customize their public booking pages, meeting durations, and custom intake form questions.

```
Build a responsive admin dashboard in Next.js under `/dashboard`. Include a list of user booking pages and a multi-tab editor interface to configure page details: slug, title, description, meeting duration in minutes, buffer times before/after, price, and custom intake form questions stored as JSON. Implement server actions to create, update, and delete booking pages with proper input validation using Zod.
```

3. **Calendar Provider Integration and Slot Calculation Engine** — Implement OAuth connections for Google Calendar and Microsoft Outlook, securely store access tokens, and build the availability calculation engine that merges working hours with busy calendar events.

```
Implement OAuth callback routes for Google Calendar and Microsoft Graph APIs. Store encrypted OAuth tokens in a `calendar_connections` table linked to the user. Build an availability calculation engine service that takes a date range, fetches existing events from connected external calendars via API, respects user-configured working hours and buffer times, subtracts busy intervals, accounts for timezone shifts, and returns a list of available bookable time slots for a given booking page.
```

4. **Public Booking Flow and Timezone Rendering** — Create the public-facing booking page where clients can select a timezone, pick an available time slot from the calculated slots, and complete intake form questions.

```
Build a public booking page view at `/[username]/[slug]`. Include a dynamic timezone selector that automatically detects the booker's local timezone. Fetch and render available time slots grouped by day in a clean, interactive calendar grid. When a slot is clicked, display an intake form capturing the booker's name, email, and custom questions configured for that page. Validate slot availability on submission to prevent double-booking race conditions.
```

5. **Stripe Payments and Calendar Event Creation** — Integrate Stripe checkout for paid appointment types and implement backend logic to push confirmed bookings directly into the host's external calendar.

```
Extend the booking flow to handle paid appointment types using Stripe Checkout. When a page has a non-zero price, initiate a Stripe Checkout session upon form submission. Implement a Stripe webhook handler (`/api/webhooks/stripe`) that listens for `checkout.session.completed`. Upon successful payment confirmation, automatically create a corresponding calendar event on the host's connected Google/Microsoft calendar via their respective APIs, store the booking record in Turso, and transition the booking status to confirmed.
```

6. **Automated Notifications and Reschedule Flows** — Set up automated confirmation emails using Resend and provide secure rescheduling/cancellation tokens for booked appointments.

```
Configure Resend email service to send automated confirmation emails to both the booker and the host immediately after a booking is confirmed. Include secure reschedule and cancel action links with encrypted tokens in the email body. Build frontend pages for `/booking/reschedule/[token]` and `/booking/cancel/[token]` allowing booker-initiated changes that update both the local database and the external calendar event accordingly.
```

### Cost vs paying

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

- Custom domain (optional): $12/year
- AI coding tools subscription: $20
- Total: ~$32 one-time

**Ongoing costs (monthly):**

- Vercel Hobby/Pro hosting: $0-20/mo
- Turso database: $0/mo
- Resend email API: $0/mo
- Total: ~$0-20/mo

- Paying for the SaaS instead: ~$10/mo (Professional Plan)
- Build time: 35-50 hours
- AI tool credits: $20 (Cursor/Claude Pro subscription)
- Break-even: N/A (Built for personal use and learning)

## Sources

- [YouCanBookMe Official Website](https://youcanbook.me)
- [Capacity & YouCanBookMe Acquisition Press Release](https://capacity.com)