Why Settle: How a Backyard Horseshoe Tournament Became an Open-Source Android App
Every 4th of July I run the horseshoe tournament back home. My grandpa started it with a deck of playing cards, dealing them out to build teams. My aunt kept the tradition alive. When she stepped back, my cousin and I took over.
I’ve been helping set up the pits since I moved home in 2013. We built them into a tight, quirky space between the woods and a shed on uneven ground. I’ve kept helping every year since, slowly improving things where I can. A few years ago I moved us to a more open area with better ground. This year I asked for dedicated sand boxes so we could just drop stakes in, no more fighting with the earth. The details matter when you’re trying to make the game better for everyone.
We tried the old card system first. It didn’t survive contact with an actual crowd. Handwritten brackets fared even worse. Last year my cousin found a phone app that actually carried us through the day.
This year she's not going to be there.
Every Option Split The Same Way
We're on different platforms and the app she recommended wasn't available to me. I went looking for a replacement. Every option landed in one of two buckets: pay for something I'd use once a year, or cover half of what an actual tournament day needs and leave me building the rest by hand anyway. Team check-in, bracket generation, pit assignments, payouts. Pick a free tool and you're stitching three different apps together, or you're back to a legal pad.
Why settle when finding a tool that costs money or doesn't cover what you actually need is about the same amount of work as just building it?
So I built it instead. Started on a Wednesday night and about five or six hours total across a few sessions it was ready to hand off.
What It Actually Does
Check teams in as they show up, pair off anyone who arrives without a partner, then pick a format on the spot depending on turnout:
- Single Elimination — one loss and you're out. Fastest, fewest games.
- Double Elimination — lose twice to be out. A full winners/losers bracket built from scratch, not a wrapper around someone else's library.
- Pool Play + Bracket — small groups play round robin first, then group winners move into a bracket. Guarantees everyone a real number of games regardless of field size.
- Round Robin — everyone plays everyone, with the total game count shown up front so you can see if it's actually realistic before committing.
Pit assignments compute live as matches become ready. Once a champion is decided, a payout card splits the pot 60/25/15 across 1st, 2nd, and 3rd based on what each team actually paid in. No server, no login and works fully offline once loaded.
Testing before you ship isn't optional just because the stakes feel low. This is a bracket app for a backyard tournament, not production infrastructure, and it still turned up a bug where an oversized SVG icon blew out a card layout, a silent DOM bug where appending a raw table row through a div wrapper gets dropped by the parser, and a structural edge case where exactly three teams advancing to a bracket left one team with no path to a 3rd-place game. All three got caught by actually running the thing end to end before handing it over, not by assuming the code was fine because it compiled.
Now It's Generic
The first build was horseshoe-specific: pit terminology, an NHPA-sourced stake spacing calculator for laying out the yard the day before. Once it worked, the obvious next question was why keep it locked to one sport. Cornhole runs the same shape of day. So does most bracket-format sportsball. The generic release drops the horseshoe-only setup page, renames pits to stations, and swaps the fixed entry fee for a manual paid-amount field per team.
The name isn't a placeholder either. "Sportsball" is what I've been calling any skilled competitive event for years; darts, boxing, whatever. Naming the tool after it was the obvious move once it stopped being just about horseshoes.
It's also packaged as a real installed Android app through Capacitor, complete with its own icon.
It Actually Ran
July 4th happened. Fifteen teams, on Sportsball itself — not a horseshoe-specific build. The original Horseshoes app stuck around for exactly one thing: the pit layout calculator, used the day before to lay out all eight sets by hand into hard ground. Everything from check-in through the final match ran on the code going into the public release.
Pool Play was the plan going in. A bug surfaced mid-tournament — caught live, not in testing. We switched to Double Elimination on the fly, which ran clean the rest of the way. The fix for that live bug is in this release.
The engine ran the full bracket — winners side, losers side, grand final — and the built-in export produced these results:
1st: Larry T & Brandon — $180
2nd: John Kid & TJ — $75
3rd: Tim S & Riley — $45
$300 collected, split 60/25/15, no manual math on the day.
There's also MySportsball now — my own spinoff, not part of this open-source release. Same engine underneath, but rebranded and paired with a live results website for public viewing via QR code.
Get It
Source is up on GitHub: github.com/brad-tekforge/sportsball. MIT licensed. Single HTML file — no build step required to open and use it. The Capacitor wrapper is only needed if you want it installed as a native Android app.