GOING / Going Long
The current application is hosted on Vercel at https://going-long.vercel.app/.
It includes football betting/fantasy, baseball integration, server-side odds
routes, a private React validation journal, and a separate local Python scanner.
Independent reviewers, including Claude: start with CLAUDE.md
and the audit guide for the current code map and tests.
Historical draft-board documentation
The original setup notes below predate the current hosting, API and database
architecture. Their GitHub Pages/no-server instructions are historical, not the
current deployment procedure. See vercel.json and the audit guide instead.
A draft war room built on the Late-Round Draft Guide's model. Every player is
priced in expected PPR points per game, valued against your league's actual
replacement level, and scored by what it costs you to wait.
Runs on GitHub Pages. No build step, no server, no API keys.
Setup from scratch
You haven't pushed anything yet, so start here.
1. Create the repo
cd path/to/going-long
git init
git add .
git commit -m "Going Long: draft board"
git branch -M main
git remote add origin https://github.com/YOUR_USERNAME/going-long.git
git push -u origin main
2. Let Actions write to the repo
Settings → Actions → General → Workflow permissions → Read and write
permissions → Save. The data job commits back to the repo, so it fails
without this.
3. Turn on Pages
Settings → Pages → Source: Deploy from a branch → branch main, folder
/ (root) → Save. Your board lands at
https://YOUR_USERNAME.github.io/going-long/.
4. Build the data
Actions → Refresh draft data → Run workflow. Takes about two minutes and
commits data/players.json plus nine format files. After that it runs every
morning on its own.
If none of your leagues are 12-team, edit the FORMATS list at the top of
scripts/build_data.py before running.
5. Connect your leagues
Open the page. Enter your Sleeper username → Find my leagues → pick the league
and draft → Add this draft. Repeat for every league you're in; the dropdown in
the header switches between them. Team count, scoring, roster slots and
superflex are all read off Sleeper — nothing to configure by hand.
6. Load the guide
Under Rankings & tiers, select all five LateRoundQB CSVs at once
(ppr, half-ppr, te-premium, superflex, superflex-te-premium). Each
one is stored as its own board and tagged by format from its filename, and
every league you add picks up the board matching its shape automatically — a
superflex TE-premium league gets the superflex TE-premium rankings without you
choosing. Pasted cheat sheet rows work too.
Under Market Score, paste all four position tables at once. Anything that
doesn't name-match gets a dropdown to fix — usually five or six players.
Both live in browser storage, so they persist without being committed. If you'd
rather keep them in the repo, export from devtools and drop the JSON in
data/ — nothing in the app cares which.
7. Optional: profile your league
LEAGUE_ID=your_league_id python scripts/manager_profiles.py
Walks every draft your league has ever run and writes data/managers.json —
who reaches, who waits, who drafts straight off a sheet. Not wired into the
board yet.
Reading the board
EDGE is what the current pick buys you over waiting. Not "how good is he" —
if a player you love won't be taken for another twenty picks, waiting is free
and his edge is low. It spikes when someone unlikely to survive is also well
clear of the next man at his position.
VORP is points per game above your league's replacement level, which is
derived from your actual starting slots. In a superflex league the QB baseline
slides from QB12 to roughly QB20 and every quarterback's VORP jumps
accordingly — nothing about that is hardcoded.
MS is Market Score, converted into points. The model's ranking is compared
to the ADP ranking, and the gap between what those two draft slots have
historically been worth is the edge.
The survival bar under the edge number is the chance he lasts to your next
pick. Teal is safe to wait on, red means gone.
Tags on the name line:
-
NEED — the quality supply at that position won't cover what you still have
to fill by your pick after next.
-
RUSH 8.9 — a top-8 quarterback who ran for that many fantasy points per game
last year. Four or more is the bucket that hits.
-
POCKET — a top-8 quarterback under two rushing points per game. Historically
the worst early-round bet at the position.
-
N-1 9.3 — a top-6 tight end who missed 12 PPR points per game last season.
-
TIER THIN — fewer players left in that tier than picks before your turn. It
will not survive.
-
COMES BACK — the tier is deep enough that someone from it returns to you.
Take the scarce tier instead.
-
FIRST QB / FIRST TE — nobody has taken one yet. Being first off the board
at a onesie position risks paying a premium the room was never going to pay.
The sliders are Rank (how much the guide's board overrides raw ADP), MS
(how much Market Score divergence counts), and Bench (what a player who doesn't
crack your lineup is still worth). Defaults are .60 / .40 / .30.
The Tier watch panel shows every live tier's remaining count against your
pick gap, which is the guide's tiering rule as a running readout.
Data sources
| What | Where | Notes |
|---|
| Players, drafts, picks, rosters | api.sleeper.app/v1 | No auth, CORS-friendly, read-only. |
| Consensus ADP + stdev + byes | fantasyfootballcalculator.com/api/v1/adp | Pulled server-side in the Action. |
| Market values | api.fantasycalc.com/values/current | Carries sleeperId, so the join is exact. |
| Expected points, replacement level, tiers, Market Score | The guide | Curves and tables are in docs/MODEL.md; rankings you import. |
| Prior-season production | nflverse + DynastyProcess IDs | Weekly stats aggregated to per-game rates, joined on Sleeper ID. |
The board polls Sleeper every 3 seconds while the draft is live and stops when
the tab is hidden. Everything else is a static file.
Not built yet
- Lineup optimizer for the season, once weekly projections are wired in.
- Trade finder — consolidation penalty plus an acceptance filter that ranks
by
my_gain × their_perceived_gain.
- Playoff odds via Monte Carlo.
- Betting models — see
docs/BETTING_MODEL.md for the implemented statistical contract and remaining validation limits.
If something breaks
- "No data files" — the Action hasn't run or it failed. The log prints which
source came back empty.
- Everything shows "—" for ADP — FFC may not have your format posted yet.
The board falls back to market rank and still works.
- Draft won't connect — Sleeper doesn't create the draft object until the
commissioner sets it up. Enter your slot by hand under Overrides meanwhile.
- Names won't match — the fixer dropdown writes straight to storage; once
fixed, it stays fixed.
Automated Betting Board
The board opens directly with NFL props and a separate NFL/NCAA game-lines view.
Player projections use trailing nflreadpy game statistics, a nonpositive-mass
lognormal yardage model, and Poisson receptions/TD counts. The board displays
model win probabilities, push-aware EV and capped quarter-Kelly allocations.
It preserves bookmaker/line identities and flags missing or stale data.
The nightly workflow now runs scripts/build_pipeline.py after odds ingestion,
writing configuration and projections into data/data.json and
data/history.json. Set the Actions repository secret PARLAY_API_KEY to
enable prop quotes. Historical model rebuilding does not need an odds key.
The hosted board refreshes NFL props and NFL/NCAA game lines through the
server route /api/odds. Set the same PARLAY_API_KEY secret in hosting.
Run npm ci and npm run dev locally with the key in your environment.
The server uses Parlay’s X-API-Key header and caches results for two minutes.
Hosted model snapshots follow the nightly GitHub files automatically.
GitHub Pages serves the nightly snapshots; live refresh requires the hosted server.
For data sources, assumptions, limitations, test commands, and schema details,
see the betting model documentation.
