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

> Automatic time tracking built for privacy

- Site: https://memtime.com
- Category: Productivity & Time Tracking
- Platforms: macOS app, Windows app, Linux app, Web app
- Verdict: **Serious undertaking** (42/100 vibecodeable)
- Estimated effort: 3-5 weeks of focused engineering

## Verdict

Build a personal single-platform subset for your own machine, or keep paying for the production app if you need multi-app ecosystem sync.

Cloning Memtime for personal use means writing native desktop daemons in Rust or Node/Tauri to poll active window handles, titles, and file paths across OS permissions barriers. While an AI agent can generate the UI dashboard and SQLite schema, you will spend weeks debugging native accessibility hooks, macOS TCC permission prompts, and background event loops that don't crash or drain your laptop battery.

### What you can't replicate

- Pre-built native sync connectors to 100+ commercial project management tools
- Certified compatibility with corporate Citrix and Windows Terminal Server environments
- Enterprise security audit certifications and zero-trust offline guarantee compliance

## What it does

An automatic time tracking desktop application that records active programs, documents, and browser tabs offline, displaying them on a chronological timeline to reconstruct billable hours.

### Core features

- Background OS foreground window monitoring (Windows Win32, macOS Accessibility APIs, Linux X11/Wayland)
- Local SQLite activity database running entirely offline on user device
- Chronological timeline UI (Memory Aid) with zoomable 1-minute to 60-minute increments
- Browser tab title and active file path extraction
- Calendar sync (CalDAV, Google, Outlook)
- Time entry creation and grouping rules against built-in projects

## The business

### Pricing

- Basic: $18/mo — For freelancers and small teams not using external project software.
- Connect: $26/mo — For teams using external project management software.
- Premium: $35/mo — For teams requiring call system integrations and advanced auth.

### Funding

$588K raised.
- Seed / Early Stage
Investors: BayBG (Bayerische Beteiligungsgesellschaft), Bayern Kapital, APEX Ventures

Founded 2015.
Team size: ~36.

## The hard parts

- Cross-platform native OS monitoring code requiring specialized accessibility permissions and platform-specific window hooks
- High-frequency background logging without causing CPU spikes, battery drain, or uncontrolled local SQLite database bloat
- Timeline clustering heuristics that group rapid window-switching noise into clean, human-readable blocks

## How to vibe code Memtime

### Prerequisites

- Rust & Node.js (free): Required for compiling the Tauri desktop shell and local background daemon.
- Cursor (Free tier / $20/mo): AI code editor for rapidly structuring the frontend timeline UI and backend IPC commands.

### Recommended AI tools

- Claude Code: Best-in-class agent for multi-file systems engineering, setting up Rust backend daemons, and wiring TypeScript IPC bridges.
- Cursor: Ideal for fine-tuning the complex CSS/Tailwind interactive timeline grid and zoom intervals.

### Stack

- Frontend: Next.js
- Backend: Tauri
- Database: Turso
- Auth: better-auth
- Payments: none
- Other: Rust, Tailwind CSS, SQLite (local)

### Hosting

- Cloudflare (Optional web portal dashboard sync): $0/mo

### Build guide

1. **Scaffold Tauri Desktop Shell with Rust Backend** — Initialize a Tauri desktop application project with a React/Next.js frontend and a Rust core daemon capable of executing system-level background loops.

```
Create a new Tauri project configured with Next.js for the frontend and Rust for the backend. Set up the Rust structure to run a background tokio thread that ticks every 5 seconds. This background thread must use platform-specific crates (like active-win-pos-rs or native OS bindings) to capture the current active window title, application executable name, and timestamp. Ensure proper error handling for cases where accessibility permissions are denied by the operating system.
```

2. **Implement Local SQLite Storage and Data Rotation** — Build a robust local SQLite database layer via Rust to store high-frequency activity logs securely on disk without memory leaks.

```
Write a SQLite storage module in Rust using rusqlite or sqlx to persist captured window events locally inside the user's application support directory. Define an 'activities' table storing id, app_name, window_title, start_time, end_time, and duration. Implement a batch-writing queue so events collected every 5 seconds are flushed to disk efficiently without locking the database or causing high CPU overhead. Add a cleanup migration that archives or prunes raw logs older than 90 days to manage disk space.
```

3. **Build the Interactive Chronological Timeline UI** — Develop a high-performance timeline component in the frontend that visualizes 24 hours of activity blocks with zoomable increments.

```
Build a React timeline component using Tailwind CSS that renders a 24-hour horizontal or vertical grid divided into customizable increments (1-minute, 5-minute, and 6-minute legal slots). Expose a Tauri IPC command to fetch aggregated activity blocks for a selected date from the local SQLite database. Implement smooth zooming and panning controls that recalculate block widths dynamically. Each block should display the dominant application icon, title snippet, and duration on hover.
```

4. **Add Time Entry Grouping and Rule Automation** — Implement manual and rule-based assignment of raw timeline chunks into billable project time entries.

```
Create a project management view in the React frontend where users can define projects and tasks. Implement drag-and-select or click-to-assign functionality on the timeline grid to group raw activity blocks into a billable time entry. Write a Rust backend rule engine that scans incoming window titles against user-defined keyword rules (e.g., matching client names in browser tabs or document paths) and automatically suggests or assigns matching project IDs to activity intervals.
```

5. **Integrate Calendar Sync and Polish Local App Experience** — Incorporate CalDAV / Google Calendar syncing to overlay meetings on the timeline and package the app for daily desktop use.

```
Implement a CalDAV calendar sync client in Rust/TypeScript that fetches calendar events for the active day and renders them as background shaded blocks behind the activity timeline. Add system tray support using Tauri's tray API so the app runs quietly in the background with options to open the dashboard, pause tracking, or view daily summaries. Test the build process for macOS and Windows packaging.
```

### Cost vs paying

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

- AI Coding Assistant Subscriptions: $20
- Total: $20 one-time

**Ongoing costs (monthly):**

- Local Desktop Execution: $0/mo
- Total: $0/mo

- Paying for the SaaS instead: $26/mo (Connect Plan)
- Build time: 40-60 hours
- AI tool credits: $20 (1 month Cursor/Claude Pro)
- Break-even: 0 months (built for personal use)

## Sources

- [Memtime Official Website](https://memtime.com)
- [Memtime Pricing](https://memtime.com/pricing)
- [PitchBook Memtime Profile](https://pitchbook.com)