Before Polymarket, I Had a Side Hustle Trading Super Bowl Ticket Futures

Before Polymarket and Kalshi, I had a side hustle trading Super Bowl ticket futures.

This was in the late 2000s, mostly 2007 and 2008 from what I remember, which is part of why the whole thing feels like it belonged to a different internet.

There was a startup called Yoonew that tried to turn championship tickets into a market. It was not literally the same thing as a modern prediction market, and I am not making a legal claim here, but from a user's point of view it was very close. You did not buy a contract on the Colts to win the AFC. You bought the right to receive Super Bowl tickets if the Colts made the game. Or you bought a specific matchup. If that matchup happened, the contract converted into tickets worth real money.

For fans, it was a weird financing product. For traders, it was a prediction market wearing a blazer.

I loved it immediately.

I was just out of college, liked software, liked economics, and liked any system that accidentally revealed its logic if you stared at it long enough. Yoonew felt like one of those systems. And for a while, it paid extremely well.

The loophole mattered less than the market structure

What made Yoonew interesting was not just the legal gray area. It was the market microstructure.

Because the contracts paid out in tickets instead of cash, the product sat in a strange category. But economically, it behaved a lot like a betting market. If a team's odds of making the Super Bowl rose after a win, the value of that team's contract rose too. If a team got upset or looked shaky, the contract fell. The same was true for matchup contracts, only with more convexity and more chaos.

That meant you could do what traders always do: buy underpriced probability and sell overpriced probability.

The important thing here is that markets do not become efficient just because they are markets. They become efficient when there are enough informed participants, enough liquidity, and enough reaction speed. Yoonew had the shell of a market, but not always the muscle memory. It wanted active trading because active trading made the product look alive. So from what I could tell, it leaned on its own bids and asks to keep the book moving.

That was the opening.

A lot of founders think liquidity is something you can add decoratively, like better copy or a referral program. In adversarial systems, fake or slow liquidity is more like putting dollar bills under a glass table and asking who notices first.

My edge was not brilliance. It was a tighter loop.

I built a model around playoff odds, mostly using estimates from Football Outsiders as a base and then adjusting in real time as games unfolded.

The core idea was simple. I generated a grid of every plausible Super Bowl matchup and estimated the fair value of each contract. Then I compared my estimate to what Yoonew was offering. Underpriced contracts showed up in green. Overpriced ones showed up in red. Anything close enough to fair I left yellow.

That color coding sounds trivial, but it mattered. The hard part on a Sunday afternoon was not raw computation. It was attention. Football gives you a lot of moving information at once, and the human bottleneck is usually seeing the opportunity before it disappears. I did not need a perfect model. I needed a decision surface that let me act fast.

So I spent Sundays refreshing that page, watching the games, and hitting mispriced contracts as they appeared.

This is one of the earliest lessons I learned about applied software: the software usually does not replace judgment. It compresses the search space so your judgment can actually matter in time.

Live markets punish anyone who updates on a delay

The money was real because Yoonew did not always react quickly enough to new information.

If a late fourth-quarter swing materially changed playoff odds, there was often a window where the site still showed prices anchored to the old world. That is all an adversarial trader needs. Not certainty. Just a temporary lag between reality and a quoted price.

I still remember one Sunday, and if memory serves it involved the Ravens, where a team looked dead or close to dead and then a late touchdown flipped the game. What my model showed, and what the market seemed slow to internalize, was that the win did not just help that team in that moment. It reopened a path through an easier remaining schedule, which changed a whole chain of downstream matchup probabilities.

The moment the touchdown happened, the screen changed color.

Contracts that had looked uninteresting a minute earlier suddenly lit up green all over the grid. I started buying everything I could at what were, for a brief stretch, absurd prices. It felt half like trading and half like a video game, except the P&L was real and the market had made the mistake first.

That is another lesson I still believe: the best quantitative edge is often not in predicting the final outcome better than everyone else. It is in updating faster when the world changes.

The anti-bot move solved the wrong problem

At some point Yoonew clearly realized that people were automating around the market.

Its answer, from what I remember, was to move the main experience toward an Adobe Flash interface. I get the instinct. In that era, Flash felt harder to scrape, less legible, more sealed off from the kinds of crude automation people were using against plain HTML.

But this is a classic founder mistake. The surface implementation is not the real boundary. The incentive is.

I found that if I changed my user agent to mimic an early mobile device, I could still get a stripped-down HTML experience meant for smartphones. It was much easier to parse and much easier to trade against. The details of the interface changed, but the underlying market mechanics did not. If anything, the switch just confirmed that Yoonew understood there was an adversarial game happening and had chosen the wrong layer to defend.

This happens all over software.

People see automation and try to block the client. What they actually need to fix is the exploitability of the system behind the client.

Not better obfuscation, but better market design.

Every market teaches the same lesson eventually

Eventually the fun ended.

Yoonew widened the bid-ask spread enough that I could not consistently find profitable trades anymore. That was the rational move. If you cannot price quickly, you price defensively. The problem is that once the spread gets wide enough, the product stops being fun for exactly the people who made it feel alive. Traders leave. Volume dries up. Price discovery gets worse. The platform becomes less useful to fans too.

And then the whole thing starts to collapse under its own awkwardness.

Yoonew eventually shut down in 2010 and faded into internet-history obscurity. Most people have never heard of it. But I think about it now because prediction markets are back in the conversation, and the same themes keep repeating. Not the exact same legal wrapper. Not the exact same assets. But the same deep structure.

If you create a market that looks liquid but is actually slow, someone will learn to trade the lag. If you publish prices into an environment with motivated adversaries, those prices are not just information for users. They are attack surfaces. And if your product depends on participants behaving like passive customers when the system rewards them for behaving like traders, you have not built a customer experience. You have built a game.

What I really remember is how fun it was

The money was nice. I made thousands of dollars doing this, which mattered a lot to me at that stage of life.

But the thing I remember most is the feeling.

I was young, just out of college, and learning that software was not only a way to build products. It was a way to see systems more clearly than the people operating them. I liked football. I liked economics. I liked the feeling of turning live information into a model and then turning that model into action. Yoonew happened to sit right at the intersection of all three.

That is why this story has stuck with me.

For a little while, I had a weird side hustle that let me practice engineering, probability, market design, and attention management all at once. It felt niche and nerdy and slightly absurd. Which is probably why it was so educational.

Some of the best technical lessons do not come from elegant systems. They come from crooked little markets held together by ambition, loopholes, and a startup's mistaken belief that users will behave exactly as the product team hoped.

Yoonew is gone. The lesson is not.

If you were on Yoonew back then too, I would genuinely love to compare notes.