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

> All-in-one time tracking, billing, and budgeting across your tools

- Site: https://everhour.com
- Category: Productivity & Time Tracking
- Verdict: **Serious undertaking** (38/100 vibecodeable)
- Estimated effort: 3-5 months of serious development

## Verdict

You can build a standalone personal web dashboard for time tracking and budgeting, but replicating the multi-platform footprint and browser extensions injected into 40+ third-party tools is a massive undertaking.

Everhour is not just a simple timer app; it is an integration-heavy ecosystem spanning a full-stack SaaS web app, a macOS menu bar client, native mobile apps, an Apple Watch extension, and browser content scripts that manipulate foreign DOM trees. While an AI coding agent can scaffold the core Postgres database, Next.js frontend, and basic timer logic quickly, maintaining browser extension injection scripts across changing third-party SaaS apps (Asana, Linear, Jira) introduces endless maintenance drag. Furthermore, managing dated billing rates, complex budgeting alerts, and multi-currency invoices requires rigorous relational database architecture. For personal use, paying for the tool is infinitely more pragmatic unless you restrict your scope strictly to a self-hosted standalone timer.

### What you can't replicate

- Official marketplace distribution and verified native integrations with 40+ project management tools
- The massive historical trust and 10,000+ team network effect
- Flawless cross-platform maintenance across web, macOS menu bar, iOS, Android, and watchOS

## What it does

A time tracking, budgeting, project billing, and resource planning platform that embeds directly into popular project management tools like Asana, ClickUp, Jira, and Linear.

### Core features

- Time tracking & timesheets with locking rules
- Project budgeting and automated alerts (75%, 90%, 100%)
- Billable hours calculation and multi-currency invoicing
- Resource planning and PTO accrual tracking
- Browser extension injecting timers into third-party apps
- Multi-user role-based access control and approvals

## The business

### Pricing

- Free: $0
- Team: $8.50/mo — Billed annually, minimum 5 seats required
- Custom: Custom — Minimum 50 seats

Founded 2015.
Team size: 15-20.

## The hard parts

- Building a reliable browser extension that injects UI elements into rapidly changing third-party apps like Asana and Linear without breaking layouts or triggering CSP errors
- Bi-directional real-time webhook sync across multiple external task trackers without rate-limit or data-drift issues
- Multi-tiered relational financial data model handling dated cost/billing rate histories without corrupting historical profit reports
- Cross-platform client footprint covering a web app, a macOS menu bar utility, iOS/Android apps, and a watchOS companion app

## How to vibe code Everhour

### Prerequisites

- Node.js (free): Required runtime for the Next.js full-stack web application and build tools.
- GitHub (free): Source control and deployment pipeline integration.
- Supabase Account (free tier): Provides hosted PostgreSQL database, instant row-level security, and authentication.

### Recommended AI tools

- Claude Code: Terminal-based agentic coding tool capable of scaffolding multi-file Next.js features, database migrations, and debugging backend sync logic autonomously.
- Cursor: AI-native code editor ideal for iterative UI component refinement and reviewing complex financial calculation logic.

### Stack

- Frontend: Next.js (React) with Tailwind CSS and Shadcn UI
- Backend: Next.js Server Actions / API Routes
- Database: Supabase (PostgreSQL with Row Level Security)
- Auth: better-auth
- Payments: Stripe
- Other: Resend for transactional budget alert emails, WXT framework for building cross-browser extension scripts

### Hosting

- Vercel (Hosting the Next.js web application and API endpoints with zero-config preview deployments.): $0-20/mo
- Supabase (Managed PostgreSQL database and real-time user authentication store.): $0-25/mo

### Build guide

1. **Database Schema & Core Relational Data Model** — Initialize the Supabase PostgreSQL database schema with tables for organizations, users, projects, tasks, time_entries, budgets, and billable rates.

```
Using Supabase and PostgreSQL, write a comprehensive SQL migration script for a time-tracking and project-billing SaaS. Create tables for: 'organizations', 'users' (with role-based access control: admin, manager, member), 'clients', 'projects' (with fields for budget type: fixed_fee vs non_billable, budget amount, and hourly rate), 'tasks' (linked to projects), and 'time_entries' (tracking user_id, task_id, start_time, end_time, duration_seconds, billable boolean, and dated rate snapshot). Add foreign key constraints, indexes on user_id and project_id for performance, and Row Level Security (RLS) policies ensuring users can only access data within their organization.
```

2. **Authentication & Workspace Setup** — Implement authentication and workspace organization management using better-auth.

```
Set up better-auth in a Next.js App Router project connected to our Supabase PostgreSQL database. Configure email/password authentication and Google OAuth. Implement multi-tenant workspace logic where a user belongs to an organization and can be invited via email. Create onboarding pages for creating a new workspace or joining an existing one, and protect all dashboard routes behind an auth middleware check.
```

3. **Time Tracking Dashboard & Manual Entry UI** — Build the core time tracking web interface supporting both running timers and manual time logs.

```
Build a full-featured time tracking dashboard in Next.js using Tailwind CSS and Shadcn UI. Create a top bar with a live active timer component that persists state across page reloads using local storage and server sync. Add a weekly timesheet matrix view grouped by project and task, showing days of the week (Mon-Sun) with input fields for logging hours. Include a modal for creating manual time entries with date, project selector, task selector, billable toggle, and notes.
```

4. **Project Budgeting, Cost Tracking & Alert Engine** — Implement project budget management and an automated alert system checking consumption thresholds.

```
Create a project budgeting and financial calculation module in Next.js. Build a project settings view to define total budget caps (hours or monetary value) and hourly cost vs billing rates. Implement server-side calculation logic to aggregate total tracked time and compute burn percentage. Build a background job or server action check that evaluates projects when time entries are saved, triggering simulated email notifications via Resend when a project hits 75%, 90%, and 100% of its budget.
```

5. **Reporting & Profitability Analytics** — Develop flexible reporting views analyzing billable hours, team utilization, and project profitability margins.

```
Develop a comprehensive Reports analytics page in Next.js using a data table component and charting libraries. Allow users to filter time entries by date range, team member, client, project, and billable status. Calculate total tracked hours, billable amount, effective hourly rate, and profit margins. Implement functionality to save custom report views and export report data to CSV format.
```

6. **Invoicing Module from Tracked Time** — Build an invoicing generator that converts unbilled billable hours into professional client invoices.

```
Build an Invoicing module in the Next.js web application. Create an 'Invoices' database table and an interface allowing users to select unbilled billable time entries for a specific client and project range. Automatically aggregate hours and line items into a clean, printable invoice view with customizable tax rates and company details. Include status tracking (draft, sent, paid) and an option to mark invoices as paid.
```

7. **Browser Extension Scaffolding for Third-Party Injection** — Build a companion browser extension using WXT to inject simple timer buttons into target web tools.

```
Using the WXT (Web Extension Tools) framework, scaffold a browser extension supporting Chrome and Firefox. Implement a content script configured to run on match patterns for a mock task board (or local development testing page). The content script should detect task item headers in the DOM and inject a lightweight 'Start Timer' button next to them. When clicked, authenticate against our main Next.js SaaS backend via API token to start a running timer associated with that task title.
```

### Cost vs paying

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

- Domain name registration: $12
- AI coding credits: $40
- Total: ~$52 one-time

**Ongoing costs (monthly):**

- Supabase Database Pro / Vercel Hobby: $0-25/mo
- Resend Email API: $0/mo (Free tier)
- Total: ~$0-25/mo

- Paying for the SaaS instead: $42.50/mo ($8.50/seat for 5 seats)
- Build time: 80-120 hours
- AI tool credits: $20/mo (Claude Pro / Cursor Pro)
- Break-even: N/A (Built for learning and personal customization)

## Sources

- [Everhour Official Homepage](https://everhour.com)
- [Everhour Pricing Page](https://everhour.com/pricing)
- [Everhour Features Page](https://everhour.com/features)