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

> The AI Calendar That Helps You Master Your Day

- Site: https://skedpal.com
- Category: Productivity & Time Management
- Verdict: **Serious undertaking** (35/100 vibecodeable)
- Estimated effort: 6+ months of part-time work

## Verdict

Build a task list and calendar view easily, but keep paying for SkedPal because writing a production-grade time-blocking constraint solver is brutally hard.

The UI and basic task lists are straightforward to scaffold, but the core IP of SkedPal—the scheduling engine that digests task durations, rigid deadlines, preferred working hours ('Time Maps'), and external calendar events to auto-block time—is a complex constraint-satisfaction problem (RCPSP variant). Furthermore, handling bulletproof two-way calendar sync with Google and Microsoft webhooks without dropping sync tokens or creating infinite event-duplication loops involves significant engineering grit. You will spend weeks debugging edge cases in interval arithmetic and timezone shifts.

### What you can't replicate

- The exact decade-refined deterministic scheduling heuristics
- Zero-downtime calendar webhook ingestion at scale

## What it does

An AI-powered time-management and calendar-optimization web application that automatically time-blocks to-do lists, task hierarchies, deadlines, and time constraints into existing external calendars.

### Core features

- Infinite nested task lists with durations, priorities, and deadlines
- Time Maps (rule-based working hours and category allocation rules)
- Constraint-satisfaction scheduling algorithm (auto-time-blocking)
- Two-way calendar sync with Google Calendar and Microsoft Outlook
- Dynamic schedule rescheduling on the fly when events shift
- Status tracker and time budgeting analytics dashboard
- Natural language task parsing via LLM integration

## The business

### Pricing

- Core: $9.95/mo — Billed annually; includes 21-day planning window and single calendar two-way sync.
- Pro: $14.95/mo — Billed annually; includes unlimited calendar sync and instant schedule updates.

Founded 2015.
Team size: Small boutique team.

## The hard parts

- Writing a reliable constraint-satisfaction and interval-scheduling algorithm that respects hard deadlines, working windows, and overlapping meetings without hanging or infinite loops
- Robust two-way calendar sync dealing with webhook race conditions, recurring event exceptions, token refresh cycles, and timezone mismatches
- State reconciliation for dense calendar grids under rapid user adjustments
- Incremental rescheduling logic that recalculates only affected future slots efficiently

## How to vibe code SkedPal

### Prerequisites

- Node.js (free): Required runtime for building the Next.js full-stack web application.
- GitHub (free): Source control and deployment pipeline for your codebase.
- Google Cloud Console (free): Required to configure OAuth credentials and Calendar API webhooks for testing calendar sync.

### Recommended AI tools

- Claude Code: Best-in-class CLI agent for scaffolding complex full-stack apps, managing multi-file changes, and iterating on algorithmic logic.
- Cursor: Ideal IDE fork for reviewing diffs, inspecting calendar UI components, and refining frontend state management.

### Stack

- Frontend: Next.js with Tailwind CSS and shadcn/ui
- Backend: Next.js Server Actions and Route Handlers
- Database: Turso (SQLite at the edge with libSQL)
- Auth: better-auth
- Payments: Skipped (personal use clone)
- Other: Vercel AI SDK for natural language task breakdown, FullCalendar or custom grid implementation for calendar rendering

### Hosting

- Vercel (Hosting the Next.js frontend, API routes, and scheduled cron triggers): $0/mo (Hobby tier)
- Turso (Serverless SQLite database for tasks, time maps, and calendar sync tokens): $0/mo (Free tier)

### Build guide

1. **Project Scaffolding and Database Schema** — Initialize a Next.js project with Tailwind CSS, configure Turso database with Drizzle ORM, and set up better-auth for single-user authentication.

```
Initialize a new Next.js project using TypeScript and Tailwind CSS. Configure Drizzle ORM to connect to Turso (SQLite). Create database schemas for users, tasks (with fields for title, estimated duration, deadline, priority, parent_id for nested lists, status, and scheduled flag), time_maps (json rules for working hours and category windows), and calendar_events (external event cache with start/end times and source identifiers). Set up better-auth for local credential authentication so a single user can log in safely. Verify the database migrations apply correctly and build a clean landing dashboard skeleton using shadcn/ui components.
```

2. **Nested Task Management and Time Budgeting UI** — Build the task hierarchy view, prioritization board, and time-mapping configuration interface.

```
Build a responsive dashboard in Next.js featuring a sidebar navigation, a hierarchical task list supporting infinite nesting (parent-child task relationships with collapsible subtasks inline), and a Prioritization Board view where tasks can be reordered by relative priority. Create a 'Time Maps' settings page where users can define weekly working hours windows (e.g., Monday 9am-5pm) and allocate specific time zones or categories (Deep Work, Admin, Personal). Store these settings in the Turso database with proper validation rules using Zod.
```

3. **External Calendar Integration (Google Calendar API)** — Implement OAuth connection flow and API sync to pull external calendar events into the local cache.

```
Implement Google Calendar API integration. Create an OAuth flow route to connect a user's Google account and securely store refresh tokens in the database. Write a background sync service using Next.js route handlers that fetches calendar events for a 60-day window, handles pagination and timezone conversions, and upserts them into the local calendar_events table. Set up a webhook subscription endpoint to receive instant notifications from Google Calendar when events change, updating the local cache accordingly.
```

4. **The Core Scheduling Engine (Constraint-Satisfaction Solver)** — Develop the deterministic scheduling algorithm that auto-blocks tasks into available calendar slots according to Time Maps and deadlines.

```
Write a robust server-side scheduling engine in TypeScript that implements interval scheduling and constraint satisfaction. The algorithm must: 1. Read uncompleted tasks sorted by priority and deadline. 2. Fetch all existing calendar events and user Time Maps for the planning window (e.g., 21 to 60 days). 3. Compute available free slots within allowed Time Map windows that do not collide with existing calendar events. 4. Fragment tasks into chunks matching their estimated durations if necessary. 5. Assign tasks to optimal free slots, respecting deadlines and priorities. 6. Output a set of scheduled time blocks and persist them to the database. Handle edge cases where tasks cannot fit before their deadlines and flag them as overdue or unschedulable.
```

5. **Calendar UI Grid and Drag-and-Drop Rescheduling** — Create an interactive calendar view rendering both fixed external events and auto-scheduled task blocks, with manual override support.

```
Build an interactive calendar grid view (day, week, and month views) using React and Tailwind CSS that renders both synced external calendar events (read-only) and auto-scheduled task blocks (editable/draggable). Implement click-to-reschedule and drag-and-drop actions that update the task block's scheduled start and end times in the database. When a manual override or external calendar conflict occurs, trigger a lightweight re-optimization pass of the scheduling engine for the affected day to ensure downstream tasks adjust cleanly without overlapping.
```

6. **Natural Language Task Parsing and Status Tracker Polish** — Integrate LLM-based task parsing for quick entry and add the Status Tracker analytics dashboard.

```
Integrate the Vercel AI SDK with Anthropic API to provide a natural language task creation input bar. When a user types a phrase like 'Review Q3 budget for 2 hours before Friday', parse it into structured JSON fields (title: 'Review Q3 budget', duration_minutes: 120, deadline: [next Friday ISO string], priority: 'high') and save it to the database, automatically triggering the scheduler. Finally, build a 'Status Tracker' analytics page showing metrics on completed tasks versus planned tasks, time spent per category, and schedule adherence over the past week.
```

### Cost vs paying

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

- Claude Pro / Cursor Pro (1 month): $20.00
- Custom domain (optional): $12.00/yr
- Total: ~$32.00 one-time

**Ongoing costs (monthly):**

- Vercel Hobby & Turso Free Tier: $0.00
- Anthropic API credits (NL task parsing): ~$2.00/mo
- Total: ~$2.00/mo

- Paying for the SaaS instead: $14.95/mo
- Build time: 40-60 hours
- AI tool credits: $20 (1 month of Claude Pro / Cursor)
- Break-even: Never (built for learning and personal customization)

## Sources

- [SkedPal Official Website](https://skedpal.com)
- [SkedPal Pricing Page](https://skedpal.com/pricing)
- [SkedPal About Page](https://skedpal.com/about)