TL;DR / Key Takeaways

Binary contracts have exactly two outcomes, which collapses most of the hard math that makes equity modeling intractable.
Stock prices require modeling a continuous distribution with fat tails, earnings surprises, sentiment gaps, and overnight risk. Binary markets don't.
A single probability estimate plus a market price is enough to calculate edge. The formula fits in three lines of Python.
Predict & Profit's Weather Bot and Econ Bot are built on this principle: use better data to estimate that one probability more accurately than the market does.

I spent 30 years building data pipelines and enterprise systems. I understand data. I understand models. I tried to build an equity trading system twice in my career, and both times it fell apart.

Not because I'm bad at modeling. Because equities are genuinely hard to model in ways that binary contracts are not.

Let me show you the difference.

What You're Actually Estimating

When you trade a stock, you're trying to answer a question that has infinite possible answers: where will the price be at some future time?

You don't just need a direction. You need a magnitude. You need a timing estimate. You're implicitly betting on the shape of an entire price distribution, including the tails, which is where all the bad surprises live.

When you trade a Kalshi binary contract, you're answering a different question: will this event happen, yes or no?

That's it. The contract settles at $1.00 if yes, $0.00 if no. There is no in between. There is no "mostly yes." There is no gap down at the open because of something Jerome Powell said at dinner.

The outcome space collapsed from infinite to two.

The Equity Modeling Problem Is Structural

When I tried to model equities, here's what I needed to handle:

Continuous price paths with heavy-tailed distributions. Normal distributions don't work because markets have fat tails. So now you're in GARCH territory or jump-diffusion models, and you need a lot of clean historical data to fit those parameters reliably.

Earnings surprises. Every quarter, a company can print a number that invalidates your entire model in 30 seconds. You cannot forecast earnings reliably. The sell-side analysts with full research teams and access to management can't do it either.

Overnight gap risk. The market closes. The world doesn't. News breaks at 2am, the stock opens 15% down, and your stop-loss is a suggestion, not a guarantee.

Regime changes. The relationship between price and your features breaks without warning. Something that worked for two years stops working. You have no way to know in real time whether you're in a new regime or just a temporary drawdown.

Sentiment. Retail flows. Options market maker hedging. Short squeeze dynamics. None of these show up cleanly in price data. They're real forces that move stocks.

I'm not saying it's impossible to model equities. Quant firms do it with teams of PhDs, proprietary data, and infrastructure I'll never have. I'm saying it's not tractable for one data engineer working nights and weekends.

Binary contracts are different.

The Math That Actually Fits in Your Head

Here's the core of what I do for every trade candidate.

Let p_model be my estimated probability that the event resolves Yes. Let p_market be the current market price for the Yes contract, expressed as a probability. These are the same units: a Yes contract trading at $0.62 implies p_market = 0.62.

Edge is just:

edge = p_model - p_market

If p_model = 0.72 and the market is pricing Yes at 0.62, my edge is 0.10. I think this event is 10 percentage points more likely to happen than the market does.

That's the whole signal. Everything else is position sizing and risk management.

For position sizing I use a simplified Kelly fraction:

def kelly_fraction(p_model: float, odds: float) -> float:
    """
    p_model: estimated probability of win (0 to 1)
    odds: net odds paid on a win (e.g. 0.62 contract pays ~0.61 net)
    Returns: fraction of bankroll to risk
    """
    q = 1 - p_model
    return (p_model * odds - q) / odds

# Example:
# Yes contract at $0.62, pays $0.38 net if correct, loses $0.62 if wrong
p_model = 0.72
net_odds = (1.00 - 0.62) / 0.62  # approximately 0.613
fraction = kelly_fraction(p_model, net_odds)
print(f"Kelly fraction: {fraction:.3f}")
# Kelly fraction: 0.186

Full Kelly is aggressive. I run quarter-Kelly in practice because the model is not perfect. But the structure is clean. There's one input variable that matters: how good is my p_model?

That's the only problem I need to solve. Not price paths. Not volatility surfaces. Not earnings models.

Where the Edge Actually Lives

The question becomes: how do I get a better p_model than the market?

For weather markets, the market is set by people making gut calls, reading the same weather.com forecast everyone reads, or using a single deterministic model output. My bot runs a 4-source ensemble with up to 164 forecast members across GFS, NOAA AIGEFS, ECMWF IFS, and ECMWF AIFS-ENS. I compute a weighted probability from all of them.

When those four systems agree, my p_model is tight and high-confidence. When they diverge, I don't trade. That's the whole thesis: DIVERGENCE IS RISK. CONVERGENCE IS AN EDGE.

For inflation markets, the Cleveland Fed publishes a CPI nowcast. Most Kalshi traders aren't reading it. I pull it programmatically, combine it with FRED market signals, BLS subcomponent data, and BEA PCE data, and build a composite p_model from five sources.

In both cases I'm not doing anything exotic. I'm using publicly available data more systematically than the average person pricing the market.

That's it. That's the edge.

What Binary Contracts Don't Require

Let me be explicit about what I'm not doing, because the contrast matters.

I'm not estimating how far the temperature will miss the threshold. I only need to know which side of the line it lands on.

I'm not modeling volatility. There's no implied vol surface. The contract is worth $1.00 or $0.00 and that's known in advance.

I'm not managing overnight gap risk. The settlement price is determined by an observable real-world event, not by what other traders decide to do at the open.

I'm not dealing with earnings surprises. The BLS prints CPI at 8:30am. The number is the number.

I'm not worrying about short squeezes or gamma hedging feedback loops. There's no continuous price path to squeeze.

This doesn't mean binary contracts are free money. The market is reasonably efficient. Good data helps but doesn't guarantee wins. My bot has lost trades. It will lose more.

But the problem is tractable in a way that equity modeling isn't for a solo engineer with a day job.

Why This Matters for Someone Like Me

I'm 60. I work full time as a Senior Data Engineer. I built this bot on nights and weekends, running on a VPS in Atlanta that costs me $9 a month.

I couldn't build a profitable high-frequency equity trading system. That requires co-location, tick data, and a team. I couldn't build a fundamental equity model that beats the market, because the market has better information than I do on every single stock.

But I can pull NOAA weather model data from a public S3 bucket faster than most people know it exists. I can read the Cleveland Fed nowcast on the morning it drops. I can build a weighted ensemble that most Kalshi traders have never thought about.

Binary contracts turned "beat the market" into "estimate one probability better than a crowd that mostly isn't trying." That's a problem I can actually solve.

The math is simple enough to fit in three lines of Python. The data is public and free. The edge is real if you're disciplined about only trading when it's there.

That's why I'm here and not trying to day trade SPY.

If you're a developer who's been curious about prediction markets but assumed the modeling complexity would be similar to equities, I hope this reframes it. It's not the same problem at all. The outcome space is smaller, the settlement is deterministic, and the data sources that matter are publicly available. The hard part is building the discipline to not trade when your model is uncertain.

That part nobody can hand you in a package.

Why Binary Contracts Are Actually Easier to Model Than Stocks