Gridzo

Gridzo is a globally scalable gaming platform where competitive games share player identities, rankings, and progression.

Comment

Inspiration

Most competitive web games are built as isolated experiences. Every game has its own login system, player profiles, rankings, and progression, forcing developers to rebuild the same infrastructure repeatedly.

I wanted to explore a different approach: what if competitive games could share the some of the game progression metrics while still remaining independent games?

That idea became Gridzo—a globally scalable gaming platform where multiple competitive games can coexist on a shared backend. Rather than building a single competitive racing game, the goal was to build the foundation for many future games in multiple categories.

To validate the platform, I integrated my existing Unity racing game, Sky City Rush – Competitive, as the first game on Gridzo.

What it does

Gridzo is a competitive gaming platform that provides shared infrastructure for multiple games.

Players authenticate once and receive a persistent profile that follows them across the platform. Each game can maintain its own leaderboards, statistics, seasonal rankings, and progression while sharing the same player identity.

The first integrated title, Sky City Rush – Competitive, allows players to:

  • Compete across ten racing tracks
  • Submit race results directly from the Unity WebGL client
  • View global and track-specific leaderboards
  • Maintain persistent player profiles
  • Track race history and personal records
  • Participate in seasonal rankings

The architecture is designed so additional games can be added through a Games Registry without changing the underlying player or ranking systems.

How we built it

The frontend platform is built with Next.js and deployed on Vercel, while the racing experience runs as a Unity WebGL application embedded inside the web application.

One of the most interesting engineering challenges was building a communication bridge between Unity WebGL and the web platform. Unity submits completed race results through a JavaScript bridge, which forwards authenticated requests to the backend. After processing, the backend immediately returns information such as leaderboard position and personal best status back into Unity, allowing the game to display competitive results.

Player profiles, race history, rankings, and leaderboard data are stored in Amazon DynamoDB.

DynamoDB was chosen intentionally because the application performs predictable, high-volume key-value lookups where players frequently query:

  • their own profile
  • leaderboard rankings
  • recent race history
  • track records

These access patterns benefit from DynamoDB's single-digit millisecond latency while providing horizontal scalability without requiring schema migrations as the platform grows.

The platform is also designed around a Games Registry, making future game onboarding straightforward while preserving shared player identities across titles.

Challenges we ran into

The largest challenge was integrating Unity WebGL with the web application.

Passing authenticated race results from Unity into the browser, processing them through the backend, and then sending ranking information back into Unity required building a custom bidirectional bridge between Unity, JavaScript, and Next.js.

Another challenge was designing DynamoDB tables around real access patterns instead of treating the database as generic storage. Modeling player profiles, race history, and leaderboard queries efficiently required thinking about how the application would scale to millions of results submissions.

Accomplishments that we're proud of

  • Built a working competitive gaming platform.
  • Successfully integrated Unity WebGL with a modern Next.js application.
  • Designed a scalable DynamoDB-backed architecture around real-world access patterns.
  • Created a reusable player identity and profile system shared across games.
  • Implemented persistent leaderboards, rankings, race history etc.
  • Built the platform so additional games can be onboarded with minimal changes.

What we learned

This project reinforced that scalability starts with data modeling rather than infrastructure.

Designing DynamoDB around application access patterns simplified many parts of the backend while keeping the architecture flexible enough for future expansion.

We also learned that combining Unity WebGL with modern web technologies enables desktop-quality gameplay while retaining the advantages of a scalable web platform.

Most importantly, building a platform requires thinking beyond today's features and designing systems that future developers can build upon.

What's next for Gridzo

Gridzo is intended to become a multi-game competitive platform rather than a single-game website.

Future work includes:

  • Developer onboarding so studios can publish their own games on Gridzo.
  • Shared achievements and progression across games.
  • Cross-game player statistics.
  • Tournaments and seasonal events.
  • Matchmaking for real-time multiplayer titles.
  • Additional competitive games beyond Sky City Rush.
  • Global infrastructure expansion for lower latency worldwide.

The long-term vision is to provide reusable competitive infrastructure that lets developers focus on building great games instead of rebuilding identity, leaderboard, and progression systems for every project.

Share this project:

Updates