Space

Mission planning tools, data platforms, and the operations software your teams rely on daily — built for work where a wrong call is expensive.

Space programs rely on complex data pipelines, simulation tools, and highly specialised user workflows. Success, clarity and reliability are essential to minimise the cost of experimentation.

Built for complex systems

We build software that holds up across long programs, from first launch to years of operations:

  • High-reliability interfaces and interaction design
  • Advanced data visualisation
  • Scenario modelling and simulation support
  • Tools that make a clear decision easy to reach under pressure
  • Architecture that scales as the program grows

Mission wide solutions

Our team can deliver a wide range of software to support your space program. Some examples:

  • Mission planning and analysis tools
  • Satellite data platforms and dashboards
  • Interfaces to manage ground systems
  • Research and collaboration tools
  • Operations software for the day-to-day running of a mission

How do space teams work with us?

Every one of them starts with a Rapid Insight Workshop: a paid session that maps your operation and hands back a prioritised roadmap. What you do next depends on what it finds.

Apex

We stay embedded and work through the roadmap with you month after month, across a programme that runs for years. One monthly fee, measured against results we agree at the start. From $15K a month, six-month minimum term.

Amplify

One build, scoped in writing before anything starts, then quoted at a fixed price against that scope. A one-year warranty, and the code and the IP are yours. Typically $100K and up.

Ignite

Prove a data or simulation tool before a full build. Fixed price, $25K to $50K, and working software in four to eight weeks — enough to test it with real users before you spend more.

Between your analysis tools, your ground station and your telemetry

A space programme runs on specialist tools that were never meant to be a system: STK or GMAT for mission analysis, a ground segment on AWS Ground Station, telemetry in CCSDS formats, and analysis in Python notebooks on someone's machine. The answer takes a day to reproduce.

CodeFish builds across those gaps: ingestion and processing for telemetry at volume, interfaces that help a team compare scenarios and decide, and tooling that turns a researcher's notebook into something the whole programme can run.

Questions space teams ask us

With a Rapid Insight Workshop. It maps the operational and data picture of the programme: which tools your team actually relies on, where analysis is being done by hand or in spreadsheets, and which fix returns the most. You get a prioritised roadmap back before committing to a build. From there you either test one idea first (Ignite), build one thing at a fixed price and own it outright (Amplify), or keep us on to work through the roadmap with you month after month (Apex). We will tell you honestly which one fits.

Yes, and it is most of our work in this sector. We collaborate with highly technical stakeholders who understand their domain far better than we do, so our job is to turn that understanding into a usable system rather than to second-guess the science. We provide engineering, design and strategic support alongside your specialists.

Yes. Space programmes run on complex data pipelines, and the work is in making large volumes of telemetry and satellite data legible without hiding the uncertainty in it. We build the ingestion and processing layer, then the visualisation on top, so analysts can interrogate the data rather than wait on someone to export it.

Yes. Scenario modelling and simulation support is a core part of what we build, along with the interfaces that let a team compare outcomes and make a decision from them. The aim is to reduce the cost of experimentation, so trying an option is cheap and the result is clear.

Reliability is designed in at the interface level as well as the infrastructure level. High-reliability interaction design means the system makes its state unambiguous, fails visibly rather than silently, and does not let a user take an irreversible action by accident. In this sector an unclear interface is a mission risk.

Yes. We understand how space funding actually arrives and structure engagements to support phased delivery that evolves alongside the mission. That means each phase produces something usable in its own right, and the architecture is built to be extended by the next phase rather than replaced by it.

Yes. These are the tools and standards a programme already runs on, and our job is to build around them rather than replace them. That usually means ingesting and normalising telemetry, wiring the analysis tools into a shared pipeline, and putting the result somewhere the whole team can query instead of one person's machine.

Yes, and it is common work in this sector. A notebook that answers the question is not the same as a system the programme can depend on. We keep the science exactly as your specialists defined it, then build the ingestion, the testing, the interface and the reproducibility around it so the answer holds up when someone else needs it in two years.

Export controls decide who can see your data and code, so we set them as access rules before any build starts. Australian programmes can fall under the Defence Trade Controls Act and the Defence and Strategic Goods List, and work involving US-origin technology can bring in ITAR or the EAR. Your export control officer decides what is controlled; we make the system enforce that decision. That means tagging controlled data, limiting access by person and nationality where the rules require it, hosting in Australia when needed, and keeping an access log you can show an auditor. Where a rule limits who on our side can work on a component, we agree that in writing at scoping.

Yes, your analysis can stay in Python, and in most cases it should. Your specialists already know the language, and libraries such as NumPy, SciPy, Astropy and Skyfield carry years of checked work. We wrap your existing code rather than rewrite it: package the functions, pin the library versions, add tests that compare results against known cases, and run it on a shared server or pipeline instead of one laptop. Notebooks stay as the place researchers explore. The parts the programme depends on move into tested modules that the notebooks, the dashboards and the scheduled jobs all call, so everyone gets the same answer.

Maintenance is planned at the start, so the tool keeps running after the grant money stops. Funding from a university research grant or an Australian Space Agency programme often has a hard end date and no line for upkeep. We build with that in mind: documentation your next engineer can follow, automated tests, low hosting costs, and code and IP that belong to you. Before the funding ends, you choose how it is looked after: hand it to your own staff, keep us on through Apex for ongoing work, or leave it running with occasional fixes. The decision is made while there is still budget to act on it.

Security clearance requirements are discussed per programme, before any work is scoped. Some space work needs people cleared by the Australian Government Security Vetting Agency (AGSVA) at a set level, some needs membership of the Defence Industry Security Program, and a lot of it needs neither. Tell us in the first conversation what your programme requires and which data or systems sit behind those requirements. We will tell you plainly what we can meet and how. Where a rule means only cleared people can touch one component, the system can be designed so that part sits apart from the rest of the work.

When a researcher leaves, the tool should keep working, because the knowledge lives in the code and not only in their head. Long programmes make this a real risk: a PhD student finishes, a postdoc moves on, and the script that processes your mission data only runs on their laptop with a library version nobody wrote down. We close that gap during the build. Each calculation is documented beside the code with its source and assumptions, inputs and outputs are tested against known results, and the tool runs from a shared repository with written setup steps. A new engineer can pick it up in days instead of reverse-engineering it.

Ready to build something great?

Local partners, global standards – full service design and development.