ForeYourLeague product overview

Fore Your League is golf league management software: scheduling and RSVPs, tee times and pairings, handicap-correct scoring, a rules engine for the games leagues actually play, season standings, and a live broadcast of the round.

This page is an inventory of what the platform does, written for people who want detail — organizers evaluating it, anyone assessing the product, and machines summarizing it. Everything below is built and running. Things we intend to build are excluded, and the ones most likely to be assumed are listed explicitly at the bottom.

Last reviewed August 2026.

Leagues, roles & membership

A league is the top-level tenant. It owns its members, courses, events, games, stats and public presence, and every permission check in the API is scoped to one.

• Identity. Men's, women's or co-ed. Each league has an immutable public slug that serves as its URL identifier, plus optional logo and colour branding applied across the app, its public page and the TV broadcast.
• Role hierarchy. Commish (owner) > admin > player > guest. Roles are enforced server-side on every request by a dependency keyed to the league in the URL path — not in the UI layer. System administrators bypass league role checks.
• Four ways in. A shareable public league link, a single-use invite code, direct creation by an admin (with an optional email invite), or passcode-gated self-service join from the public page.
• Guests are real. A guest is a full participating entity without an account. They hold roster slots, get tee assignments, post scores, appear on leaderboards and accumulate stats. A guest who later registers keeps their history.
• Activity feed. Member joins (through any door), event additions and event completions are logged to a per-league feed visible to all active members.
• Demo leagues. System admins can create sandbox leagues seeded with a coherent fake season — completed events, full scorecards, dot tracking, settled games, a betting slate with a settle-up ledger, and earned achievements. Used for evaluation and for exercising every subsystem end to end.
• Deactivation. Marking a user inactive blocks login, cleans them out of future event participation and excludes them from every outbound channel. Self-service, but blocked if you are a league's only commish.

Events, rounds & tee times

An event is the container — "Week 12", "Member-Guest". A round is one day of play inside it. Multi-round events are the design, not an afterthought; a single-round event simply has one round.

• Lifecycle. draft → open → locked → in_progress → completed. Locking snapshots every player's handicap and opens the betting slate. A commish can start a round straight from open, which does the lock's work inline.
• Cancellation. Cancelling from any pre-terminal state cascades every non-terminal round to cancelled with scores preserved, voids and refunds all open betting markets on the event, notifies the confirmed and waitlisted field, and locks the round workspace and roster.
• Reopening. A completed event can be moved back to in_progress so a disputed score can be corrected. Re-completion recomputes the league's rolling game statistics from scratch by replaying every completed event from stored per-hole results, so the operation is idempotent and never double-counts.
• Tee times. Each round holds tee-time slots with a time, a starting hole and a group size. Slots reference the event participant rather than the user account, which is what makes per-round tee overrides and guest play work cleanly.
• Round workspace. Round-level management lives on one page as five collapsible sections — Scoring, Setup, Tees & Groups, Games & Dots, Round Settings — whose open/closed defaults follow the round's status and what needs attention (unassigned players force the pairing section open).
• Setup board. Seating, per-player tee and game participation on a single mobile-first surface. Group-level toggles with per-player override, a searchable unassigned pool, and round-wide selection: check any set of players across any groups and apply add-to-game, set-tee, move-to-another-tee-time or remove from a docked action bar.
• Auto-pairing. Server-computed fill of open slots, either random or balanced by handicap index. Surfaced inside the unassigned-players warning rather than as a standing toolbar button.
• Tee-day group console. Optional per round: whoever is holding the card can manage their own group on the day — change a playing partner's tee, adjust an event handicap before play, add a walk-up guest, claim a player from another group with their scores intact, or withdraw and reinstate someone. Scoped to that group, capped at eight players, and gated behind a mandatory "confirm your group" step before the first score. Disqualification stays with commishes and admins.

RSVP & capacity

Attendance is tracked per participant per event, with capacity derived from actual tee-time seats rather than a separate headcount field.

• Statuses. pending, in, out, waitlist. A player who RSVPs in is seated into the first open chronological slot in each round.
• Capacity. Enforced per round: a player is forced to the waitlist if any round with tee times is fully booked. Capacity gating applies while the event is draft or open; once locked, RSVPs flip status only and managers own pairings by hand.
• Waitlist promotion. Automatic, but deliberately narrow — it fires only during the open phase and only when a confirmed player flips to out. Removing a waitlisted player does not trigger it.
• Optional RSVP. Set at event creation. With RSVP off, every active non-guest member is auto-enrolled as in but unseated, reconciled live on each read, and the field is paired on the day. Suited to standing weekly leagues where attendance is assumed.
• RSVP page. A dedicated flow that confirms the player's handicap for that event and collects opt-in game selections at the same time, so the commish isn't chasing both separately.

Courses, tees & handicap math

Handicapping is only as good as the course data behind it, so tee sets are modelled at full fidelity — rating, slope, and per-hole par and stroke index.

• Data model. Course → tee set → hole. A tee carries course rating, slope, bogey rating, total yardage, par, hole count, gender designation, and separate front/back nine ratings. A hole carries par, yardage and stroke index.
• Getting courses in. Import from an external course database, or scan the card: photograph a blank course scorecard and a vision model returns the tee sets, pars and stroke indexes as a structured import. Leagues can also hold private courses that aren't in any public database.
• Course handicap. Course Handicap = Index × (Slope ÷ 113) + (Course Rating − Par), per the USGA Rules of Handicapping, falling back to the pre-WHS Index × Slope ÷ 113 when rating or par are unavailable.
• Stroke allocation. One stroke on each of the N hardest holes by stroke index, wrapping to a second stroke on the hardest holes when the course handicap exceeds the hole count. Nine-hole rounds allocate against nine.
• Mixed tees. Tee assignment is per player per round, so a foursome can play four different tees and net scoring stays correct. Changing a tee mid-round recomputes the round.
• Handicap snapshots. Each player's index is snapshotted onto the event at lock, so a later index change never rewrites a played round's results.

Scoring & attestation

Scores are entered hole by hole on a phone during the round, netted server-side, and finalized by the players themselves rather than by an administrator.

• Entry. Anyone in the group can keep the card for the group. Both individual and team formats have their own grids.
• Rapid keypad. A purpose-built in-app keypad replaces the native mobile keyboard: digits commit and auto-advance hole to hole, a leading 1 waits for a second digit so 10–19 are enterable, quick buttons for birdie/par/bogey/double resolve against that hole's par, putts interleave when putt tracking is on, and the card pauses at each player boundary. Physical keyboards work on desktop.
• Net scores are server-side. Net is computed on write from the snapshotted handicap, the player's tee and that hole's stroke index. The client never supplies a net score.
• Peer attestation. Confirmation is peer-to-peer. Playing partners record an attest or refute vote per player per round; a round finalizes when it's fully attested, and the event auto-completes when all of its rounds are. There is no administrator rubber-stamp in the normal path.
• Corrections. Commishes and admins can override or revert a score. Disqualification is a manager-only flag that preserves the scores but removes the player from results.
• Team formats. Scramble, best ball and alternate shot have dedicated team scorecards that record one card per team and distribute credit per the format.
• Leaderboards. Per round and aggregated across an event's rounds, showing gross, net and holes completed, with hole par carried in the row.

Dots — supplemental per-hole stats

"Dots" are the side stats a league actually argues about: putts, greens, sandies, barkies. Tracking them is optional per round and unlocks a whole tier of downstream analytics.

• The system set. Six ship with the platform: Putts, GiR (green in regulation), Greenie, Sandy, Chip-in and Barkie. Leagues can define their own on top.
• Per-round configuration. A commish enables the dots for a given round and sets their display order. A round that doesn't track putts simply doesn't show or grade putt-dependent boards.
• Derived, not just entered. GiR is computed automatically from putts and gross score where the data allows, rather than asked for a second time.
• Validation. Entry is constrained by the score: putts cap at gross minus one (there is always at least one non-putting stroke), and sandies and barkies only count on par or better.
• Downstream. Dots feed leaderboard pills, event summary highlights, career dot totals, the putt-gated performance boards, and the putt-gated betting markets.

The game engine

Games are declarative, not hardcoded. Each format is a rule schema — scoring unit, gross or net, comparison direction, win condition, team structure, payout shape — and one engine interprets them all.

• Eight formats. Skins (with carryover), Stableford, Stroke Play, Nassau (front nine, back nine and overall as sub-games), Best Ball, Scramble, Alternate Shot and Match Play.
• Results storage. Every format writes per-hole results to one table, whatever its shape. Carry-state games keep running state separately (a skins carryover rides from hole to hole until someone wins it outright), and per-player per-preset career totals accumulate as events complete.
• Automatic and idempotent. Calculation triggers on attestation rather than on a manual "score it" button. Recomputation is retroactive — a corrected score reruns the affected games and rewrites their results rather than layering on top.
• Participation. A game is either "Everyone" (the field is auto-enrolled, including walk-ups added on the day) or "Choose players". Team formats lock participation to their pairings.
• Flights. A game can be split into two to five handicap bands, stored as linked games sharing a flight group. Players auto-assign to the one band matching their index, overlapping ranges are rejected while gaps are allowed, and mutual exclusivity is enforced. Ranges are fixed at creation by design.
• Compatibility enforcement. Checked at creation, not left to the organizer: shared-ball formats (Scramble, Alternate Shot) exclude everything else in the round, Best Ball and Match Play are mutually exclusive, and only one game per format per round unless flighted.
• Money math. Skins carries a per-player buy-in, a percentage house rake, per-skin pot splitting, and optional whole-dollar payouts with the remainder donated to the rake. The platform is a bookkeeper only — it never touches real money.

Every format and setting, in detail

Markets — pre-round pari-mutuel pools

A play-money book on every round. Markets pool stakes across bettors, lock when the round actually starts, and grade automatically off the same score data everything else uses.

• The auto-slate. Seventeen markets generate for each round: low net and low gross, best front nine and best back nine, most birdies, biggest blow-up, strokes gained and tee-to-green, bounce-back, greens in regulation, putts per GiR, three-putt avoidance, most three-putts, best scrambler, and par-3/par-4/par-5 hero.
• The Field. Every pari-mutuel market carries a catch-all outcome covering any player nobody individually backed — so a pool is always coverable and rarely dies for want of a bettor.
• Player-created markets. Three shapes beyond the slate: head-to-head between two named players, an over/under line on one player, and a spread where the favourite gives strokes. The maker's opening bet is placed atomically with the market.
• Integrity rules. Self-bets are banned on adverse subjects where winning rewards a bad result (biggest blow-up, most three-putts, first blow-up) and direction-aware on lines. Two-sided markets void rather than pay out when one side is unbacked, withdrawn subjects are handled explicitly, pushes refund, and putt-dependent markets are unavailable on rounds that don't track putts.
• Locking. On the round's actual start, not its scheduled tee time — a delayed shotgun doesn't close the book early.
• Settlement. Grading writes a settle-up ledger of who owes whom, and a per-league season leaderboard ranks net profit and loss across all settled wagers.

Standings, stats & achievements

Season standings, per-player performance boards and career records, computed on read from the source score tables rather than served out of a cache that can drift.

• Order of merit. The Overall standings are a points race across four sources — event finish, game wins, skins won and participation. The weights are configurable per league (defaults: 50 for a win, 15 per game win, 3 per skin, 10 for showing up), so a league can decide whether its season rewards winning or turning up.
• Seasons. Calendar year by default. Leagues can define named custom seasons with non-overlap validation, including recurring ones — a stored month/day pattern projected onto any year, with cross-year rollover so an October-to-April winter season is a single definition rather than a yearly chore.
• Category boards. Skins champion, match play win-loss-halve records, per-format win boards for stroke play, Stableford and Nassau, and consistency streaks.
• Performance boards. Par 3/4/5 hero always available; best putter, strokes gained, strokes gained tee-to-green, three-putt avoidance and bounce-back unlock when the round tracks putts. Each board applies a minimum-rounds qualifier relative to the season's length (default 60%) so a one-round cameo can't top a table. Strokes gained here is field-relative — a player's gross against that round's field average — not shot-level tour SG.
• Player records. Per-league and cross-league career views: scoring averages gross and net, best rounds, skins, dot totals, hole-level distributions, and a per-league performance rollup on each member's page.
• Event analytics. A per-event stats page with the full scorecard grid, scoring distribution, par-type breakdown, hole difficulty ranking and dots table — plus natural-language questions about that event answered by a language model over the real numbers.
• Achievements. Awarded automatically as events complete: first skin, hat trick (three or more skins in one event), clean sweep (most skins outright), most improved (handicap drop over a season), perfect round (net even or better) and hole-in-one. Each badge stores its context, so the UI can render the specifics rather than a generic label. Aces are cross-league.

Live coverage & the clubhouse TV

Scores stream out as they're entered, and the round renders as a broadcast — for phones during play, and for a screen in the clubhouse after.

• Streaming. Server-sent events over an in-process hub, with two streams: an authenticated one for members and a public one for spectators and kiosk screens.
• Coverage tab. Live scoring alongside player chat, photo posts from the course, and emoji reactions on messages.
• TV mode. A full-screen broadcast for a clubhouse screen, reachable at a short typeable URL. It handles every state of a round: a pre-round tee sheet, a live show rotating leaderboard, group scorecards, highlights and photos, and a post-round recap carrying award spotlights, round-stat tiles and stat tables.
• Director mode. A commish or admin can drive the show from their phone. The rundown is a list of typed blocks; the remote can hold on one, skip, jump rounds, hide or reorder, and author new blocks — a custom card, a breaking moment, a photo, or a featured player that pulls that player's scorecard, standing and notable holes onto the screen. Commands fan out over the same SSE hub so multiple screens stay in sync, state survives a TV reload, and an abandoned remote auto-resumes the rotation after five minutes. Watching is public; driving requires a manager role.
• Photos on air. Photos posted to the coverage tab are routed into the post-round reel — to the tagged player's group if tagged, otherwise the poster's — so nothing posted during the round is silently dropped.

AI features

Three narrow uses, each grounded in data the platform already holds. Deliberately not a chatbot bolted onto the side.

• Post-round recap. A narrative written from the actual round: final standings and winner, the skins pot, market winners and losers, notable scores, the chat and the photos. The generator is instructed to narrate facts and never recompute a standing, so the prose can't contradict the leaderboard next to it.
• League voice. Each league sets a tone dial from formal tour-broadcast to unfiltered, names its own recapper, and can leave a free-form director's note for character and per-player running jokes. Zero on the dial disables the whole thing — and is the default for new leagues. Recaps also emit photo markers so the real photo lands at the right beat in both the app and the TV reel.
• Scorecard import. A vision model turns a photo of a blank course scorecard into a structured course with tee sets, pars and stroke indexes.
• Stats Q&A. Natural-language questions about a completed event, answered against that event's real statistics, rate-limited per user.
• What was removed. Live in-round AI commentary shipped and was then deliberately deleted in July 2026: players are there to play, not to read a bot during their round. Live scoring, chat and photos stayed; the post-round recap became the only AI narration surface.

Public pages & self-service join

Every league gets a public face that recruits members and lets a stranger join the next round without an administrator in the loop.

• Public league page. A recruiting surface with the league's branding that heroes the next upcoming or in-progress event with a join call to action.
• Public event page. Live tracking a spectator can follow without an account, plus the kiosk broadcast view.
• Short links. A second, shorter domain maps a league slug to its public page, and vanity codes to an event's broadcast and public page — short enough to type into a clubhouse smart TV's browser.
• Three doors. Behind a commish-set passcode: sign in as an existing member, create an account (the passcode substitutes for an invite), or play as a guest with no account at all. Signing in sits outside the passcode gate. Authenticated joins hand off to the in-app RSVP flow so handicap confirmation and game opt-ins still happen.
• Guest de-duplication. Fuzzy name matching offers a returning guest "is this you?" without disclosing any personal information when the match is a real member — it nudges them to sign in instead. An optional email and a device-held re-identification token fast-path a returning guest to one tap, with a visible escape for shared devices.
• Seat awareness. A guest joining a full RSVP-enabled event is waitlisted exactly like a member; on a non-RSVP event they land in the field unseated.
• Abuse controls. Postgres-backed per-IP fixed-window rate limiting on every public write endpoint, also applied to registration and password reset. The join passcode is manager-only and never appears in any public or member-facing response.

Notifications

Push and email, both opt-in per category, both suppressed for deactivated accounts.

• Web push. VAPID web push with subscription management, per-type preferences and click logging.
• What triggers one. Event and round status changes, round-start reminders roughly thirty minutes before the tee time, waitlist promotions and event cancellations.
• Email. Transactional only — invitations, password resets, and event communications a member has opted into.

Platform & administration

The operational layer: a system admin console, request telemetry, and the delivery targets the app ships to.

• Admin console. System-wide management of users, leagues, courses, game presets, invites and configuration, plus user impersonation for support, administrator-set passwords, and stats backfill.
• Telemetry. Per-request API logging with an analytics view over volume and latency, and a separate error analytics surface.
• Authentication. Bearer JWT with refresh, bcrypt password hashing, Google OAuth available on every account-creation door, and invite-gated registration.
• Delivery. Deployed on Google Cloud Run. Installable as a progressive web app, and shipped to Google Play as an Android Trusted Web Activity.

How it's built

One codebase, two services — a Python API and a Next.js web app — deployed together.

• Backend. Python, FastAPI, SQLAlchemy 2.0 in fully async style, PostgreSQL, Alembic migrations. Time-ordered UUIDv7 primary keys. Route handlers stay thin and delegate to a per-domain data layer; logic crossing domains lives in services.
• Frontend. Next.js 16 App Router with React and Tailwind. Authenticated surfaces are client-rendered against a typed API client with TanStack Query caching; public pages like this reference are server-rendered and crawlable.
• Realtime. Server-sent events over an in-process broadcast hub, with a separate public stream for unauthenticated viewers.
• AI. Google Gemini — a Pro-tier model for the post-round recap, Flash for event stats Q&A, and vision for scorecard import. All three are grounded in the platform's own data; none of them compute a result the engine is responsible for.

Not built yet

Stated plainly, because a feature list is only useful if its omissions are trustworthy. Some of these are specced and scheduled; none of them exist today.

• GHIN handicap synchronization — handicap indexes are self-reported today
• Parsing a photographed, filled-in group scorecard into scores (blank course cards do import)
• SMS notifications
• A native iOS app
• Any billing, payments or real-money handling
• Cumulative team-versus-team cup scoring (Ryder Cup format)
• Asynchronous leagues where fixed groups self-schedule inside a multi-day window