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

> Online booking and service sales platform

- Site: https://zencal.io
- Category: Scheduling & Service Sales SaaS
- Verdict: **Solid side project** (68/100 vibecodeable)
- Estimated effort: 2-4 weeks part-time

## Verdict

Build a personal service scheduling clone for yourself, but keep paying if you rely on multi-user team routing and regional payment gateways.

The core booking loop (pick slot, save meeting, email confirmation) is straightforward. However, maintaining reliable two-way calendar sync with Google and Microsoft without hitting rate limits or timezone corruption requires careful engineering. Background jobs for SMS reminders and atomic Stripe payment locks add noticeable integration friction.

### What you can't replicate

- Zencal's established user base and specialist trust
- Pre-integrated regional European payment processors (Przelewy24, tPay, PayU)

## What it does

An online booking and service sales platform combining multi-directional calendar sync, payment processors, automated invoicing, SMS/email reminders, and team routing.

### Core features

- Meeting types & service definition
- Hosted booking profile page & embeddable widget
- Two-way calendar sync (Google Calendar, Outlook)
- Real-time availability conflict calculation
- Stripe payment gateway integration
- Automated email & SMS reminder sequences
- Team round-robin assignment routing
- Basic revenue & booking analytics dashboard

## The business

### Pricing

- Light: $10/mo — For individuals getting started with scheduling
- Pro: $28/mo — For professionals and small teams who need all features
- Team: $349/mo — For growing teams up to 20 users
- Enterprise: Custom — For organizations needing dedicated infrastructure

Founded 2022.
Team size: Small boutique team.

## The hard parts

- Two-way calendar sync handling timezone shifts and preventing infinite webhook sync loops
- Robust background job queues for time-sensitive global SMS/email reminders
- Team round-robin scheduling logic with overlapping schedules and buffer times
- Atomic payment-to-booking finalization ensuring slots lock only upon successful charge

## How to vibe code Zencal

### Prerequisites

- Node.js (free): Runtime environment for Next.js development
- GitHub (free): Source control and deployment pipeline
- Stripe Account (free): Processing test-mode payments for booked services

### Recommended AI tools

- Cursor: AI code editor for iterative full-stack component and database schema design
- Claude Code: Terminal agent for scaffolding multi-file routes, database schemas, and API integrations

### Stack

- Frontend: Next.js with Tailwind CSS and shadcn/ui
- Backend: Next.js App Router API Routes
- Database: Turso (SQLite at the edge)
- Auth: better-auth
- Payments: Stripe
- Other: Resend for transactional email notifications, Twilio for SMS reminders, Inngest for durable background jobs

### Hosting

- Cloudflare (Hosting Next.js frontend and edge API endpoints): $0-5/mo

### Build guide

1. **Scaffold Project & Database Schema** — Initialize Next.js project with Tailwind CSS, configure Turso SQLite connection, and define database schemas for users, meeting types, bookings, and availability schedules.

```
Scaffold a new Next.js project with TypeScript, Tailwind CSS, and Drizzle ORM configured for Turso SQLite. Create database tables for users, event_types (title, duration, price, description, buffer_time), bookings (host_id, client_name, client_email, start_time, end_time, status, stripe_payment_id), and availability_schedules (user_id, day_of_week, start_time, end_time). Ensure strict foreign key constraints and timestamp indices. Add validation schemas using Zod for all incoming request bodies.
```

2. **Authentication & Host Profile Setup** — Integrate better-auth for secure host login and build profile settings to manage username slugs and branding.

```
Configure better-auth in the Next.js app supporting email/password and Google OAuth. Implement protected dashboard routes where a logged-in user can configure their profile slug (e.g., /app/username), upload an avatar, set their default timezone, and manage their general settings. Create a public profile page route at /[slug] that fetches the user's active meeting types and renders them cleanly.
```

3. **Availability Calculation & Booking Engine** — Build the core booking availability engine that computes open time slots based on weekly schedules and existing appointments.

```
Build an API route /api/availability that accepts a userId, eventTypeId, and date range. The endpoint must evaluate the host's weekly availability templates, subtract existing confirmed bookings and buffer times, account for the client's timezone, and return an array of available start slots. On the frontend, build an interactive datepicker and time slot selection UI for clients visiting /[slug]/[eventType].
```

4. **Stripe Payments & Booking Confirmation** — Integrate Stripe Checkout to capture payment before finalizing appointment creation.

```
Implement Stripe Checkout integration for paid meeting types. When a client selects a slot and submits their contact details, create a Stripe Checkout session with metadata containing the eventTypeId, hostId, slot start/end time, and client details. Set up a Stripe webhook endpoint (/api/webhooks/stripe) that listens for checkout.session.completed events, securely verifies signatures, creates the confirmed booking record in Turso, and triggers confirmation emails.
```

5. **Google Calendar Two-Way Sync** — Connect host Google Calendar via OAuth to block busy times and push confirmed bookings.

```
Implement Google Calendar OAuth connection in the user dashboard. Store encrypted refresh tokens securely. Write a background service utility that fetches free/busy calendar intervals from Google Calendar API when computing available slots, and automatically creates a calendar event with a Google Meet link when a new booking is finalized via Stripe webhook.
```

6. **Automated Reminders & Polish** — Configure durable background jobs via Inngest to send automated email and SMS reminders before meetings.

```
Integrate Inngest for background job processing. Create an event-driven function triggered upon booking creation that schedules reminder events to be sent 24 hours and 1 hour before the meeting start time. Use Resend to send HTML email notifications and Twilio to send SMS reminders containing appointment details and rescheduling links. Build a host dashboard view displaying upcoming revenue stats and client lists.
```

### Cost vs paying

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

- AI Coding Assistant Pro subscription: $20
- Custom domain name (optional): $12
- Total: ~$32 one-time

**Ongoing costs (monthly):**

- Cloudflare Edge Hosting: $0-5/mo
- Twilio SMS usage (personal volume): ~$2/mo
- Resend Email API (free tier): $0/mo
- Total: ~$5/mo

- Paying for the SaaS instead: $28/mo (Pro Plan)
- Build time: 35-50 hours
- AI tool credits: $20 one-time (Cursor/Claude Pro)
- Break-even: 1 month

## Sources

- [Zencal Official Website & Platform Pages](https://zencal.io)
- [Zencal Pricing Page](https://zencal.io/pricing)
- [Zencal Help Center & Documentation](https://zencal.io/help)