Building an 82-0 Inspired Football Draft Game in One Week With AccelByte

Built by Damar Inderajati, an engineer at AccelByte, F11 started with a simple idea: take the drafting concept behind 82-0 and see what it could look like as a football game. Over the course of a week, Damar built the game using AI-assisted development, then added login, Cloud Save, leaderboards, and multiplayer with AccelByte. In this post, Damar walks through what he built, the decisions he made, and how the game works under the hood.

The Idea

I recently started playing 82-0 in my spare time. It is simple, but very addictive: you draft an NBA starting five from random team and season spins, choose one player each round, and then let the game simulate the season with the lineup you built. You can also challenge other players or invite friends, which makes a simple game much more fun to share.

A few days into it, I started thinking, "Wait a minute. It would be cool if I could also do this with my favorite football players or my local football league."

And this is when the mission began.

Starting with the Scopes

With AI, everything can be much faster. So I immediately got to the drawing board, and when I say drawing board, I mean myself and my preferred AI agent. After a few quick brainstorming sessions, I got the scope locked down. I called it F11, a simple name inspired by football's starting eleven.

I started with these scopes to make sure I could get a working prototype up and running fast, so I could immediately experience playing it myself before going overboard and adding more and more features. So here are the scopes:

• Start with an eleven-player draft in a 4-3-3 formation. Why 4-3-3? Because it's my favorite!

• Offer fifteen random players per round and five rerolls for the full run.

• Show available player positions and ratings based on the selected position.

• Deterministic player selection, scoring, and season simulation.

• A complete 38-match season with an explanation of the squad's strengths and weaknesses.

• And to make it more fun, the game should at least have social linking, an invite-a-friend feature, and leaderboards so you can share the fun instead of playing alone.

From the scope, I was pretty sure my AI agent could help me build the core game. But it felt unnecessary to build the online functionality from scratch too - things like player identity, saved runs, friend rooms, and leaderboards. Working at AccelByte, I already knew AccelByte Gaming Services (AGS) covered those pieces, so I decided to use them instead of turning F11 into a separate backend project of its own.

From the Scopes to the Specs to the Execution Using AI

With AGS in the picture, I also wanted my AI agent to understand the backend context instead of me feeding it documentation and configuration details one by one.

That is where I used the AccelByte AI plugin. It gives my agent context about AGS services, configuration, and integration patterns, so I can ask questions in the same workflow I am already using to build the game. It can also help with service configuration, which saves me from constantly switching between my editor, documentation, and the portal.

Below is a quick overview of how I installed, authenticated, and started using it.

AccelByte AI plugin installation

Initialize the project with AGS

Now, with everything set, I continued with several brainstorming sessions with my agent to lock down the plans and specifications so that it could continue working on the game and complete it. The final plans are also available in the F11 GitHub repository.

Preparing the Assets

One of the first challenges was finding the right player data for the draft. I eventually settled on OpenFootball's complete Premier League 2023/24 data, covering all 20 clubs, 380 matches, and 1,041 squad entries. The source provides player identities and general positions, while the game deterministically generates the additional positions, attributes, and ratings needed for gameplay. The ratings are synthetic rather than official player ratings.

I also recalibrated the ratings after realizing the first version never actually produced a 90-rated player. The updated model keeps strong players rare, with only 14 cards rated 90 or above and a maximum of 94. I then ran 10,000 seeded drafts to make sure all 1,041 cards could appear and every draft could be completed.

Building the Gameplay

With the assets ready, the next step was the draft itself. You build an eleven-player starting XI in a 4-3-3 formation, with up to fifteen player choices for each pick. Players can support multiple positions with different ratings, so choosing the highest-rated card is not always the best decision for your remaining slots.

You also get five rerolls for the full run. I originally made rerolls replace only players from the same team, but that felt too limited, so I changed them to also give you a different team whenever a safe alternative is available.

Once the XI is complete, the game simulates a full 38-match season and explains the squad's strengths and weaknesses. The whole flow is deterministic: the same seed, configuration, and choices always produce the same result. I tested 10,000 seeded runs with the current setup, and every draft completed without reaching a dead end.

F11 Gameplay

Connecting the Online Features Together

Because the core gameplay was already working, adding AccelByte did not require rewriting the game. The game rules remain in the shared game package, while AccelByte handles the connected features around it.

For login, players can continue as guests using AccelByte IAM Device ID. The game creates or restores a Device ID and uses it to obtain a player identity before entering the draft. The trade-off is that clearing browser storage can lose a Device ID-only account, so a public release would eventually need an account-linking or recovery path.

Setup Device Login

Completed runs are saved through AGS Cloud Save rather than treated as authoritative local data. When a result is loaded, the game verifies its owner, version, checksum, and deterministic replay before using it.

Saving the Run

For competitive results, the browser does not simply submit a score. It sends the seed, version, and player actions to a trusted server handler, which replays the run and calculates the canonical result. Only accepted results update the AGS Statistic and Leaderboard.

Ranking the Run in a Leaderboard

Play with Friends

Playing alone is fun, but I also wanted the experience to be shareable. Using AccelByte Session Management, one player can create a room and others can discover and join it while it is open. The current setup supports up to eight players.

Setup Game Sessions

When the round starts, the room closes to new players and locks the participants. Everyone gets a reproducible private draft generated from the room's base seed and their AccelByte identity, so players can receive different offers while still being able to refresh or reconnect without changing their run.

After everyone finishes, the room reopens and shows a comparison of the results before starting another round. I tested the flow with three isolated browser identities, including joining, locking the room, reconnecting mid-draft, comparing results, and replaying another round.

Multiplayer Session

With that, the prototype now connects the complete draft and season simulation with guest login, Cloud Save, trusted result validation, Statistics, Leaderboards, and friend rooms - without turning the game into a separate backend project.

From Idea to a Playable Game

At the end of the day, this experiment was really about seeing how quickly I could turn an idea into something playable.

What started as, "It would be cool if I could do this with football," turned into a working connected game in about a week. AI helped me move through prototyping and iteration faster, while AGS gave me existing building blocks for the online pieces like identity, saved runs, leaderboards, and sessions.

That meant I didn't have to build every layer myself. I could spend more of the week working on the draft, simulation, ratings, and the parts that actually make F11 fun, then add the connected features around them as the game came together.

Feel free to check out these links to watch the video, try the game, check the tutorial or get the source code.

• Watch the video here

• Try the game > here

• Check the tutorial > here

• Get the source code > here

What's next? I might take this prototype further and turn it into a full app, explore other markets such as Indonesia's Liga 1, and, of course, add more features along the way.

This was a fun experiment, but it also made me wonder: if one person can do this in a week, imagine what a small team could do with the same tools.