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

> Intensive workouts & individual training plans

- Site: https://freeletics.com
- Category: Fitness & Health
- Platforms: iOS app, Android app
- Verdict: **Serious undertaking** (42/100 vibecodeable)
- Estimated effort: 4-6 weeks of intensive development and debugging

## Verdict

You can build a personal workout tracker and basic rule-based plan generator, but the deep exercise catalog, video asset pipeline, and adaptive physiological progression engine require substantial multi-platform mobile engineering.

Building a clone of Freeletics for personal use means tackling cross-platform mobile state management, local video caching, and a complex scheduling algorithm that calculates progressive overload based on daily user feedback. While an AI agent can rapidly scaffold the Expo/React Native UI, local database schema, and basic timer components, you will spend weeks debugging offline sync edge cases, managing video storage pipelines, and refining the deterministic rules engine so it doesn't output physiologically absurd workout routines.

### What you can't replicate

- 60 million user community and engagement network
- Professional studio-produced library of 700+ exercise demonstration videos
- Proprietary sports science coaching datasets and validated progression matrices

## What it does

Digital fitness and personal coaching platform centered on high-intensity interval training (HIIT), calisthenics, bodyweight workouts, and an adaptive AI Coach.

### Core features

- Adaptive workout generator (AI Coach) adjusting to user feedback and recovery
- 700+ exercise library with high-definition video demonstrations
- Multi-week progressive overload and training plan scheduling
- Offline workout mode with local data caching and persistence
- Workout logging, interval timers, and audio/visual rep counters
- Cross-platform sync for user progress history and statistics

## The business

### Pricing

- Free: Free — Limited access to basic bodyweight workouts and standard exercise libraries.
- Freeletics Coach (Training Subscription): $34.99/mo — Personalized, dynamically evolving training plans with multi-month discount options.

### Funding

$70M raised.
- Seed Round (August 2018)
- Series A (December 2018) - $45M
- Series B (September 2020) - $25M
Investors: FitLab, Causeway Media Partners, JAZZ Venture Partners, Courtside Ventures, Elysian Park Ventures, Tony Robbins, KKCG

Founded 2013.
Team size: 100-150.

## The hard parts

- Deterministic-meets-heuristic workout progression engine adhering to strict physiological rules of recovery and progressive overload
- Smooth offline playback and caching of hundreds of high-definition exercise demonstration videos on mobile devices
- Complex cross-platform mobile app store billing entitlements and subscription state management
- Cross-device synchronization of offline training logs without race conditions or data corruption

## How to vibe code Freeletics

### Prerequisites

- Node.js (free): Required to run Expo, TypeScript compiler, and local development tooling.
- Expo Account & EAS (free): Required for building and testing the React Native application on physical iOS and Android devices.
- GitHub (free): Repository hosting for version control and CI/CD triggers.

### Recommended AI tools

- Claude Code: Best-in-class terminal agent for scaffolding complex multi-file React Native schemas, local SQLite persistence layers, and workout state machines.
- Cursor: Essential for iterative UI component styling, gesture handling, and tuning the interactive interval timer screens.

### Stack

- Frontend: React Native with Expo (TypeScript, Expo Router)
- Backend: Local SQLite database via expo-sqlite (offline-first architecture)
- Database: SQLite / Turso (for optional cloud sync)
- Auth: better-auth (self-hosted local token management)
- Payments: none (personal use clone)
- Other: Expo AV for exercise video playback, Expo Notifications for workout reminders

### Hosting

- Cloudflare (Hosts the optional backend sync API and stores exercise video assets in R2 object storage with zero egress fees.): $0-5/mo

### Build guide

1. **Initialize Expo React Native Project with Local SQLite** — Scaffold a new React Native application using Expo Router and TypeScript. Configure expo-sqlite to establish a local-first relational database storing user profiles, exercise dictionaries, workout templates, and completion logs.

```
Create a new Expo TypeScript project using Expo Router named 'freeletics-clone'. Configure file-based navigation for tabs: Today, Coach, Exercises, Profile. Install expo-sqlite and set up a local database initialization script that creates tables for users, exercises (id, name, muscle_group, video_url, description), workout_plans, workout_blocks, and workout_logs. Write a migration script that pre-populates 20 common bodyweight exercises (pushups, squats, burpees, climbers) with placeholder video URLs and metadata. Ensure all database operations are wrapped in safe async helper functions with TypeScript interfaces.
```

2. **Build the Exercise Library & Cached Video Player UI** — Develop the exercise catalog screen featuring search, category filters, and detail views containing video playback via Expo AV with local caching capabilities.

```
Build an Exercise Library screen in React Native using Expo Router. Implement a searchable list with category chips (Core, Upper Body, Lower Body, Cardio). Tapping an item should open an Exercise Detail screen featuring an Expo AV video player loop, instructions list, and muscle group target tags. Implement local caching for video assets using expo-file-system so videos can be replayed offline without re-fetching. Ensure the UI follows a dark fitness aesthetic (deep charcoal background #121212, bright accent #E5FF00) with smooth touch feedback.
```

3. **Implement the Workout Player & Interval Timer Engine** — Create an immersive workout execution interface with countdown timers, audio/vibration feedback for interval transitions, and set completion logging.

```
Implement the active Workout Execution screen in React Native. The screen must support a multi-exercise circuit timer with countdowns, rest periods between sets, and audio/vibration cues using expo-av and expo-haptics. Include controls to pause, skip, or mark sets complete. Upon finishing the workout, calculate total duration, calories burned estimate, and record the session timestamp and completed rep counts into the local SQLite workout_logs table. Add a summary celebration screen showing completed metrics.
```

4. **Develop the Adaptive AI Coach Logic & Plan Generator** — Write a deterministic scheduling and adaptation engine that evaluates user feedback (soreness rating, available time, equipment) to generate weekly workout progressions.

```
Build a TypeScript coaching engine module that generates weekly workout plans based on user parameters (fitness goal: strength/weight loss, available equipment: bodyweight/gym, weekly training days). Implement a feedback ingestion function that accepts daily post-workout inputs (e.g. soreness_level: 1-5, perceived_exertion: 1-5). If soreness in specific muscle groups is high, the engine must dynamically substitute conflicting exercises in upcoming workouts with alternate movements from the database while maintaining progressive overload principles. Display the generated weekly schedule on the Coach tab.
```

5. **Build Progress Tracking & Statistics Dashboard** — Create analytical views and charts tracking workout streaks, completion history, and strength progression over time.

```
Develop a Progress Dashboard screen in React Native querying local SQLite logs. Display a weekly activity heatmap or streak counter, total workouts completed, total training time, and a breakdown of muscle groups trained. Include a history log list showing past workout sessions with expandable details. Ensure the layout is responsive and performs efficiently with hundreds of logged records.
```

6. **Configure Cloudflare R2 Asset Storage & Optional Cloud Sync** — Set up remote backup sync so local workout logs can optionally be backed up to a Cloudflare D1/Workers backend.

```
Create a lightweight Cloudflare Worker API using TypeScript and D1 database to receive encrypted backups of local user workout logs. In the React Native app, add a settings screen toggle for 'Cloud Backup' that batches local unsynced logs and pushes them via fetch when an internet connection is detected. Handle network failure gracefully with retry queues and local sync state flags.
```

### Cost vs paying

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

- Expo EAS Build credits (optional): $0
- Total: $0 one-time

**Ongoing costs (monthly):**

- Cloudflare Workers & R2 storage: $0-5/mo
- Total: $0-5/mo

- Paying for the SaaS instead: $34.99/mo
- Build time: 40-60 hours
- AI tool credits: $20 (Claude Pro / Cursor Pro)
- Break-even: Instant (personal clone)

## Sources

- [Freeletics Official Website](https://www.freeletics.com)
- [Freeletics Help Center - Pricing & Subscription FAQ](https://support.freeletics.com)
- [Crunchbase News - Freeletics Raises $45M Series A](https://news.crunchbase.com)
- [Tracxn - Freeletics Company Profile & Financials](https://tracxn.com)