World cup prediction league

Transform your group chat into a live World Cup prediction league. Make picks, answer bonus questions, track matches, climb leaderboards, and let admins keep score without spreadsheets.

Comment

Inspiration - From Group Chat to Game Platform

World Cup prediction pools are one of my favorite ways to turn a global sporting event into a shared experience with friends. The problem is that these leagues often begin in a group chat and quickly become difficult to manage. Picks are scattered across messages, deadlines are unclear, bonus questions require manual grading, and the organizer spends more time maintaining spreadsheets than enjoying the tournament.

I built Danz World Cup League 2026 to replace that fragmented process with a polished, reliable social experience.

The project began as a tool for my own friend group, not as a hypothetical demo. I wanted one shared home where everyone could make predictions, follow the tournament, compare results, compete for rankings, and celebrate the winners. At the same time, I wanted the administrative experience to be powerful enough to handle the complicated scoring rules and edge cases that appear during a real World Cup.

The result is a digital ecosystem for the entire tournament: part prediction game, part live community scoreboard, and part tournament management system.

It fits the Apps for Your Life category because it solves an everyday social problem. It helps friends and family organize a real group activity, reduces administrative work, and makes following sports together more engaging.

What it does - The Player Experience

Danz World Cup League 2026 is a full tournament pick’em platform for private leagues with friends and family.

Players can:

  • Sign in securely with Google
  • Make predictions for each tournament stage
  • Answer stage-specific bonus questions
  • Choose the countries they are supporting
  • View match times in their local timezone
  • Follow match results through a tournament ticker
  • See their total score and detailed points breakdown
  • Compare picks and standings through a public leaderboard
  • Open player profiles to inspect predictions and scoring
  • Celebrate the final winners through a podium experience

League administrators can:

  • Enter official match results
  • Grade bonus questions
  • Accept multiple valid answers when appropriate
  • Review player responses
  • Publish updated leaderboard results
  • Manage scoring across every tournament stage
  • Correct answer keys without accidentally awarding points twice
  • Separate administrative controls from public player data

The app also includes fairness protections that are essential for a real prediction competition. Picks lock according to each match’s kickoff time, match winner selections remain hidden until the appropriate reveal time, and timestamps are handled consistently even when participants are in different timezones.

At the end of the tournament, the experience celebrates the players at the top of the leaderboard. The top three players receive medals and podium placement, while every participant receives a final thank-you message for being part of the league. The project becomes more than a match prediction league. It creates a complete social experience across the full lifecycle of a tournament.

How I built it - Architecture and Implementation

I built the application as a responsive web app using HTML, CSS, JavaScript, Firebase Authentication, and Cloud Firestore.

Firebase Authentication provides Google sign-in, while Firestore stores user profiles, predictions, official results, bonus responses, scoring information, and public leaderboard data. Firestore security rules separate normal player access from administrator-only operations.

A central part of the project is its deterministic scoring engine. Instead of treating scoring as a collection of manual adjustments, I modeled tournament rules as explicit, repeatable logic. The system evaluates official results against saved predictions and produces detailed scoring entries that explain where each point came from.

The scoring system accounts for:

  • Group-stage qualification predictions
  • Round-by-round knockout selections
  • Exact-score bonuses
  • Stage-specific point values
  • Extra time and penalty shootouts
  • Winner-first final-score formatting
  • Multiple accepted bonus answers
  • Manually graded statistical questions
  • Answer-key revisions
  • Protection against duplicate scoring

The frontend supports both authenticated and public experiences. Logged-in players can submit and review their own predictions, while logged-out visitors can still follow the leaderboard and tournament results. Player detail drawers make scoring transparent by showing individual picks, bonus answers, and awarded points.

The interface was designed to work across desktop and mobile devices. Important information such as deadlines, match status, save confirmations, standings, and point explanations remains visible and understandable on smaller screens.

For the final tournament state, I also created a cached podium result so that the completed leaderboard and winners can load quickly without repeatedly recalculating historical data.

Codex with GPT-5.6 served as my primary build partner throughout the project. I used Codex to help implement and refine:

  • The scoring engine
  • Firebase data-model changes
  • Firestore security rules
  • Administrator grading workflows
  • Match ticker behavior
  • Kickoff-based lock and reveal logic
  • Public leaderboard modes
  • Player scoring detail drawers
  • Responsive interface improvements
  • Bug diagnosis and regression fixes
  • Final tournament and podium states

Rather than using Codex only to generate isolated code snippets, I used it as an iterative engineering partner. I described product requirements, supplied the existing codebase and observed behavior, reviewed proposed changes, tested the implementation, and returned with errors or edge cases for further refinement.

This workflow allowed me to move quickly while still maintaining responsibility for architecture, testing, product decisions, and final verification.

Challenges we ran into - Engineering for Real-World Complexity

The most difficult part of the project was not creating the prediction form. It was making the application behave correctly throughout an entire real-world tournament.

Building a trustworthy scoring system

Tournament scoring contains many subtle cases. A match may end in regulation, extra time, or penalties. A correct advancing team may still have a different final score than expected. Bonus questions may require several accepted answers or manual statistical verification.

The scoring engine needed to remain deterministic: the same saved predictions and official results should always produce the same points.

It also needed to be explainable. Players should not simply see a total score; they should be able to understand exactly which prediction produced each point.

Preventing duplicate points

Administrator tools allow answer keys and official results to be corrected. That introduced an important data-integrity challenge: saving an updated answer must recalculate the correct state rather than adding another copy of the same points.

I had to design scoring as an idempotent process. Repeating the same grading operation should not change the final result.

Managing time correctly

Kickoff-based locking sounds simple until users are located in different timezones and the tournament contains many matches across several host cities.

The application stores and compares canonical match timestamps while displaying times in each user’s local timezone. This protects fairness while keeping the interface understandable.

Balancing privacy and transparency

Players should not be able to copy one another’s predictions before a match begins, but the league should become social and transparent once picks are locked.

That required carefully designed reveal rules. Upcoming selections remain hidden, while eligible historical picks and detailed scoring become visible through the leaderboard.

Separating public, player, and administrator access

The application needed three distinct modes:

  1. Public visitors who can view the league
  2. Authenticated players who can submit predictions
  3. Administrators who can grade results and manage the competition

Designing the Firestore rules and frontend states around those roles required careful testing. Administrative data had to remain protected without preventing the public leaderboard from loading.

Debugging scoring-date behavior

One of the most valuable debugging experiences involved a major scoring-date issue that caused points from the wrong bonus section to appear in the leaderboard.

The visible total looked plausible, but it violated an important scoring invariant. I traced the problem through the date and section logic, isolated which bonus categories were being included prematurely, and corrected the calculation so that only eligible questions affected the active standings.

That experience reinforced the importance of validating not only whether code runs, but whether its output respects the underlying rules of the product.

Accomplishments that I'm proud of - From Prototype to Real Product

I am most proud that Danz World Cup League 2026 became a real, complete product used by an actual friend group throughout the tournament.

It was not created only for a presentation. Players signed in, submitted predictions, answered bonus questions, followed the leaderboard, and experienced the competition as the tournament progressed.

Other accomplishments include:

  • Building both the player-facing and administrator-facing experiences
  • Supporting the full tournament from group stages through the final
  • Replacing spreadsheets and fragmented group-chat messages
  • Implementing transparent, deterministic scoring
  • Handling complex match and bonus-question edge cases
  • Protecting picks with kickoff-based lock and reveal rules
  • Supporting local-time displays for different users
  • Creating a public leaderboard that works without authentication
  • Providing detailed scoring explanations for each player
  • Designing a responsive experience for desktop and mobile
  • Completing the tournament experience with medals and a final podium

I am also proud of the level of product care that went into features users may never consciously notice. Save confirmations, hidden-pick states, responsive layouts, corrected scoring, fast final loading, and clear point explanations all contribute to trust.

That trust is especially important in a competitive social app. A leaderboard is only fun when participants believe the rules are fair and the results are accurate.

What I learned - Engineering Lessons

This project taught me that seemingly simple social applications often contain significant systems-design complexity.

A prediction league is easy to describe, but a reliable implementation requires thoughtful decisions about state, permissions, time, data consistency, transparency, and user experience.

One of my biggest lessons was to treat scoring rules as data and invariants rather than scattered interface logic. Centralizing the calculations made the application easier to test, explain, and correct.

I also learned that timezones should be treated as a core architectural concern, not a final formatting detail. Deadlines and locks are part of the competition’s integrity, so timestamp handling must be designed correctly from the beginning.

The project reinforced the value of idempotent administrative operations. Organizers inevitably need to correct results or revise an answer. A well-designed system should make those corrections safe.

From a product perspective, I learned that transparency reduces both confusion and administrative work. Detailed score breakdowns allow players to answer many of their own questions and make the leaderboard feel more credible.

I also developed a stronger workflow for building with Codex. The best results came from giving Codex clear product requirements, relevant code context, observable bugs, and explicit acceptance criteria. I treated generated changes as engineering proposals to inspect and test, not as automatically correct output.

Codex accelerated implementation and debugging, but the most important benefit was its ability to help reason across the application: UI behavior, data structures, scoring rules, security boundaries, and edge cases.

What’s next - Expanding Beyond One Tournament

The next step is to transform Danz World Cup League from a tournament-specific application into a reusable platform for social sports competitions.

Planned improvements include:

  • Configurable leagues for future World Cups and other tournaments
  • Custom scoring systems for different friend groups
  • Automated ingestion of official match results and statistics
  • Push or email reminders before prediction deadlines
  • Multiple private leagues under one account
  • Commissioner audit logs for result and scoring changes
  • Historical league archives and player records
  • Head-to-head comparisons between participants
  • Achievement badges and tournament awards
  • Improved accessibility and internationalization

I would also like to introduce an AI-powered league assistant using OpenAI models. It could:

  • Generate balanced and easily verifiable bonus questions
  • Explain why a player received a particular score
  • Summarize major leaderboard changes after each matchday
  • Create personalized tournament recaps
  • Help administrators detect inconsistent answer keys
  • Translate league announcements for international groups
  • Turn natural-language tournament rules into structured scoring configurations

The long-term vision is a platform where anyone can create a polished prediction league in minutes, invite friends, define the rules, and enjoy the competition without becoming a full-time spreadsheet administrator.

Danz World Cup League 2026 began as a solution for one friend group, but the underlying problem is universal: people want to experience major events together, and software should make that connection easier.

Built With

Share this project:

Updates