This is a submission for the GitHub Finish-Up-A-Thon Challenge
What I Built
This is my submission for the GitHub Finish-Up-A-Thon Challenge.
The idea behind this challenge really hit home for me: finally finish what you started.
HELIX started as a satellite tracking and conjunction detection project. It already had a working backend, orbital propagation, a 3D globe, and basic AI summaries. But it still felt like a technical prototype.
For this challenge, I brought it much closer to a finished product.
I turned HELIX into an AI-powered space operations intelligence platform that can investigate orbital risk, correlate multiple space data sources, and generate explainable operational assessments.
GitHub Copilot helped me push the project from “cool prototype” to something that feels like a real mission operations console.
Demo
Github Repository :
HELIX
Coral-Powered Space Operations Intelligence Platform
HELIX is an AI-powered Space Operations Intelligence Platform that transforms fragmented orbital, launch, and space weather data into actionable mission intelligence.
Built on top of Coral's federated SQL runtime, HELIX enables operators, researchers, and analysts to investigate conjunction risks, correlate launch activity, monitor orbital congestion, and generate explainable operational assessments through multi-step AI investigations.
Unlike traditional satellite trackers, HELIX focuses on answering:
What is happening in orbit?
Why is it happening?
What should operators pay attention to next?
Why HELIX?
Earth's orbit is becoming increasingly congested.
Thousands of active satellites, frequent launches, and growing debris populations create a complex operational environment where understanding risk requires data from multiple disconnected systems.
Most tools can visualize orbital activity.
HELIX investigates it.
Using Coral as a unified intelligence layer, HELIX correlates:
- Satellite conjunction events
- Launch schedules and mission activity
- Space weather conditions
- Satellite metadata
- Historical orbital trends
…
What HELIX Does
HELIX is a local-first space situational awareness and mission intelligence platform.
It helps answer questions like:
- Why are conjunction risks elevated today?
- Which satellites repeatedly appear in high-risk events?
- Are upcoming launches contributing to orbital congestion?
- Is space weather affecting operational risk?
- What should an operator monitor next?
Instead of only showing satellite positions, HELIX performs structured investigations over operational data.
Core Features
3D Satellite Monitoring
HELIX includes a real-time globe interface for viewing satellites and conjunction events.
The frontend uses:
- Next.js
- React
- TypeScript
- Three.js
- react-globe.gl
The backend uses:
- FastAPI
- SQLite
- SGP4 orbital propagation
- KD-tree optimized conjunction detection
System Architecture:
Multi-Source Operational Intelligence
HELIX connects multiple operational data sources:
- Local satellite and conjunction database
- NOAA space weather data
- Launch Library launch data
- Space-Track metadata
These sources are exposed through Coral as SQL-queryable tables.
That means HELIX can run cross-source intelligence queries like:
conjunction risk + NOAA space weather
launch activity + current solar conditions
closest conjunctions + Space-Track object metadata
Starlink launch activity + local conjunction pressure
Multi-Step AI Investigation Agent
The biggest finish-up improvement was moving from:
prompt → query → summary
to:
prompt → investigation plan → query chain → findings → assessment → recommendations
The investigation engine is deterministic and safe.
It does not generate arbitrary SQL.
Instead, it chooses from approved Coral SQL templates and runs a bounded sequence of investigation steps.
Example investigation:
`User: Why are conjunction risks elevated today?
[1] Querying conjunction risk distribution
[2] Analyzing closest high-risk events
[3] Detecting repeated satellite involvement
[4] Comparing risk density by day
[5] Checking upcoming launch activity
[6] Checking NOAA space weather
[7] Correlating findings
[8] Generating operational recommendations`
Before and After
When I started, HELIX was primarily a space visualization prototype.
The first version could display satellites on a 3D globe and visualize orbital tracks, but the overall product was still incomplete. The core visualization layer worked, but most of the operational intelligence layer was missing. The Intel experience and the Conjunctions workflow existed mostly as ideas and partially implemented components rather than finished features.
The early version included the basic foundation:
- Satellite globe visualization
- Object counts and statistics
- Basic live status information
- Planned Intel and Conjunctions navigation
- Early conjunction detection data
While the foundation was solid, it did not yet feel like a complete operations platform. Users could observe activity in orbit, but they could not effectively investigate, analyze, or act on that information.
The Final Version
The final version of HELIX is much closer to a real mission-control-style interface.
It now includes:
- A polished interactive satellite globe
- Live satellite detail drawer
- High-risk conjunction overlays
- Conjunction count indicators and alert banners
- Fully functional Intel console
- Working Conjunctions panel
- Operational investigation workflow
- Coral-backed cross-source intelligence analysis
- AI-generated operational recommendations
The current interface transforms the globe from a visualization component into an operational workspace.
Instead of simply displaying satellites, HELIX now surfaces:
- Active high-risk conjunction events
- Detailed satellite metadata
- Live position and velocity information
- Investigation context
- Operational intelligence insights
The globe is no longer just showing data it is helping explain and investigate it.
How GitHub Copilot Helped
GitHub Copilot played a major role in turning unfinished concepts into working product features.
The most significant contributions were helping build the areas that previously existed only as plans:
- The Intel console
- The Conjunctions workflow
- Backend intelligence endpoints
- The multi-step investigation engine
- Coral SQL query chaining
- Frontend operational panels and UI states
More importantly, Copilot helped support the entire engineering workflow rather than simply generating isolated code snippets.
The process looked like this:
- Inspect the existing codebase
- Understand the backend and frontend architecture
- Identify where missing features should integrate
- Implement backend APIs
- Connect frontend interfaces
- Test the application
- Resolve integration and debugging issues
- Polish the final experience
Copilot was especially valuable for bridging the gap between planned functionality and working functionality.
Many parts of the interface already existed visually, but they were not fully connected to operational workflows. Copilot helped move the project from:
Button exists
→ Feature planned
→ Logic incomplete
to:
Button exists
→ Backend implemented
→ Frontend connected
→ Investigation workflow operational
→ Feature fully functional
Outcome
As a result, HELIX evolved from a satellite visualization prototype into a complete AI-powered space operations intelligence platform.
It now supports:
- Operational investigations
- Conjunction monitoring
- Cross-source intelligence analysis
- AI-assisted assessments
- Coral-backed data correlation
- Actionable operational recommendations
The project did not require a complete rebuild.
It required finishing the missing pieces, connecting existing systems together, and transforming concepts into working features.
GitHub Copilot helped make that transition possible.
The Comeback Story of HELIX
Before the Finish-Up-A-Thon, HELIX was a project with a lot of potential but it was stuck in the place where many ambitious side projects end up.
The foundation was already there.
It had a FastAPI backend, satellite data ingestion, orbital propagation, conjunction detection, a SQLite database, and a 3D globe interface. It could track satellites, visualize orbital activity, and identify close approaches between objects in space.
Technically, it worked.
But it didn't feel finished.
HELIX could tell users what was happening, but it struggled to explain why it was happening. The AI layer was limited to basic summaries, many features felt disconnected, and the overall experience resembled a collection of powerful components rather than a unified intelligence platform.
In short, HELIX felt more like a satellite-tracking prototype than a true mission operations system.
That was the state of the project when I began the finish-up process.
Enter GitHub Copilot
Instead of starting over, I focused on understanding what already existed.
Using GitHub Copilot and advanced GPT-5.5 style assistance, I began by inspecting the codebase, mapping the architecture, and identifying the areas that would create the biggest impact if improved.
The process became highly iterative:
- Understand the existing system
- Identify weak points
- Plan improvements
- Implement safely
- Test thoroughly
- Repeat
Rather than rewriting everything, I concentrated on strengthening what was already there.
Bringing HELIX Back to Life
The first step was cleaning up and stabilizing the architecture while preserving the satellite tracking and conjunction detection capabilities that already worked.
From there, I introduced Coral as the data orchestration layer and connected multiple operational datasets into a unified queryable system.
Suddenly, HELIX was no longer looking at isolated pieces of information.
It could correlate data across:
- Conjunction events
- Satellite metadata
- Launch activity
- NOAA space weather
- Space-Track datasets
The project started evolving from a visualization tool into an intelligence platform.
The Biggest Transformation
The most significant change was the intelligence workflow itself.
Before, the AI interaction looked something like this:
Ask a question
→ Run a query
→ Summarize the results
It worked, but it was shallow.
The system answered questions without actually investigating them.
I wanted HELIX to think more like an analyst.
So I built a deterministic investigation engine that transformed the workflow into:
Ask a question
→ Build an investigation plan
→ Execute approved Coral queries
→ Correlate findings
→ Generate an assessment
→ Recommend next actions
With the help of Copilot, I implemented:
- Multi-step investigation workflows
- Query tracing and transparency
- Passive monitoring alerts
- Operational recommendations
- Investigation timelines in the UI
- Backend intelligence endpoints
- Frontend investigation experiences
The system stopped behaving like a chatbot and started behaving like an operations analyst.
A Different Kind of Answer
Consider a question like:
Why are conjunction risks elevated today?
Previously, HELIX would have returned a simple summary of conjunction data.
Now it performs a full investigation.
It can:
- Analyze conjunction density
- Identify repeatedly involved satellites
- Check recent launch activity
- Review NOAA space weather conditions
- Compare current activity with historical patterns
- Correlate findings across multiple datasets
Only then does it generate an assessment and suggest possible operational actions.
That fundamentally changed how the platform feels.
From Prototype to Platform
The transformation wasn't about adding flashy features.
It was about connecting everything together.
GitHub Copilot helped accelerate the parts that often cause projects to stall:
- Understanding a large codebase
- Architecture planning
- Safe refactoring
- Backend development
- Frontend improvements
- SQL generation
- API debugging
- Documentation
- Final validation
Feature by feature, HELIX became more cohesive, more intelligent, and more useful.
Where HELIX Stands Today
Before the Finish-Up-A-Thon, HELIX was a promising demonstration of satellite tracking technology.
Today, it feels like a genuine AI-powered space operations console.
It can investigate, correlate, explain, and recommend not just visualize.
The project didn't need a complete rewrite.
It needed someone to finish what had already been started.
GitHub Copilot helped make that possible.
And in many ways, HELIX's biggest achievement wasn't the technology itself—it was finally crossing the line from almost finished to fully realized.
My Experience with GitHub Copilot
How GitHub Copilot Helped
I used GitHub Copilot heavily throughout the finish-up process, specifically with advanced ChatGPT/GPT-5.5 style coding assistance.
Copilot helped with:
- reading and understanding the existing codebase
- planning the architecture
- refactoring the project safely
- adding the investigation engine
- creating backend endpoints
- improving the frontend UI
- generating SQL query templates
- debugging API issues
- writing documentation
- validating the final build
The most valuable part was not just code generation. It was the ability to work iteratively:
- inspect the existing project
- identify weak points
- plan the next phase
- implement safely
- test
- repeat
That workflow made it possible to finish a project that otherwise could have stayed half-done.
Top comments (0)