Tørny

Fire up a golf tournament in a couple of minutes.

Tørny is a mobile-first PWA for running golf tournaments. It scales from four friends on a Saturday round to a club event with 150 players. You create the game, invite the group, and everyone taps their strokes while they walk the course. The app handles the rest: scoring, the live leaderboard, side tournaments, and the mail that goes out when a game ends.

Live at tornygolf.no (also tørny.no).

It's invite-only: players sign in with a one-time code by mail, with no open signup and no password to forget. Any signed-in player can set up a game, run it, and finish it themselves, and manage their own games end to end: edit or delete before play starts, add or remove players, invite new people by mail, withdraw someone mid-round, and approve a scorecard on the flight's behalf when a co-player can't. Everyone gets a Klubbhuset tab at the bottom of the screen: your own games gather there, and it's where you set up a new game or add a course. For admins it also holds the full secretariat, where they run club-scale tournaments. Tørny is a solo project, built and run by Jørgen, and it runs in production for real tournaments.

What you get

• More than twenty tournament formats, all on WHS net handicap.
• A leaderboard that updates live while your flight taps scores.
• A big screen for the clubhouse. With live-follow on, the organizer opens the board on the TV in the bar: five players a page, turning every ten seconds, the latest birdies and lead changes, and a QR code so anyone can follow on their phone.
• Flights that match the course. Four or fewer players walk as one group where anyone can keep score for anyone, and whoever kept every hole of a flightmate's card submits it together with their own in one tap; bigger fields are split into flights — the organizer can auto-split and adjust them, players can pick their own group in the waiting room, and signup can be closed while the final adjustments are made. Team formats get the same treatment: when players sign up individually for best ball or a scramble, the organizer suggests and adjusts the teams from the secretariat, and the game won't start until everyone has one.
• Offline-first scoring. Tap in a dead spot on the course and it syncs once your phone has signal again.
• Distance to the green, crowdsourced. Tap in your score by the green and save the spot with one more tap; from then on the hole screen shows "~X m to the green" from your phone's GPS to the middle of everyone's saved points. No course mapping needed — the data builds itself round by round.
• Guest players. Bring a friend who doesn't have an account: the organizer adds them with just a name and handicap, the marker in the flight keeps their score and submits their card, and they count everywhere a player counts. After the round the organizer can send the result to the guest's email — they log in and the account, round included, becomes theirs.
• A side tournament you can bolt onto any game: a points race across the round, plus longest-drive and closest-to-pin contests.
• Your own cup. Run a team-vs-team Ryder Cup among friends without needing a club: name the two teams, generate the matches from your friends, then start and finish it yourself. When you generate the matches, every session comes with a match count you can dial down — run twelve singles off sixteen-player teams and the rest sit out that session. A personal cup holds up to thirty-six matches and forty players, which fits a full Ryder Cup line-up with captains on top; need more and that's what a club cup is for. You can also hand the picking to the players themselves: put each participant on a team, name one captain per side, and open a session at a time. Each captain fills their own ordered line-up without seeing the other side's, and the moment both have submitted, the matches appear and everyone is told. The organiser still sees both drafts, can submit on a captain's behalf, and can unlock a submitted line-up before the reveal. Because those sessions add matches after the cup has started, the organiser states up front how many matches the cup will have in total, and the points target is worked out from that — so a Ryder Cup that opens with eight of twenty-eight matches says "first to 14.5" from day one instead of crowning someone after day one. State fewer than the cup ends up playing and the target moves up on its own. Skip the captains and the cup behaves exactly as it did before.
• Clubs, set up through Tørny. A club gathers people and tournaments in one named place; you arrange one with us rather than spinning it up yourself, and each comes with a member cap and a duration. The owner runs it from there: appoint co-admins and owners, add members by mail or a shared join link, approve join requests, and set up rounds every member finds under "Finn turneringer" and joins straight away, even when the round would otherwise be private. An owner or club admin can also set up and run a season-long league for the club: start it, manage its rounds and participants, and finish the season themselves. Members find it on the club page, and can join an upcoming league themselves before it starts, then back out again until they've played a round. They can run a team-vs-team cup the same way: create it from the club page, generate the matches from the members, and start or finish it there. The player picker draws from club members rather than your friends, and members find both the leagues and cups on the club page.
• Friends. Add people you've played with, by mail, or with a share link that connects whoever opens it. Inviting someone to a game by mail also makes you friends once they join, so the list fills itself as you play. Friends turn up when you fill a team, and their games appear under "Finn turneringer" with a line naming the friends who are already in. Open a round "for friends": tick a box on a request-to-join game and your friends skip the approval and join straight away, while everyone else still asks.
• Leagues. Run a season across several rounds: pick how often you play, keep one course and tee for the whole thing or change it round to round, and rank everyone on net-to-par with a table that updates as flights come in. Players have the full round window to play in their own flights of at least two, missed rounds take a penalty score or drop out, and you decide the winner by total or average. Flip on the club-site board and you get a paste-ready snippet that puts the season table — or a live game leaderboard — on the club's website or info screen, self-updating and readable without an account.
• A year-end cavalcade. On 24 December your golfing year opens as a deck you page through: your best round, the hole that keeps beating you, the rival you met most often, your best stretch of form, and the crew's year beside it (who won most, most birdies, the year's snowman, the tightest finish). Every card shares as an image straight into the group chat. The home screen says it's coming from 1 December and carries the link from Christmas Eve until the end of January; from Christmas Eve on you'll also find it on your history page.
• An inbox for invitations, friend requests, peer approvals, submitted scorecards, finished games, and requests to join your club. Mail only goes out when you're not already in the app.
• Norwegian and English. Switch language right on the login page, before you've even signed in, or later from your profile. The whole play loop is covered — game page, hole-by-hole scoring, scorecard, leaderboards for every format, and the CSV export — and so is setting things up: the game wizard, quick setup and the course form. The admin console is covered too: the result log, running a game (sign-ups, flights, reminders, finishing), player and course management, the format mapping and launches. So are the club, league and cup surfaces, and the personal side — your profile with stats and history, friends, the inbox with every notification, "Finn turneringer" and the bottom navigation. The home screen, the self-registration flow, the format guide — names, descriptions, rules and examples for every game format — and the legal pages are covered too, so the whole interface is now bilingual. The transactional mail follows your language as well: every notification — invitation, result, reminder, cup and registration mail — goes out in the recipient's language, and the login-code mail is pared down to the code itself so it reads the same in any language. What's left is the draft Gaelic and Irish locales.
• A fixture list for finding a round. "Finn turneringer" shows every round you can join in one list, split by day, with filters for this weekend and your club; a round with a player cap shows how many places are left, and a full one says so instead of offering a button. Under the clock a round with a tee-off says whether it starts from the first tee or as a shotgun (the organiser ticks it when setting the round up), and a nine-hole round says «9 hull».
• Open tournaments you can browse before you sign in. Reach Tørny without an account and "Finn turneringer" lists the open rounds anyone can join; tap one to see the details, then log in when you want to sign up. It shows the round itself, never player names or personal details.
• Installable on your home screen. It opens like a native app, with no browser bar on top.
• GDPR self-service. Export or delete your data from your profile page without emailing anyone.

Formats

Tørny ships more than twenty scoring modes. Each one comes with a short rules card in the app, so a player can pick something they've never tried and still know how to score it.

• Solo: stroke play, Stableford, modified Stableford
• Matchplay: singles, fourball, foursomes, greensome, gruesome, Chapman, patsome, round robin
• Team: best ball, Texas and Florida scramble, Ambrose, shamble
• Betting games: Wolf, Nassau, Skins, Bingo Bango Bongo, Nines, Acey Deucey

Side tournaments

Any game can carry a side tournament next to the main result. Turn it on and it runs as an automatic points race across the round, and you can switch off any category you don't care about.

The package counts things like the best net front and back nine, King of the par 3s, 4s and 5s, and most birdies and eagles. It also hands out named badges: Turkey for three birdies in a row, Solid for five, and Snowman for a blow-up hole (that last one costs you points).

Then there are the two hole contests, longest drive and closest to the pin, with up to two of each. Those winners can't be read off the scorecard, so you pick them yourself when you end the game.

Stack

Framework	Next.js 16 (App Router) + React 19 + TypeScript
Styling	Tailwind v4, forest-and-champagne palette
Database and auth	Supabase (Postgres + Auth + Realtime, EU region)
Offline sync	Dexie (IndexedDB) with a last-write-wins RPC
i18n	next-intl — Norwegian default on unprefixed URLs, other locales under /<locale>/, catalogs in messages/
Mail	Resend, through the verified tornygolf.no domain
Testing	Vitest + Testing Library + Playwright
Hosting	Vercel, auto-deploy on push to main

Auth uses a one-time code by mail. Magic links went in the bin because iOS PWA handoff and mail scanners each broke the flow in their own way at the same time.

Running it locally

npm install
npm run dev

Open http://localhost:3000. You'll need a .env.local with Supabase and Resend keys. They're not in the repo, so a fresh clone won't boot on its own. This isn't wired up for outside contributors.

npm test          # vitest (2000+ unit + integration)
npm run e2e       # playwright
npm run typecheck # tsc --noEmit (Supabase clients are typed, so schema drift fails here)
npm run lint
npm run build
npm run dup       # jscpd — copy-paste / duplication report (on demand, doesn't gate)

CI (GitHub Actions) runs typecheck + tests + lint on every PR to main, along with the Expo app's own gate — its separate npm ci, its jest suite, tsc --noEmit, and an expo export, which is the only check that catches a shared lib/ module importing a package the app itself doesn't declare. Its limit is worth knowing: it resolves imports, so it says nothing about a shared module reaching for a JS global the app's engine lacks — Hermes has no crypto, and that only surfaced when the round-start code ran on a device (#1855). A daily schema-drift job regenerates the Supabase types from prod and fails if lib/database.types.ts is stale — run npm run gen:types to refresh it (needs the Supabase CLI + a SUPABASE_ACCESS_TOKEN). A sibling daily job (migration-ledger.yml) reads prod's applied-migrations ledger and fails — opening a prod-vakt issue that closes itself once green — when a file in supabase/migrations/ on main has never been applied; the few known renames and out-of-ledger applies live in docs/loops/migration-ledger-baseline.txt. A monthly job (tavle-arkiv.yml, 1st–3rd of the month) copies last month's comments from the loop boards #1110 and #1208 into docs/loops/logg/ via a docs PR, and deletes a board comment only once a byte-identical copy is on main. An optional authenticated-e2e gate (the scoring golden path, cup/liga smoke, and the signup/invite flows) is wired but off by default; set the RUN_E2E repo variable and the Supabase service-role + E2E_* secrets to activate it. A local pre-push git hook (.githooks/pre-push, enabled automatically by ) runs the same typecheck + lint + tests before every push, so red code never leaves your machine; branch protection on then enforces the same gate server-side — the , and checks must be green before any merge, with docs-only PRs satisfied by the no-op twins in . Companion hooks in and block direct pushes to , guard the local Dexie database name, and require an issue reference in each commit and a note file on user-visible changes — a weekly Monday workflow () rolls the notes into a single version bump and CHANGELOG update. Once that PR is merged, tags the version () and publishes the week's CHANGELOG block as a GitHub release. Main verify starts it with a each time it runs on (every merge except docs-only ones) — the Discord card merges with , which fires neither push nor workflows, but a dispatch always runs — with a push trigger for human merges and a daily schedule as a backup. Releases from before the automation are backfilled locally, because may not tag a commit whose workflow files differ from every branch tip. Native store builds get a tag of their own () on the exact commit that was built, set by the build script after a confirmed upload.

How it fits together

The scoring logic (lib/scoring/) is plain TypeScript with no Supabase dependency. It has its own tests and its own TDD discipline, so don't touch it without writing a new test first. This is where the WHS formula, stroke allocation, best-ball aggregation, the five-tier tiebreaker, and all twenty-odd game modes live.

Offline sync (lib/sync/) writes to Dexie first and drains the queue against Supabase once the phone has signal again. Last write wins, keyed on client_updated_at. The Dexie database is named 'golf-app' for historical reasons. Don't rename it, or you'll wipe local data for every existing user.

RLS is enforced strictly in Postgres. You see your own scores, all scores from any flight while a game is running in live mode (and your own flight's scores in reveal mode), and every score once the admin has ended the game. Single-flight games — four players or fewer, matchplay, Wolf — expose all scores throughout. A game can also be given a public spectate token; anyone with the URL can follow the leaderboard without logging in, via a dedicated /spectate/[token] route that uses the service-role client rather than opening any anon RLS. Realtime channels prime their auth with a no-argument await supabase.realtime.setAuth() before subscribing: the join payload is snapshotted synchronously, so a channel built before priming joins without an access token at all. The token itself is never passed in — an explicitly set token switches off supabase-js' own token upkeep, which used to kill the channel when the access token expired mid-round. lib/sync/realtimeChannel.ts owns both, and rebuilds the channel after three consecutive failures. Postgres Changes are never replayed, so once a channel is back after an error or a rebuild it calls the consumer's onResubscribed, and every screen reads its state again instead of waiting for the next event.

The Expo app is the one client that cannot lean on RLS for everything. Anything needing Node — the notification fan-out, Resend mail, the service-role key — reaches the server over a small set of route handlers under app/api/ that authenticate a Authorization: Bearer <access_token> against GoTrue and take the user id from that token alone, never from the body or query. Those routes sit outside the proxy matcher, so they own their own auth: the shared check in lib/api/appAuth.ts is the only place that decides who is calling and whether they organise the game in question. The helpers behind them run on the service-role client with no authorization of their own, which is the part worth remembering — the gate in the route is the security, and there is no RLS underneath it to catch a missing one.

Migrations live in supabase/migrations/ (120+ files, chronological).

Where the rest lives

• CLAUDE.md is the map: the rules every session needs, the files worth knowing, and where the rest lives — PR and issue workflow, staging testing, style and brand each have their own file under docs/, read when that event comes up.
• AGENTS.md is short but it matters. Next.js 16 has breaking changes against what you think you know.
• DESIGN.md is the design system written for agents and design tools: tokens, components, do's and don'ts. The values themselves live in app/globals.css, and a test fails if the two drift apart. The design skills in .claude/skills/ and when to use each are in docs/style-and-brand.md.
• CHANGELOG.md is the version history: one block per weekly release, the features as collapsible plain-language rows and that week's fixes gathered in a drawer beneath them. The same blocks appear on the releases page, one per version tag.
• GitHub Issues is the whole work queue, tagged by type, area, and scope.
• docs/ holds the launch checklist, mail templates, and the original design notes.