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

> Time tracking + invoicing with two-way Jira sync

- Site: https://tallymeter.com
- Category: Productivity SaaS
- Verdict: **Solid side project** (75/100 vibecodeable)
- Estimated effort: 2-3 weekends of focused coding

## Verdict

Build a personal clone if you want custom agent time-billing; otherwise, the €9/month fee is vastly cheaper than maintaining your own sync glue and MCP server.

At €9/month, buying Tallymeter is mathematically rational if you just need the tool. However, building a personalized clone with Next.js, Turso, and a custom MCP server is a rewarding weekend-to-weekend project if you want your AI coding agents (like Claude Code) to log billable hours natively into your own private database schema without third-party dependencies.

### What you can't replicate

- The managed infrastructure and continuous uptime of the official SaaS
- Out-of-the-box native listing in official AI tool registries

## What it does

A streamlined, agent-ready time-tracking and invoicing tool designed for solo operators and developers with a one-click timer, date-range reports, PDF invoices, two-way Jira sync, and a native Model Context Protocol (MCP) server.

### Core features

- One-click timer state management (start, stop, resume, live duration)
- Daily-grouped time entries list with project tagging and rate overrides
- Date-range reports with daily totals, task breakdowns, and CSV export
- Numbered PDF invoice generation with line items, tax, and company details
- Two-way Jira Cloud worklog sync (push tracked time up, pull worklogs down)
- Secure token-authenticated REST API for automation
- Streamable HTTP Model Context Protocol (MCP) server for AI agent fleets

## The business

### Pricing

- Tallymeter Pro: €9/mo — The only plan, includes all features, unlimited projects, Jira sync, and MCP server access.

Founded 2026.
Team size: Solo / Small indie team.

## The hard parts

- Implementing a Streamable HTTP Model Context Protocol (MCP) server with scoped bearer tokens and safe tool definitions
- Building robust two-way Jira sync with idempotent reconciliation, error handling, and conflict detection
- Generating pixel-perfect, multi-page numbered PDF invoices with reliable table formatting

## How to vibe code Tallymeter

### Prerequisites

- Node.js LTS (free): Runtime environment for the full-stack TypeScript application.
- GitHub (free): Source code repository and CI/CD deployment pipeline.
- Cloudflare account (free): Edge hosting for the Next.js application and serverless SQLite database.

### Recommended AI tools

- Claude Code: Terminal-based AI agent to scaffold the Next.js app, API routes, and custom MCP server endpoints.
- Cursor: For fine-tuning UI components, styling PDF invoice templates, and verifying day-grouped time entries.

### Stack

- Frontend: Next.js (App Router) with Tailwind CSS and shadcn/ui
- Backend: Next.js API Routes and custom Streamable HTTP MCP endpoint
- Database: Turso (libSQL/SQLite at the edge)
- Auth: better-auth with token-based personal access tokens for API/MCP access
- Payments: None (personal use clone)
- Other: React-PDF for invoice generation, @modelcontextprotocol/sdk for the MCP server

### Hosting

- Cloudflare (Hosting the full-stack Next.js app and Turso database at zero marginal cost.): $0/mo

### Build guide

1. **Project Scaffolding and Database Schema** — Initialize a Next.js application with Tailwind CSS and configure Turso with libSQL for persistent time entries, projects, and API tokens.

```
Scaffold a new Next.js 16 project using TypeScript, Tailwind CSS, and App Router. Set up Drizzle ORM configured for Turso (SQLite). Create a database schema with tables for users, projects (id, name, color, hourly_rate), time_entries (id, project_id, description, started_at, ended_at, duration_seconds, source, agent, billed_invoice_id), api_tokens (id, user_id, name, token_hash, scopes), and invoices (id, workspace_id, client_name, issue_date, due_date, status, total_amount). Ensure indexes are added for fast date-range filtering on time entries. Verify the setup with a local migration script.
```

2. **Core Timer and Dashboard UI** — Build the clockify-style web tracker interface allowing users to start, stop, and resume timers with day-grouped lists.

```
Build a responsive time-tracker dashboard in Next.js using shadcn/ui components. Implement a top active timer bar where users can type a description, select a project dropdown, and hit start/stop. Display historical time entries grouped by day with weekday headers and live total durations. Implement client-side polling or state refresh when a timer is running. Add an inline editing capability for entry descriptions and project assignments without needing to split or restart sessions.
```

3. **Reports and PDF Invoice Generation** — Implement date-range aggregation reports, CSV exports, and client-ready numbered PDF invoice layouts.

```
Create a reports page with date-range filters, total hours calculation, unbilled amount sums, a daily breakdown chart, and a one-click CSV export button. Build an invoice generator view that aggregates unbilled entries into line items, allows adding manual line items (e.g. expenses), computes subtotal and taxes, and renders a clean, professional numbered PDF invoice using React-PDF or server-side HTML-to-PDF rendering with repeating table headers.
```

4. **REST API and Token Authentication** — Implement a secure token-authenticated REST API supporting timer controls and entry updates.

```
Build a secure REST API under /api/v1/ with Bearer token authentication validated against the api_tokens table. Implement endpoints: GET /api/v1/timer (current status), POST /api/v1/timer/start, POST /api/v1/timer/stop (idempotent), GET /api/v1/projects, and PATCH /api/v1/entries/{entry} (updates description/project in place if unbilled). Return standard JSON error structures with 401, 403, 409, and 422 status codes according to standard conventions, and enforce a 120 requests/minute rate limit.
```

5. **Native Model Context Protocol (MCP) Server** — Expose a Streamable HTTP MCP server so AI coding assistants can manage timers and log time natively.

```
Implement a native Model Context Protocol (MCP) server over Streamable HTTP at endpoint /mcp using the official TypeScript MCP SDK. Authenticate incoming requests using the same Bearer token mechanism. Register tools: timer-status, start-timer, stop-timer, list-projects, log-time, update-entry, unbilled-summary, and send-feedback. Ensure all tools include human-readable titles, safety annotations (read-only/idempotent hints), and tag created time entries with source='mcp' and the specific agent name from the token.
```

### Cost vs paying

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

- Custom domain (optional): $12/yr
- Total: ~$12 one-time

**Ongoing costs (monthly):**

- Cloudflare & Turso free tiers: $0/mo
- Total: $0/mo

- Paying for the SaaS instead: €9/mo (~$10/mo)
- Build time: 16-24 hours
- AI tool credits: $20 (Claude Pro)
- Break-even: Never (SaaS is cheaper unless built for learning or custom extensions)

## Sources

- [Tallymeter Home Page](https://tallymeter.com)
- [Tallymeter API Documentation](https://tallymeter.com/docs/api)
- [Tallymeter Changelog](https://tallymeter.com/changelog)