When a tiny browser game became an infrastructure problem

Orbit started with a small question: could a browser game built around a single input still be genuinely compelling?

The mechanic was deliberately simple. A small astronaut orbited one planet. The player released at exactly the right moment and tried to land on the next one. Get the timing wrong and the astronaut disappeared into space. Get it right and the journey continued.

There was no grand product strategy behind it. I wanted to build something immediate—simple enough to understand without instructions, but difficult enough to make another attempt feel irresistible.

AI dramatically shortened the distance between the idea in my head and a game I could actually play. I could describe the mechanic, test the result, identify why it felt unfair, adjust the physics and repeat the process until the experience began to feel right.

At that stage, my definition of success was modest: the mechanic worked, the game felt fair and I enjoyed playing it. Then I shared it.

A few friends started playing. Before long, scores were appearing in group chats.

Someone would post a new personal best. Somebody else would immediately try to beat it. Screenshots became proof. Scores that had meant nothing in isolation suddenly carried bragging rights.

The original version of Orbit had no social system. Each player was competing only against their own previous run. But the players created a competition outside the product before I had designed one inside it.

That behaviour made the next feature obvious: Orbit needed a global leaderboard.

Players could choose a name, submit their best score and see exactly where they stood. Each browser identity could hold one leaderboard position, and a new score would only replace it if the player had genuinely improved.

A leaderboard sounds like a small feature. It changed the entire product. Orbit was no longer simply a private interaction between one player and one game mechanic. Every attempt now existed inside a shared contest.

The leaderboard did not create the competitive instinct. It gave that instinct somewhere to live.

Once the leaderboard appeared, traffic rose dramatically.

People were no longer playing once, satisfying their curiosity and moving on. They were returning to protect a position, chase a friend or improve a score that somebody else could now see.

That loop also created new obligations. Player names needed to remain connected to the correct browser identities. Personal bests needed to survive a reload. A great run could not disappear because a mobile keyboard closed at the wrong moment. The leaderboard needed to reject lower scores without preventing somebody from submitting a genuine new high.

These were not glamorous additions. Most players would never consciously notice them when they worked correctly.

But the moment people cared about the outcome, persistence and fairness stopped being background technical details. They became part of the product experience.

That was the point where Orbit stopped behaving like a playful prototype and started behaving like a real product.

• Play
• Compare
• Retry
• Return

Around the same time, the original hosting became unreliable.

The rise in traffic did not necessarily cause every hosting problem. But it completely changed the consequences of those problems.

When Orbit was only an experiment on my laptop, an outage was annoying. Once people had names, high scores and a reason to return, an outage became a trust problem.

The public address had already been shared. Players had browser identities and stored personal-best information. The backend held a growing leaderboard and analytics history. People were returning with the reasonable expectation that the game—and their place within it—would still be there.

Moving to a more dependable host was clearly necessary. Unfortunately, Orbit was no longer something that could simply be copied into a new folder and switched on elsewhere.

A careless migration could have produced a perfectly functioning game that had forgotten everyone who had played it.

The transfer to Cloudflare became a form of surgery.

The visible game needed to remain the same while nearly everything underneath it changed.

The public address had to stay intact so existing links would continue working. Browser identities needed to remain recognizable after the move. The complete leaderboard had to arrive without losing or duplicating scores. Analytics history needed to remain available. Score-recovery behaviour still had to work. The private administration area had to remain private.

Most importantly, the original version could not be removed until the replacement had been proven.

We approached the move in stages. The existing system was inventoried. Browser storage and backend data were mapped. A separate staging environment was created. The new version was tested without touching the live domain. Leaderboard records were reconciled before and after the transfer. A rollback path remained available until the new system was confirmed to be working.

Only then did the public address move to Cloudflare.

The most important result was wonderfully boring: people could keep playing.

The same names were present. The same high scores remained on the leaderboard. Existing players did not need to reintroduce themselves. The game looked almost unchanged because, from their perspective, almost nothing was supposed to change.

That invisibility was the point.

A successful infrastructure migration should be dramatic for the people doing it and uneventful for everyone using the product.

The speed of AI-assisted building made Orbit possible for me.

But the most interesting work began after the first version existed.

Real behaviour revealed the need for a leaderboard. The leaderboard revealed a retention loop. Returning players raised the standard for fairness and persistence. Growing usage made unreliable hosting unacceptable. The migration then forced decisions about identity, data, continuity and risk that the original prototype had never needed.

None of that was visible when Orbit was still an idea.

This is what I increasingly find most compelling about building with AI. The first build is becoming faster, but that does not eliminate product work. It gets us to the real product questions sooner.

What do people actually value? What behaviour does a new feature create? Which parts of the experience must never be lost? When does a temporary solution become a liability? And when has an experiment earned the right to be treated like a product?

Orbit began with one mechanic and no meaningful expectations. Then people started competing, returning and caring about what happened to their scores.

That changed everything.

A prototype becomes a product when somebody else starts caring whether it still works tomorrow.