AIRSIDE

Glimpse of the software

Inspiration

Airports are fascinating because they are systems where many things have to happen at the right time, while resources such as gates and runway capacity are limited. A small delay can quickly create another problem somewhere else.

I wanted to turn that kind of real-world complexity into a game without making the game itself complicated. The idea behind AIRSIDE came from a simple question: “What should I deal with first?”

Instead of making another flight simulator or airport tycoon game, I wanted the player to manage the operation itself and experience the consequences of those decisions in real time.

What it does

AIRSIDE is a single-player, real-time airport operations strategy game.

The player manages a busy airport during a five-minute peak period. Flights arrive with different levels of urgency, while the airport has only a limited number of gates available.

The core loop is:

Observe → Prioritize → Assign → Consequence → Adapt → Repeat

The player selects incoming flights and assigns them to available gates. Aircraft then land, taxi to their assigned gate, undergo turnaround, and eventually depart. As traffic increases, disruptions and competing priorities force the player to make increasingly difficult decisions.

For example, two priority aircraft may arrive only seconds apart when only one gate is available. The player has to decide which flight should receive the gate first and accept the consequences of that decision.

Delays affect the airport's performance, passenger satisfaction, efficiency, and score. The goal is to keep the airport operating successfully until the peak period ends.

How I built it

I built AIRSIDE in HTML, CSS, and JavaScript, using Three.js for the airport visualization and aircraft movement.

I developed the project in VS Code with Codex doing the heavy lifting on the implementation. I used AI to build and iterate on the playable systems, interface, airport scene, aircraft animations, scoring, escalation, and game-state logic, while I directed the design, tested the game, identified problems, and decided what needed to change.

I kept the architecture deliberately simple. The final prototype is self-contained, uses local assets and libraries, and is designed to run offline without external network requests.

Challenges I ran into

The biggest challenge was not getting the game to run—it was making the game understandable.

My first playable version technically contained the core mechanics, but when I played it for the first time, I scored 0 points because I did not immediately understand how I was supposed to interact with the game. The interface felt more like a dashboard than an airport.

That playtest exposed an important problem: a management game cannot rely on the player already understanding its systems.

I then redesigned the experience around a short tutorial, single-click interaction, a visible airport environment, and animated aircraft. The aircraft became a way of communicating what the player's decisions were doing rather than simply being decoration.

Balancing the pressure was another challenge. The game needed to be simple enough to understand quickly but difficult enough to create meaningful decisions. During testing, situations such as two priority flights competing for one available gate became particularly important because they created genuine strategic choices.

Accomplishments that I'm proud of

I'm most proud that AIRSIDE evolved from a functional prototype into something that I could actually play without explaining the rules to myself.

My first attempts resulted in 0 points. After improving the interaction and presentation, I scored 1,242, then 1,589, and then 1,200 on subsequent runs.

More importantly, the scores were not the only improvement. I started encountering situations where I genuinely had to prioritize one flight over another because the airport did not have enough resources to handle everything immediately.

That is the experience I wanted AIRSIDE to create.

I also managed to keep the concept focused. The aircraft are not the game. The decisions between them are the game.

What I learned

I learned that making a system realistic is not the same as making it fun.

For AIRSIDE, I had to abstract airport operations into a small number of understandable decisions. The player does not need to know every detail of real-world aviation operations; they need to understand what resources are available, what is becoming urgent, and what will happen because of their decision.

I also learned how valuable direct playtesting is. My first version looked reasonable from a development perspective, but playing it myself immediately revealed that the interaction was unclear.

Most importantly, I learned that good management gameplay comes from interacting constraints, not from simply adding more features.

What's next for AIRSIDE

The prototype establishes the core airport-management loop, but there is considerable room to expand it.

Future versions could introduce more complex disruptions, additional airport resources, different airport layouts, weather events, more sophisticated passenger-flow systems, and increasingly challenging scenarios.

The longer-term vision is to explore AIRSIDE's core idea beyond airports as well: taking complex real-world systems and turning them into accessible strategy games where the player constantly has to decide what deserves attention next.

For now, the goal is simpler: make the five-minute airport shift as engaging, readable, and replayable as possible.