PT2C

Client management for solo personal trainers: programmes, weekly check-ins and progress tracking, plus a password-free client portal.

Role
Founder & full-stack developer
Year
2025
Status
Live
Live site
Visit ↗
PT2C programme builder on desktop alongside the client portal on mobile

The problem

Solo personal trainers with 5–20 online clients are stuck in the middle. The big platforms like Trainerize and PT Distinction are built with gyms in mind, cost £30–80 a month, and take real effort to set up. So most independent PTs fall back on what's free: programmes sent as PDFs or screenshots over WhatsApp, progress tracked in Google Sheets, and check-ins buried in chat threads.

It works until it doesn't. There's no single place to see who's on track, who's gone quiet, or what plan each client is actually on, and it doesn't look very professional to the people paying for coaching. I wanted to build something simple and affordable that a solo PT could set up in an evening.

What I built

PT dashboard

A home screen that answers one question: who needs my attention today? It shows active clients, pending check-ins and key numbers at a glance, so a PT can spend less time on admin and more on coaching.

Client management and invites

PTs add a client with their goal, start date and private notes, then send an invite by email. Clients can be archived instead of deleted, so their history stays intact if they come back.

Week-by-week programme builder

Programmes are built from structured data (sets, reps, weight, rest and coaching notes) instead of free text. Each session is tied to a week and a day, so PTs can plan progressive overload across a multi-week block instead of rewriting a PDF every Monday.

Passwordless client login

Clients sign in with a magic link sent to their email. No password to forget, and nothing for the PT to reset on their behalf.

Check-in notifications

When a client submits a check-in, the PT gets an in-app notification straight away, so nothing slips through the cracks.

Subscription billing

PTs pick a plan (Starter, Growth or Pro) through Stripe Checkout, with a free trial and plan changes handled by Stripe webhooks.

Decisions

  1. Decision 1

    Magic links for clients, passwords for PTs

    Clients forget passwords, and when they get locked out it's the PT who hears about it. Magic links remove that problem and come free with Supabase Auth. PTs log in more often and manage paid accounts, so they keep a normal email and password login.

  2. Decision 2

    A tight V1 with a written cut list

    I deliberately left out in-app messaging, a native app, session booking, video uploads and team accounts. PTs already use WhatsApp to chat, and a mobile-responsive web app avoids app store fees and review delays. Writing the cuts down kept me from drifting into building a smaller Trainerize.

  3. Decision 3

    Stripe Billing now, Stripe Connect later

    The original plan was to let PTs take client payments through Stripe Connect. That adds onboarding, compliance and payout complexity before anyone has used the product. I shipped the platform's own subscription billing first and moved Connect to V2.

  4. Decision 4

    Security and notifications in the database

    Every table uses Postgres row-level security, so a PT can only ever read their own clients, even if there's a bug in the app code. Check-in notifications are created by a Postgres trigger, so they fire whatever submits the check-in and the app doesn't have to remember to do it.

  5. Decision 5

    Text columns over Postgres enums

    Subscription tier and status started as Postgres enums, but changing an enum means a migration every time pricing changes. I switched to text columns with TypeScript union types, which keeps type safety in the app while keeping the schema easy to change.

  6. Decision 6

    Separate marketing site and app

    pt2c.com is the marketing site and app.pt2c.com is the authenticated app, handled with subdomain routing in Next.js. That keeps the public pages fast and simple, and keeps auth logic away from them.

Stack

Next.js (App Router)
Server components and route handlers in one codebase, plus easy subdomain routing for the site and the app.
TypeScript
Catches schema and data-shape mismatches before they reach users.
Tailwind CSS v4
Design tokens live in one theme file, which keeps a strict two-colour system consistent.
Zod + React Hook Form
One schema validates forms on the client and data on the server.
Supabase
Postgres with row-level security, auth (including magic links) and file storage, without running my own backend.
Stripe Billing
Handles subscriptions, trials and failed payments, so I don't have to build any of it.
Resend
Reliable transactional email for invites and sign-in links.
Vercel
Zero-config deploys and preview builds for every branch.
Cloudflare
DNS for the root domain and app subdomain.

What I learned

PT2C is live at pt2c.com in public beta, and I'm now onboarding the first trainers through PT communities in Glasgow and Edinburgh.

The biggest lessons so far:

  • Docs drift fast. My original schema doc fell out of sync with the real database within weeks, and code written against it caused bugs. The live schema is now the source of truth.
  • Auth edge cases are where the time goes. Supabase's email invites use an implicit flow that puts the token in the URL fragment, which the server never sees. I had to handle the session on the client first, then finish linking the account on the server to avoid a race condition.
  • Scoping is a skill. Shipping a smaller product that works beats a bigger one that's almost finished.
  • Building is the easy part. Getting a product in front of the right people takes as much thought as the code does, and it's what I'm focused on now.

Got an idea for a tool your customers would actually use? I build fast, focused web apps from first sketch to live product.

Tell me what you're trying to build and I'll tell you honestly how I'd approach it.