Skip to content
Health & Fitness Built by us

Gym Management System

Memberships, check-in, billing and trainer scheduling in one system — with the freeze, grace and pro-rata rules that cause every front-desk argument handled explicitly.

The front-desk screen. Membership state, days remaining and any outstanding balance visible before the receptionist has to say anything.

Who it's for

Built for a specific kind of business

Single-location gyms and small chains, plus studios running class-based or personal-training models. The threshold where spreadsheets stop working is usually the first month somebody's membership is disputed and nobody can prove when it was frozen.

Business type
Gym, fitness studio, CrossFit box, martial arts academy
Size
200–3,000 active members
Locations
1–6
Runs today on
Excel, a register at the desk, and WhatsApp for renewals
Decision maker
Owner or general manager

The problem

What this actually costs you today

In the words operators use, not the words software vendors use.

  • Membership expiry is tracked by whoever remembers to look

    Renewal is the entire business model, and in most gyms it depends on a receptionist noticing a date in a spreadsheet. Members lapse quietly, and the first sign is that they stopped coming two months ago.

  • Freeze and pause rules cause disputes nobody can settle

    A member travels for three weeks and asks for their membership to be paused. Whether that extends the end date, whether it counts against an annual freeze allowance, and whether it was actually approved are all questions with no recorded answer — so the argument is won by whoever is more insistent.

  • Walk-ins, day passes and members get billed inconsistently

    Different staff quote different prices for the same thing. Cash taken at the desk does not always reach a record. The daily close does not reconcile, and by the end of the month nobody tries.

  • There is no record of who actually shows up

    Attendance is the strongest predictor of whether a member will renew, and most gyms do not capture it at all — which means retention work is guesswork rather than targeted at the people who have stopped coming.

  • Personal training packages are tracked on paper by the trainer

    Sessions sold, sessions delivered, sessions remaining — held in a notebook, and disputed at exactly the moment the package runs out.

What it does

Grouped by who uses it

Feature lists organised by technical module tell you nothing about whether the software fits your team. These are grouped by the person who lives in them.

Membership plans and pricing

Owner

Plans are configuration, not code, so seasonal offers and corporate rates do not require a developer.

  • Duration-based plans — monthly, quarterly, half-yearly, annual
  • Session-based and class-pack plans with expiry
  • Peak / off-peak and single-facility access tiers
  • Joining fees, security deposits and locker charges as separate heads
  • Couple, family and corporate rates
  • Promotional pricing with automatic start and end dates

Member registration and profiles

Receptionist

Everything about a member on one screen, including the things that matter at the desk rather than in a report.

  • Registration with photo capture, ID and emergency contact
  • Health declaration and PAR-Q questionnaire on file
  • Complete membership, payment and attendance history
  • Notes visible to staff — injuries, preferences, outstanding issues
  • Family and corporate group linking

Check-in

Receptionist

The highest-frequency interaction in the building. It has to be fast, and it has to keep working when the internet does not.

  • Card, QR code and biometric check-in
  • Membership state shown instantly — active, expiring soon, expired, frozen
  • Configurable grace-period behaviour on expired memberships
  • Day-pass and guest check-in with payment capture
  • Offline-tolerant — the turnstile keeps working through an internet outage
  • Live occupancy count and peak-hour heat map

Billing, renewals, freezes and refunds

Manager

The part that generates disputes. Every rule here is explicit, configurable and logged.

  • Automatic renewal invoices ahead of expiry
  • Pro-rata calculation for mid-cycle joins, upgrades and downgrades
  • Freeze requests with an approval step, a duration cap and an annual allowance
  • Automatic end-date extension when a freeze is approved
  • Grace period with configurable access rules
  • Partial payments, instalments and outstanding balance tracking
  • Refunds and cancellations as reversing entries, never deletions
  • Receipts by WhatsApp, SMS or print

Class scheduling and trainers

Manager

For gyms where classes are the product rather than an extra.

  • Recurring class timetable with capacity limits
  • Member booking with a waitlist and automatic promotion
  • Trainer assignment, substitution and no-show handling
  • Cancellation windows and no-show penalties
  • Class attendance feeding the same analytics as gym check-in

Personal training packages

Trainer

Session-level accounting for the highest-margin product in the building.

  • Packages sold as a session count with an expiry date
  • Session booking, delivery confirmation and remaining balance
  • Member confirmation on session completion, so the count is not disputed
  • Trainer commission computed from delivered sessions
  • Expiring-package alerts before sessions are lost

Retention analytics

Owner

Attendance data is only worth capturing if something acts on it.

  • At-risk list — members whose attendance has dropped off a cliff
  • Renewal rate by plan, by joining month, and by trainer
  • Lifetime value and average membership duration
  • Expiring-in-30-days list, prioritised by attendance
  • Peak-hour utilisation for staffing decisions

Front-desk daily close

Receptionist

A cash-drawer workflow, because the alternative is a monthly reconciliation nobody completes.

  • End-of-shift cash count against recorded transactions
  • Variance flagged and explained at the point it happens
  • Payment-mode breakdown — cash, card, bank transfer, wallet
  • Shift handover summary
  • Immutable daily close record

Screenshots

The actual interface

Every screenshot uses generated demo data. No real customer, student or member record appears anywhere on this site.

  • A membership with its full state history — including the freeze that was approved in March and the seven days it added to the end date.

  • Check-in. Photo, state and days remaining — enough for the receptionist to handle a renewal conversation without opening another screen.

  • A freeze request. The annual allowance is enforced by the system, which removes the argument from the front desk entirely.

  • Daily close with a variance flagged at the point it occurred, rather than discovered at month end.

  • The at-risk list. Ranked by attendance decline rather than expiry date, because the members worth calling are the ones who stopped coming before they stopped paying.

Roles & permissions

Who can do what

Publishing this table is unusual. It is also the fastest way to show that the system was designed for a real deployment rather than for a demo.

Three roles cover almost every gym. The distinction that matters most is between what a receptionist can do at the desk and what requires a manager — because that boundary is where money goes missing.

Capabilities by role. Each row is a capability; each column is a role.
Capability Owner All locations Manager Assigned location Receptionist Assigned location Trainer Own members
Member records Owner: Full Manager: Full Receptionist: Edit Trainer: View
Register a new member Owner: Full Manager: Full Receptionist: Edit Trainer:
Check members in Owner: Full Manager: Full Receptionist: Full Trainer: Edit
Take payment and issue a receipt Owner: Full Manager: Full Receptionist: Full Trainer:
Apply a discount Owner: Full Manager: Approve Receptionist: Trainer:
Approve a freeze Owner: Full Manager: Approve Receptionist: Trainer:
Process a refund or cancellation Owner: Approve Manager: Approve Receptionist: Trainer:
Edit a completed transaction Owner: Manager: Receptionist: Trainer:
Plan and pricing setup Owner: Full Manager: View Receptionist: Trainer:
Class timetable Owner: Full Manager: Edit Receptionist: View Trainer: View
PT package sessions Owner: Full Manager: Edit Receptionist: View Trainer: Own
Daily close Owner: View Manager: Approve Receptionist: Edit Trainer:
Financial reports Owner: Full Manager: View Receptionist: Trainer:
Retention analytics Owner: Full Manager: Full Receptionist: Trainer: Own
Staff and role management Owner: Full Manager: Receptionist: Trainer:
Audit log Owner: View Manager: Receptionist: Trainer:
  • Full Full access
  • Edit Create and edit
  • View View only
  • Own Own records only
  • Approve Requires approval
  • No access
  • Enforced server-side, not by hiding UI

Technical architecture

How it is built

Skip this section if you are not technical — nothing later depends on it.

An ASP.NET Core API over PostgreSQL, with a React front-desk application built as an offline-capable PWA. The membership state machine is implemented as an explicit, tested transition table rather than as a set of boolean columns — that single decision is what makes the billing edge cases tractable.

  1. Clients

    • Front desk PWAOffline-capable, IndexedDB queue
    • Member web appBookings, packages, invoices
    • Turnstile bridgeLocal service, vendor SDK
  2. Application

    • ASP.NET Core APIREST + OpenAPI
    • Membership state machineExplicit transition table
    • Billing enginePro-rata, freezes, refunds
  3. Async work

    • Expiry & renewal jobsHangfire, scheduled transitions
    • Retention scoringAt-risk detection from attendance
    • Notification outboxWhatsApp / SMS with receipts
  4. Data

    • PostgreSQLMemberships, transitions, payments
    • Check-in ledgerIdempotency-keyed, replay-safe
    • Cash drawer sessionsImmutable once closed
The front desk keeps working through an internet outage: check-ins queue locally with idempotency keys and replay on reconnect. Payments deliberately do not.
Stack, layer by layer
  • API ASP.NET Core 8 (C#)

    Strong typing on a domain full of money and dates, and a state machine that benefits from exhaustive compile-time checking.

  • Database PostgreSQL 16, EF Core

    Memberships are a temporal, transactional problem. Range types and exclusion constraints do real work here.

  • Front desk React 19 + TypeScript, PWA with IndexedDB

    Check-in must survive an internet outage. A PWA with a local queue is the least fragile way to do that.

  • Member app Server-rendered web, installable

    Members will not install a native app for a single gym. A fast web app they can add to their home screen gets used.

  • Background jobs Hangfire

    Renewal invoices, expiry transitions and at-risk detection are scheduled work that must be inspectable and re-runnable.

  • Hardware Vendor SDK bridge for turnstiles, biometric readers and card scanners

    Gyms have existing hardware. Replacing it is usually a deal-breaker.

  • Messaging WhatsApp Business API, SMS fallback

    Renewal reminders are the highest-ROI message the business sends.

Data model highlights
  • Membership as the aggregate root, holding a current state and a full transition history
  • MembershipStateTransition — from, to, reason, actor, timestamp, and the effect on the end date
  • Plan and PlanVersion, so a price change never rewrites an existing member's terms
  • FreezeRequest with duration, approval, and a link to the transition it caused
  • CheckIn keyed on (member, timestamp) with an idempotency key from the offline queue
  • PTPackage, PTSession, and a member confirmation on delivery
  • CashDrawerSession for the daily close, immutable once closed
  • Payment and Allocation as separate tables, so one payment settles several charges
Integrations
  • Turnstile and access-control hardware over vendor SDKs
  • Biometric and RFID readers
  • WhatsApp Business API and local SMS gateways
  • Card terminals and local payment wallets
  • Accounting export in CSV, or direct to QuickBooks/Xero
Deployment topology

Single-tenant per gym or chain, deployed to a small VM or managed container host. The front-desk PWA runs on ordinary desktop hardware. Chains run one deployment with location-scoped access and consolidated reporting for the owner.

Notable engineering decisions

The trade-offs we made, and why

This is the section that separates a system somebody built from a system somebody screenshotted.

The membership state machine

Most gym software models membership status as a set of columns — is_active, is_frozen, expiry_date — and derives the member’s status by evaluating them together at read time. It works until two of them disagree, which happens the first time somebody freezes a membership that was already in its grace period.

We model it as an explicit state machine with six states:

Pending → Active → Expiring → Grace → Expired → Cancelled

          Frozen

Every transition is a row: from-state, to-state, reason, actor, timestamp, and the effect it had on the end date. The current state is a column, but it is derived from the transition history and reconcilable against it — so if the two ever disagree, that is a detectable bug rather than an invisible one.

The properties this buys are worth the extra table:

  • Illegal transitions are impossible, not merely discouraged. You cannot freeze a cancelled membership, because there is no edge from Cancelled to Frozen. The check lives in one place instead of being re-implemented at every call site.
  • The end date is never mutated in place. A freeze does not overwrite the expiry — it records a transition that adds days, and the current expiry is the plan’s original end date plus the sum of the extensions. Six months later you can still explain the date.
  • Retroactive corrections are auditable. A manager who backdates a freeze creates a new transition with a reason and their identity attached. The original stays.

The Expiring and Grace states exist because gyms treat them differently and both need distinct access rules. Expiring is still fully active but triggers renewal messaging; Grace is past the end date but still admitted, with configurable behaviour — some gyms allow full access for seven days, others allow entry but block classes.

Billing edge cases are the product

The list of cases that a naive implementation gets wrong is long enough that we treat it as the acceptance-test suite rather than as an afterthought:

  • A member joins on the 22nd of a 31-day month on a monthly plan.
  • A member upgrades from monthly to annual on day 12, having already paid the month.
  • A member freezes for 10 days, then cancels during the freeze — is the freeze refunded?
  • A member’s plan price increases on the 1st; their renewal falls on the 15th.
  • A member pays for three months in advance and then downgrades.
  • A payment bounces after the membership was already extended.

Every one of these is expressible as an ordered sequence of transitions plus a pro-rata calculation, and every calculation is stored with its inputs on the invoice line — day count, daily rate, days used, days credited — not just its result.

That decision costs a little storage and settles almost every dispute at the desk in under thirty seconds. It is the single highest-leverage thing in the billing module, and it is the thing that off-the-shelf gym software most consistently does not do.

Offline-tolerant check-in

A gym’s front desk cannot stop working because a fibre line was cut. But an offline-capable check-in is not simply “cache the member list” — the hard part is what happens when the connection comes back.

The front-desk application is a PWA holding a locally-cached snapshot of active memberships, refreshed continuously while online. When the connection drops it keeps admitting members from that snapshot and queues each check-in locally with a client-generated idempotency key.

On reconnect, the queue replays. The idempotency key means a replayed check-in that already reached the server is a no-op rather than a duplicate. Conflicts — a member who was cancelled server-side during the outage but admitted from the stale snapshot — are surfaced as a reviewable list rather than silently resolved in either direction, because both possible resolutions are wrong some of the time and only a human knows which.

Payments deliberately do not work this way. An offline payment is recorded as pending and confirmed on reconnect; the receipt is not issued until the server has it. Taking money into a queue that might fail to sync is how you end up with a member holding a receipt for a payment the system has no record of.

Demo access and customisation

See it running

A seeded demo environment is available during a call. Every member name, photo placeholder and payment record in it is generated — no real member data appears in any demo or screenshot.

Deploy as-is, or fit it to your process

As-is
3–4 weeks
Customised
8–12 weeks

Plans, pricing and freeze policy are configuration and need no development. What usually does need work is hardware integration — turnstiles and biometric readers vary enormously — so we confirm your exact models during discovery rather than after.

FAQ

Gym Management — questions we get asked

  • What happens at the desk when the internet goes down?

    Check-in continues. The front-desk application holds a local copy of the active membership list and queues check-ins in IndexedDB, so members keep getting through the turnstile. When the connection returns, the queue syncs with idempotency keys so nothing is double-recorded. Payments are the exception — those are held as pending and confirmed on reconnect, because taking money offline without a receipt is a dispute waiting to happen.

  • Can members freeze their membership themselves?

    That is a policy decision, and the system supports either. Most gyms route freeze requests through an approval step, because self-service freezing without a cap is how an annual membership quietly becomes an eighteen-month one. The annual allowance and maximum duration are both configurable, and both are enforced rather than advisory.

  • Will it work with our existing turnstile and biometric reader?

    Usually, but the honest answer depends on the model. Most access-control hardware exposes either an SDK, a local HTTP interface, or a database we can read. We confirm yours during discovery and tell you before you commit if it is one of the closed ones that would need replacing.

  • How does it handle a member who upgrades mid-cycle?

    The unused portion of the current plan is credited pro-rata, the new plan is charged from the change date, and both calculations are stored on the resulting invoice — not just their net result. When the member asks why they were charged that amount, the receptionist can show them the working.

  • Can we run more than one branch?

    Yes. Staff are scoped to their location, members can be given all-branch or single-branch access as a plan attribute, and the owner sees consolidated reporting. Cross-branch check-in is recorded against the branch where it happened.

Book a walkthrough of Gym Management.

We will show you the working system, tell you honestly what would need changing for your operation, and give you a range before you commit to anything.

30 minutes · We reply within one business day.

WhatsApp Book a call