The Vision
Watching the rapid acceleration of the Middle East's space sector—from the UAE's Mars missions to Oman's recent Aman-1 launch—inspired me to build something that bridges the gap between software engineering and orbital mechanics. I wanted to create a tool that didn't just display static data, but actively modeled physical systems in real-time.
The result is MENA Orbital Command, a custom-built, full-stack 3D telemetry dashboard that tracks and projects the trajectories of regional satellites using live Earth-Centered Inertial (ECI) data.
System Architecture & Data Pipeline
Building this required stepping out of the standard web-development sandbox and treating the software like a mission control system. I separated the architecture into three distinct layers:
- The Data Aggregator (Python): A custom backend script runs on a server, parsing complex Two-Line Element (TLE) sets from global space defense databases. It cleans and standardizes this data, focusing specifically on assets from Qatar, the UAE, KSA, Egypt, and Oman.
- The API Layer (Laravel/PHP): To ensure the frontend remained fast and lightweight, I decoupled the data layer using the Laravel framework. The application serves a strictly formatted JSON payload via a RESTful API, shielding the database from frontend traffic spikes.
- The Physics Engine (JavaScript/WebGL): The presentation layer is powered by Three.js and Globe.gl. Rather than asking the server where the satellites are, the browser downloads the raw orbital parameters and uses satellite.js to perform the heavy calculus locally, propagating the satellites' positions forward in time.
Overcoming Engineering Challenges
The true value of this project wasn't in following a tutorial, but in debugging complex edge cases where web development intersects with physics.
<u>The "Ball of Yarn" Rendering Issue</u> Initially, I programmed the engine to draw a full 24-hour orbital path for every satellite. While this worked perfectly for Geostationary (GEO) satellites like Qatar's Es'hail series, it caused a critical visual failure for Low Earth Orbit (LEO) satellites like the UAE's KhalifaSat. Because LEO satellites orbit every 90 minutes while the Earth rotates beneath them, drawing 24 hours of data created a massive, tangled web of cyan lines that crashed the browser's frame rate.
- The Solution: I implemented a dynamic Altitude Heuristic. The code now actively checks a satellite's geodetic height in real-time. If it is in deep space (> 20,000 km), it calculates a full 24-hour ring. If it is in Low Earth Orbit, it mathematically constraints the rendering to a single 100-minute loop, keeping the UI clean and highly performant.
<u>DOM Memory Leaks and State Management</u> To attach names and altitudes to the 3D models, I initially used floating HTML elements linked to the Three.js canvas. However, because the orbital math recalculates positions 60 times a second, the browser's Document Object Model (DOM) couldn't destroy and recreate the HTML tags fast enough, resulting in a severe memory leak.
- The Solution: I completely re-engineered the rendering loop. I introduced strict state management flags (pathsCalculated) to ensure heavy trajectory geometry is only calculated once on page load, while only the lightweight point-coordinates are updated every second. I also migrated all labels directly into the WebGL canvas natively, bypassing the HTML DOM entirely and restoring the application to a flawless 60 FPS.
Deployment & DevOps
To bring the project to life, I bypassed standard shared hosting and deployed the architecture to a Contabo Virtual Private Server (VPS) running Ubuntu. I manually configured an Nginx web server, wired it to a dedicated PHP-FPM socket, and secured the sub-domain via Certbot/SSL.
Conclusion
MENA Orbital Command taught me that software engineering isn't just about moving data from a database to a screen; it's about translating the physical world into digital logic. Whether I am routing packets across a server or predicting the coordinate transformation of a satellite moving at 7 kilometers per second, the core engineering principle remains the same: build systems that are efficient, scalable, and mathematically sound.