Building ProxyDFS: How I Built an AI-Powered DFS Optimizer

I play DFS. I've used the popular optimizers. And I kept running into the same frustrations -black-box projections I couldn't trust, clunky interfaces, and tools that felt like they were built for everyone but optimized for no one. So I built my own.

ProxyDFS is an AI-powered DFS lineup optimizer that I started building for myself and am now growing into a product. Here's the story of how it came together, the technical challenges I ran into, and why I made the decisions I did.

Why Build Another DFS Optimizer?

The DFS tool market isn't empty. There are plenty of optimizers out there. But most of them share the same problem: you're trusting someone else's projections and someone else's logic with your money. You can tweak exposures and set rules, but you can't really see what's happening under the hood.

I wanted full control. I wanted to understand exactly why a lineup was being recommended, tune the algorithms myself, and integrate data sources I actually trusted. And honestly, the engineering challenge was just as compelling as the DFS angle -this is a genuinely hard optimization problem.

The Genetic Algorithm Approach

The core of ProxyDFS is a genetic algorithm for lineup construction. If you're not familiar, genetic algorithms work by mimicking natural selection. You start with a population of random lineups, score them based on a fitness function, keep the best ones, and then "breed" them together -combining pieces of good lineups to create even better ones. Repeat for hundreds of generations.

Why genetic algorithms over, say, linear programming or brute force? A standard NFL DFS slate might have 200+ players across 8-9 roster slots with a salary cap constraint. The number of valid lineup combinations is astronomical. Brute force is impossible. Linear programming can find mathematically optimal lineups, but it struggles with the kind of nuanced, multi-objective constraints I wanted -things like correlation stacking, game environment weighting, and ownership leverage.

Genetic algorithms handle this naturally. The fitness function can be as complex as you want. You can reward projected points, penalize high-ownership chalk, boost correlated player stacks, and factor in ceiling vs. floor -all in a single scoring pass. The algorithm explores the solution space organically and converges on lineups that balance all of these factors.

The tricky part was tuning the parameters. Population size, mutation rate, crossover strategy, elitism percentage -each one affects whether you converge too quickly on local optima or waste cycles exploring bad lineups. I spent a lot of time running backtests to find the sweet spot.

Monte Carlo Simulations for Projections

Most DFS tools give you a single projection number per player. "Patrick Mahomes: 19.4 points." But that hides a huge amount of uncertainty. Is that a high-floor 19.4 or a boom-or-bust 19.4? A single number can't tell you.

ProxyDFS uses Monte Carlo simulations to model the full distribution of outcomes for each player. Instead of one number, you get a probability curve -thousands of simulated outcomes based on historical variance, matchup data, and situational factors. This lets the optimizer make smarter decisions. For cash games, it can prioritize players with tight, reliable distributions. For tournaments, it can target high-ceiling players with wider variance who have blowup potential.

Building this meant collecting and processing a lot of historical data. I needed to understand not just average performance, but the shape of each player's output distribution -how often they boom, how often they bust, and what drives the variance.

Real-Time Injury Integration

DFS is a game of information. A player's status can change minutes before lock, and if your lineup doesn't reflect that, you're at a disadvantage. ProxyDFS pulls real-time injury data and automatically adjusts projections and recommendations as the situation evolves.

This was one of the more challenging pieces from an infrastructure perspective. You need reliable data sources, fast processing, and a system that can re-run optimizations quickly when something changes. The pipeline has to be robust enough that a late scratch doesn't leave you with an invalid lineup.

The Tech Stack

The frontend is built with Next.js and TypeScript. I wanted a fast, responsive interface where you can see lineup changes in real-time as you adjust settings. The optimization engine runs in Python -it's still the best language for numerical computing and has mature libraries for the statistical work. Prisma handles the database layer, connecting the frontend to player data, historical stats, and user configurations.

This split -TypeScript frontend, Python backend -works well for this kind of project. The UI needs to be snappy and interactive, while the heavy computation needs Python's numerical ecosystem. They communicate through a clean API layer.

What I Learned

Building ProxyDFS taught me a few things beyond the technical details. First, the gap between a working prototype and a usable product is massive. The core algorithm worked relatively quickly, but the data pipeline, error handling, edge cases, and UX polish took 10x longer.

Second, AI tools accelerated this project dramatically. As someone coming from an infrastructure background, there were parts of the statistical modeling and frontend development that would have taken me much longer without AI assistance. It didn't replace the thinking -I still had to understand the algorithms and make the design decisions -but it compressed the implementation timeline significantly.

What's Next

ProxyDFS started as a personal tool, but I'm expanding it into something others can use. The goal is to build the optimizer I wish existed -transparent, configurable, and backed by real statistical rigor instead of black-box projections. If you're interested in following the progress, keep an eye on the Projects page or reach out.