EdgeGoat's Humble Beginnings

It started the way most side projects do — with annoyance.

The Couch Problem

Picture this: it's a Tuesday night, NBA is on, and I've got a six-leg parlay riding on my sportsbook. Three games going simultaneously. My phone is open to the sportsbook app, and I'm refreshing. And refreshing. And refreshing.

The score on TV says 87-82. The app still shows 79-74. It's been like this for three minutes.

So I switch to a stats app to at least see live stats. One of my legs is Jaylen Brown over 22.5 points — is he even still in the game? The stats app shows the box score, but now I need to figure out which guy on the court is him. What's his jersey number again? Back to Google. Number 7. Okay. Back to the stats app. Back to the sportsbook — oh look, it finally updated. He's at 18 points in the third quarter. Not bad.

Now multiply that by six legs across three games. That's my Tuesday night. Every Tuesday night. And Wednesday. And Thursday through Sunday during the season.

I love my long-legged lottery parlays. There's nothing like watching a 6 or 8-legger slowly come alive, leg by leg, the potential payout climbing into ridiculous territory. But the experience of actually tracking them? Absolute misery.

The Breaking Point

The thing that finally broke me wasn't the slow updates. It was the leg-by-leg search.

I'd build a parlay on my sportsbook — maybe 8 legs across 4 games. Player props, spreads, totals, a mix of everything. Then once the games started, I'd want to check on each leg. But the sportsbook app doesn't give you a consolidated live view of your parlay legs with actual game context. You see your bet, you see if it's "in progress," and that's about it.

So I'm manually looking up each player. Is Domantas Sabonis playing tonight? How many rebounds does he have so far? What quarter is it? What's the pace of the game looking like — is it a fast game or a grind? Is he in foul trouble? All of this lives in different places. A stats app for box scores. The broadcast for context. The sportsbook for the line I took. My own head for the math on whether it's looking good or not.

I'm a developer. This is a solvable problem.

Night One: 40 Commits Before Sunrise

On March 2nd, 2026, at 12:20 AM, I made the first commit. By 4:53 AM, I had a working (barely) parlay tracker. The commit messages tell the story of that night:

• "first commit"
• "deployment"
• "workflow fix"
• "retrigger workflow"
• "this should work"
• "retrigger again"
• "retrigger #1999"
• "allow cors"
• "fix migration?"
• "fix odds"
• "Parlay fix"

CORS was fighting me at 3 AM. Migrations were breaking. Odds weren't matching. But by that first morning, I could load my betslip, match it against live game data, and see all my legs in one place with live scores, jersey numbers, and on-court indicators.

It was ugly. It was held together with duct tape and caffeine. But it worked.

By the end of that first day — 40+ commits later — I had live tracking, NCAAB support, job orchestration for polling, and a backtesting dashboard. I couldn't stop. Every time I fixed one thing, I saw three more things I could build.

The Automatic Betslip

One of the features I was most excited about early on was the automatic betslip loader. On my sportsbook, when you build a parlay, the individual legs are buried in the interface. If you want to check on your bet, you have to navigate to your open bets, find the parlay, and then mentally map each leg to what's happening in the games.

I thought: what if I just load the betslip, break out each leg, and show them all on one screen with live game data?

So I did. You share your betslip with EdgeGoat, and it breaks it down: every leg, every player, every line — matched to live game data. Jersey numbers so you can spot them on screen. On-court indicators so you know if they're playing. Live stats updating in real time. Progress bars showing how close each leg is to hitting.

No more tab-switching. No more Googling jersey numbers. No more refreshing.

The Gold Mine

Here's the thing nobody tells you about building a sports data aggregator: once you have the plumbing in place to pull game data, odds, player stats, and play-by-play — you're sitting on a goldmine and you don't even realize it.

I built EdgeGoat to watch my parlays. But within days, I started asking a different question: what if I could predict them?

I had historical game logs. I had odds data with timestamps. I had play-by-play event streams. I had player stats going back seasons. All flowing into one system, all normalized and cross-referenced.

The first prediction model was embarrassingly simple — just weighted averages of recent performance with some home/away adjustment. But it was something. And when I backtested it against historical results, it was right more often than I expected. (That backtest was in-sample, which I'd learn to distrust later.)

That was the moment EdgeGoat stopped being a parlay tracker and started becoming something else entirely.

The Obsession

What happened next is probably what happens to every developer who stumbles into a domain with infinite depth: I got obsessed.

I just wanted a bit of edge. That's it. I'm not trying to beat Vegas into the ground. I play lottery parlays for fun — I know the math is against me. But what if I could tilt the odds just a little? What if, instead of picking legs based on gut feeling and whatever narrative the pregame shows are pushing, I could pick them based on actual statistical edge?

That question consumed me.

Within a week, I had a calibration engine. Then a full backtesting framework. Then I was running optimization rounds — 16 of them eventually — each one squeezing out a fraction of a percentage point in accuracy. I started tracking metrics I didn't even know existed when I started: MAE (Mean Absolute Error), win accuracy, prop prediction accuracy, against-the-spread performance.

Every signal I could think of, I tested it. Pace of play. Defensive matchups. Rest days. Coaching tendencies. Player chemistry. Foul trouble patterns. Some helped. A lot didn't. The commit messages from this period are a mood:

• "improve MAE"
• "props plateau hit..."
• "Round 10, my best guess"
• "less overfitting"
• "super tune"
• "blah"

That last one was at 5:39 PM after a long day of calibration rounds going nowhere. We've all been there.

Where It Stands Now

What started as a frustrated developer's side project is now a full platform:

• Live parlay tracking with real-time game data, jersey numbers, on-court indicators, and progress visualization
• A 16-stage prediction pipeline trained on our own hardware, graded forward on settled results (the public record shows what has been graded so far, with sample sizes)
• A parlay builder that ranks legs by the gap between the model's probability and the sportsbook's price, instead of by what's popular
• Multi-sport support — NBA, NCAAB, NHL, and expanding
• Model % next to book % on every line the model prices, so you can see the price's break-even next to the model's estimate
• Portfolio mode for spreading a slate's edges across several smaller parlays
• An iOS app because why not at this point

354 commits in 32 days. I still can't believe the first one was just about making my parlays update faster.

The Name

We started as "Hoops Stats" because it was just basketball. Then it became "OddsDeity" when we added hockey and started thinking bigger. We landed on "EdgeGoat" because that's really what this is about — finding edge, obsessively, relentlessly, one data point at a time.

The GOAT of finding edge? Probably not. But we're trying. And honestly, just having all my parlay legs on one screen with live data and jersey numbers would have been enough. Everything else is gravy.

---

EdgeGoat started because a sportsbook app wouldn't refresh fast enough. It keeps going because the data never stops being fascinating.