# How to Vibe Code Your Own RescueTime (and Stop Paying for It) > Automatic time tracking and productivity management - Site: https://rescuetime.com - Category: Productivity & Time Tracking - Platforms: macOS app, Windows app, Linux app, Web app - Verdict: **Serious undertaking** (45/100 vibecodeable) - Estimated effort: 2-3 months of focused part-time development ## Verdict Build a web-only manual time tracker instead, unless you are prepared to write native desktop daemons in Rust/Swift/C++ for passive system tracking. RescueTime's core value relies on background system monitoring across operating systems, which requires building, signing, and distributing native daemons. While AI coding tools can help write the Tauri wrapper, database schemas, and Next.js frontend dashboard, dealing with OS accessibility permissions, window title hooks, idle timers, and offline local-first sync loops across macOS and Windows will require significant manual debugging and edge-case handling. ### What you can't replicate - 15 years of proprietary window-title classification mappings - The massive historical user trust and brand equity - Zero-friction cross-platform native stability across millions of distinct machine environments ## What it does RescueTime runs passively in the background to automatically monitor apps and websites, classifying them into productivity tiers, blocking distractions, and generating detailed timesheets and reports. ### Core features - Cross-platform background desktop daemons (macOS, Windows, Linux) capturing window titles and browser active URLs - Idle time detection and heuristic activity categorization engine - Distraction blocking during scheduled or manual Focus Sessions - Automated timesheets mapping activity history to client projects and tasks - Smart-fill autocompletion hints based on historical user corrections - Web dashboard with productivity scoring, charts, and filtering by date/category - Offline activity entry for manual meeting and phone call logging - Export capabilities (CSV, raw logs) ## The business ### Pricing - Solo Focus: $9/mo — Focus features for individuals - Solo+: $15/mo — Timesheets plus Focus features for individuals - Team Focus: $12/user/mo — Focus features for teams ### Funding $2.02M raised. - Seed Round (October 2007) - Y Combinator - Seed Round (September 2008) - True Ventures - Seed Round (December 2011) Investors: Y Combinator, True Ventures, Lowercase Capital Founded 2007. Team size: ~10-15. ## The hard parts - Writing reliable cross-platform background processes that hook into OS window managers (Accessibility APIs on macOS, Win32 APIs on Windows) - Navigating strict OS security permissions and avoiding anti-virus heuristics for continuous background monitoring - Designing an offline-first local buffering and sync queue in the desktop client to handle intermittent network disconnections without memory leaks - Building a robust heuristic mapping engine that fuzzy-matches raw window titles to clean application names and work projects ## How to vibe code RescueTime ### Prerequisites - Node.js (free): Required for running the Next.js web dashboard and build toolchain. - Rust & Tauri CLI (free): Required to build the cross-platform desktop application shell and system tray daemon. - GitHub (free): Source control and CI/CD repository hosting. ### Recommended AI tools - Claude Code: Best-in-class agentic coding tool for scaffolding full-stack applications, writing Rust/TypeScript bindings, and iterating through complex debugging loops. - Cursor: Ideal for inspecting UI diffs, refining React dashboard components, and making surgical edits to the Next.js frontend. ### Stack - Frontend: Next.js with Tailwind CSS and shadcn/ui - Backend: Next.js API Routes / Server Actions - Database: Turso (SQLite at the edge for cloud dashboard sync, with local SQLite cache in the Tauri app) - Auth: better-auth - Payments: None (personal clone) - Other: Tauri v2 for cross-platform desktop client packaging, PostHog for product analytics and telemetry ### Hosting - Vercel (Hosting the Next.js web dashboard and API endpoints): $0/mo - Turso (Serverless edge database for syncing activity logs and project timesheets): $0/mo ### Build guide 1. **Scaffold Monorepo and Database Schema** — Initialize a monorepo containing the Next.js dashboard and the Tauri desktop client wrapper, setting up Turso SQLite and better-auth tables. ``` Create a new Next.js project with Tailwind CSS, TypeScript, and shadcn/ui. Set up a Turso SQLite database connection using Drizzle ORM. Define database tables for users, activity_logs (id, user_id, window_title, app_name, url, duration_seconds, timestamp, productivity_score), projects, and timesheet_entries. Integrate better-auth for user session management with email/password support. Ensure all schema definitions and environment configuration files are fully written out. ``` 2. **Build Desktop Client Daemon with Tauri and System Tray** — Implement the native desktop background process in Tauri that runs in the system tray, handles permissions, and manages polling intervals. ``` Configure a Tauri v2 desktop application wrapper inside the workspace. Implement a Rust background loop that runs every 5 seconds to query the operating system (using macOS Accessibility/Window APIs and Windows win32 APIs) to extract the currently active foreground application name, window title, and active browser URL (via browser integration hooks). Add a system tray menu with options for 'Dashboard', 'Pause Tracking', and 'Quit'. Handle edge cases where OS permissions are denied gracefully by showing an actionable prompt. ``` 3. **Local SQLite Buffering and Sync Engine** — Implement local-first offline caching and batch syncing in the desktop client to ensure activity logs are never lost during network drops. ``` Implement a local SQLite database inside the Tauri desktop client using rusqlite. When the background poller captures active window events, buffer them locally in batches. Create a background sync worker that flushes accumulated activity logs to the Turso cloud backend every 60 seconds over HTTPS. Implement retry logic with exponential backoff for offline states, ensuring zero data loss and no duplicate log entries upon reconnection. ``` 4. **Heuristic Classification and Rules Engine** — Build the rules engine that maps raw window titles and application names to productivity categories (Productive, Neutral, Distracting). ``` Build a classification module in the Next.js backend and desktop app that matches raw window titles and app bundle identifiers against user-defined rules and regex patterns. Assign default productivity scores (-2 to +2) based on common apps (e.g., VS Code = Productive, Twitter = Distracting). Build API endpoints allowing users to customize rules, view unclassified activities, and bulk-reassign categories with historical auto-correction loops. ``` 5. **Dashboard Analytics and Productivity Scoring** — Create the web dashboard UI to visualize activity breakdowns, productivity pulses, and daily score trends. ``` Build the Next.js web dashboard featuring interactive charts (using Recharts) showing daily productivity scores, time spent per application, and category breakdowns over custom date ranges. Implement summary widgets for peak productivity hours, daily totals, and weekly behavioral trends. Ensure responsive design and clean dark/light mode support using Tailwind CSS. ``` 6. **Automated Timesheets and Smart-Fill Engine** — Implement the timesheet module to map tracked activity logs to client projects with autocompletion hints. ``` Build a Timesheets module in the Next.js dashboard. Create database tables for clients, projects, tasks, and timesheet_entries. Implement a timeline view showing the user's day broken down by project. Add a smart-fill autocompletion engine that analyzes past activity logs to suggest project mappings for unassigned time chunks. Include support for setting billable rates and generating invoice summaries in CSV format. ``` 7. **Focus Sessions and Distraction Blocking** — Add Focus Sessions to the desktop client and web app to block distracting apps and URLs during deep work periods. ``` Implement Focus Sessions in the Tauri desktop app and web dashboard. Allow users to start a timed focus session or schedule recurring blocks. During an active focus session, have the desktop client actively check foreground windows against the user's 'Distracting' category list and minimize or alert when violations occur. Display active session timers in the system tray and web UI. ``` ### Cost vs paying **Starting costs (one-time):** - AI Coding Assistant subscription: $20 - Total: ~$20 one-time **Ongoing costs (monthly):** - Vercel & Turso free tiers: $0 - Total: $0/mo - Paying for the SaaS instead: $15/mo (Solo+ plan) - Build time: 40-60 hours - AI tool credits: $20 (1 month of Claude Pro / Cursor) - Break-even: 2 months ## Sources - [RescueTime Official Website](https://rescuetime.com) - [RescueTime Pricing Page](https://rescuetime.com/pricing) - [Tracxn - RescueTime Company Profile](https://tracxn.com)