Hevy logo

How to vibe codeHevy

The #1 Workout Tracker & Gym Logger App

hevyapp.com

Fitness & Health

iOS appAndroid appWeb app
68/ 100
Solid side project

The verdict: can you vibe code Hevy?

Build a focused personal workout tracker and routine planner with React Native and Expo; skip the smartwatch companion and social feed to avoid overwhelming scope.

Building a personal-use clone of Hevy's core workout logger and routine planner is a rewarding project, but offline sync and complex relational analytics require patience. While you can build the logging interface and analytics dashboards in a few weekends using Expo and SQLite, handling edge cases in local-first database state reconciliation and building out the social graph takes real engineering effort. Because Hevy Pro costs under $3/month, building this is strictly for learning and personal customization.

Estimated effort: 3-4 weeks of focused coding

What you can't replicate

  • The 15+ million active user social network and community graph
  • Deeply polished native smartwatch companion apps (Apple Watch and WearOS) for phone-free lifting

Founded

2019

Raised

Team

~13 employees

Cheapest paid tier

$2.99/mo

What Hevy does

Digital workout tracking, routine planning, and social fitness platform for weightlifters to log sets, reps, and weights, monitor PRs, and share routines.

Core features

  • Intuitive workout logging interface (sets, reps, weights, warmup/drop/failure tags)
  • Advanced routine planner with custom split creation
  • Automatic rest timers with vibration and sound notifications
  • Personal records (PRs) tracking and 1-Rep Max (1RM) calculations
  • Advanced exercise progress charts and muscle group distribution heatmaps
  • Social feed to follow athletes, like/comment on workouts, and copy training routines
  • Comprehensive exercise library with instructional guides

The business

Pricing

  • Hevy FreeFree
  • Hevy Pro$2.99/mo

Funding

Unknown / bootstrapped

Pay vs build, cumulative

Break-even at month 7 — after that, every month is money kept.

The hard parts of vibe coding Hevy

  • Offline-first mobile synchronization with local SQLite persistence and conflict-free multi-device merge upon reconnection
  • Complex relational schema computing real-time volume, 1RM curves, and progressive overload metrics across large datasets
  • Real-time social graph infrastructure with activity feeds, comments, and follower permission models

How to vibecode Hevy

Prerequisites

  • Node.jsfree

    Required for running the React Native / Expo development toolchain.

  • Expo Accountfree

    Required for building development builds and managing cross-platform mobile deployments.

  • GitHubfree

    Source control and CI/CD integration.

AI coding tools

Recommended stack

FrontendReact Native with Expo (TypeScript, Expo Router)
BackendNext.js API routes (or lightweight Node.js/Express server)
DatabaseTurso (SQLite at the edge) for backend sync + local SQLite (expo-sqlite) for offline-first caching
Authbetter-auth
PaymentsNone (personal use clone)
OtherVictory Native or Reanimated for workout charts, Zustand for local app state management

Hosting & infrastructure

CloudflareHosting the companion web app frontend and API endpoints on Workers/D1$0/mo

Build guide

  1. 01Project Scaffolding & Database Schema

    Initialize an Expo project with Expo Router and TypeScript. Define the local and remote SQLite database schemas for exercises, routines, routine_exercises, workouts, workout_sets, and sets metadata (weight, reps, type like warmup/drop/failure).

    Initialize a new Expo React Native app using TypeScript and Expo Router. Set up a robust folder structure with directories for components, screens, hooks, and services. Create an SQLite database initialization script using `expo-sqlite` that defines tables for `exercises` (id, name, muscle_group, category), `routines` (id, title, notes), `routine_exercises` (routine_id, exercise_id, order), `workouts` (id, start_time, end_time, notes), and `workout_sets` (id, workout_id, exercise_id, set_index, weight, reps, type). Ensure proper foreign keys and indexes are established for high-performance offline queries.
  2. 02Exercise Library & Custom Exercise Management

    Build the exercise library screen with category filters, muscle group tags, and the ability for users to create custom exercises stored locally and synced remotely.

    Build an Exercise Library screen in Expo Router that displays a searchable, filterable list of exercises grouped by primary muscle group (Chest, Back, Legs, Shoulders, Arms, Core). Include a modal form allowing users to create custom exercises with name, category, and muscle group fields. Save these entries to the local SQLite database with a sync-pending flag, and render clean badge components for muscle groups using React Native primitives.
  3. 03Routine Planner

    Implement the routine planning interface where users can group exercises into reusable workout templates with target sets and reps.

    Create a Routine Planner interface. Allow users to create, edit, and delete named workout routines (e.g., 'Push Day A'). Inside a routine editor view, users should be able to add multiple exercises from the library, reorder them via drag-and-drop or list controls, and pre-define target working sets. Persist routine configurations locally with relational mapping between routines and exercises.
  4. 04Active Workout Logging Screen

    Build the core active workout session tracker featuring set logging, previous performance reference, set type tags (Warmup, Drop, Failure), and live rest timers.

    Develop the active workout logging screen. When a user starts a routine, spawn an active workout session tracking elapsed time. For each exercise, render a table of sets where users input weight and reps. Display the user's previous performance for that exercise/set directly above current inputs for progressive overload reference. Add a picker or toggle on each set row for set types: Normal, Warmup, Drop Set, and Failure. Include a floating or sticky rest timer component that triggers automatically upon completing a set, featuring customizable duration presets and audio/vibration feedback.
  5. 05Progress Analytics & Charts

    Implement exercise history charts, personal records (PR) detection, and estimated 1-Rep Max calculations.

    Build an exercise progress analytics screen using a React Native charting library (such as Victory Native). For any selected exercise, query historical workout sets to compute and plot max weight lifted over time, total volume per session, and estimated One-Rep Max (1RM) using the Epley formula: `weight * (1 + reps / 30)`. Highlight personal records (PR) clearly on the chart and in exercise history lists.
  6. 06Backend Sync & Companion Web View

    Set up a lightweight backend API and web frontend companion view to view workout logs and routines on desktop screens.

    Create a companion web view using Next.js and Tailwind CSS that connects to a shared Turso database via better-auth. Build a clean dashboard displaying historical workout logs, exercise progress graphs, and routine management tools optimized for desktop viewports so users can plan workouts from their computers.

Cost vs paying for Hevy

What will you build it with?

Est. 6.5M in / 1.8M out tokens· Includes access to introductory usage of the default model with dynamic rate limits.$0

Starting total with Claude Code$0 one-time

Starting costs (one-time)

  • Expo / GitHub accounts$0
  • AI coding credits$20

Total~$20 one-time

Ongoing costs (monthly)

  • Turso & Cloudflare free tier$0/mo

Total$0/mo

Paying for Hevy

$2.99/mo

Your time to build

45-60 hours

AI tool credits

$20 (one month of Claude Pro / Cursor)

Break-even

Never (paying $2.99/mo for Hevy Pro is far cheaper than valuing your development time)

Vibe code Hevy: FAQ

Can you vibe code Hevy yourself?
Solid side project — 68/100 vibecodeable. Build a focused personal workout tracker and routine planner with React Native and Expo; skip the smartwatch companion and social feed to avoid overwhelming scope.
How long does it take to vibe code Hevy?
3-4 weeks of focused coding — roughly 45-60 hours of hands-on time with an AI coding agent.
How do you build your own Hevy?
Scoped to personal use: React Native with Expo (TypeScript, Expo Router) on the front, Next.js API routes (or lightweight Node.js/Express server) behind it, Turso (SQLite at the edge) for backend sync + local SQLite (expo-sqlite) for offline-first caching for data. Follow the 6-step build guide on this page — each step has a paste-ready prompt for an AI coding agent.
How do you code your own Hevy without being an expert?
Use an AI coding tool (Claude Code or Cursor) and work in small steps: scaffold, data model, core screens, then deploy. Realistic effort: 3-4 weeks of focused coding. The prompts on this page are written so the AI does the heavy lifting.
How much does it cost to vibe code Hevy instead of paying?
About ~$20 one-time to start and $0/mo to run, versus $2.99/mo for Hevy. Break-even: Never (paying $2.99/mo for Hevy Pro is far cheaper than valuing your development time).
What stack should you use to vibe code Hevy?
React Native with Expo (TypeScript, Expo Router); Next.js API routes (or lightweight Node.js/Express server); Turso (SQLite at the edge) for backend sync + local SQLite (expo-sqlite) for offline-first caching; plus Victory Native or Reanimated for workout charts, Zustand for local app state management.

Sources

Alternatives & community builds

All alternatives →