About GalaxEye

GalaxEye is a Space-Tech startup pioneering the world's first OptoSAR Earth Observation Satellite, integrating SAR (Synthetic Aperture Radar) and MSI (Multi-Spectral Imaging) on a single platform. As we move towards building a constellation of indigenous satellites, we are also developing advanced data platforms that fuse satellite data, AI analytics, and geospatial intelligence.

The short version

You'll own features end to end — schema to screen. That means the data layer and APIs that turn multi-sensor satellite data into usable intelligence, and the interfaces analysts actually use to explore it: maps, imagery, dashboards, and workflows. And you'll build a lot of it to run fully air-gapped and offline, deployed inside defense and intelligence environments with no internet access.

This is a full stack role. We care far more about how you think about data, failure, correctness, and the person on the other side of the screen than about which specific stack is on your résumé. If you're the kind of engineer who wants to know why something works — on both sides of the wire — and can pick up a new stack in weeks, you'll do well here.

What makes this different

Most full stack jobs let you reach for a managed service when things get hard — a hosted database, cloud autoscaling, a CDN for your assets, Mapbox or Google Maps for your tiles, npm install at deploy time, Stack Overflow open in the next tab. Here you often can't. Systems run on isolated, on-prem hardware with no internet at runtime. That reshapes the whole stack:

• Dependencies — frontend and backend — are vendored and mirrored; builds are reproducible and offline-friendly. No CDN, no external fonts, no third-party script tags.
  
• Map tiles, basemaps, and imagery are served from local infrastructure, not a hosted provider. The UI has to render geospatial data with no internet behind it.
  
• The frontend is offline-first by necessity: it has to work fully within a closed network, degrade sensibly, and never assume a call to the outside world will succeed.
  
• Deployment and updates happen through controlled, secure processes — not push-to-cloud.
  
• Debugging happens with limited tooling and no live lifeline; you reason from logs, the network tab, and first principles.
  

If that sounds like a fun constraint rather than an annoyance, you'll fit well here.

What you'll actually do

• Build features end to end: model the data, design the API, and build the interface — owning the whole vertical slice rather than throwing work over a wall.
  
• Design, build, and maintain clean, well-documented backend APIs — getting the contracts, error handling, and versioning right so the frontend (and other teams) can rely on them.
  
• Own the data layer: schema design, queries, indexing, migrations, and consistency, including spatial data and large raster/imagery datasets. Treat the database as something to be protected, not just written to.
  
• Build responsive, usable frontends for analysts and operators — including geospatial views: rendering maps, tile layers, and imagery, and making dense data explorable rather than overwhelming.
  
• Make it all work air-gapped and offline: bundle and vendor dependencies on both ends, serve tiles and assets locally, and design for a closed network where you can't reach out for help mid-run.
  
• Debug across the whole stack with limited observability — from a slow query to a broken render — forming a hypothesis, isolating the variable, and fixing it right rather than guessing.
  

What you'll learn here

Because this matters as much as the work:

• How to build full stack systems under real constraints — offline, on-prem, security-first — a skill very few engineers ever develop.
  
• Frontend geospatial engineering the hard way: rendering and serving maps and imagery with no hosted provider to lean on.
  
• Deep ownership of data integrity: migrations, backups, constraints, and consistency in environments where mistakes are expensive.
  
• How to stay sharp without managed services — reading source code and docs, and self-hosting what others just call an API for.
  
• Full stack at the edge of a hard domain — satellite data platforms and geospatial intelligence — alongside [a strong engineering team / a lead who owns this].
  

Requirements

What we're looking for

Genuinely required:

• 3-4 years of full stack engineering experience — you've shipped both backend services and user-facing interfaces to production.
  
• Strong fundamentals on both ends. On the backend you understand why, not just which framework method to call — transactions, indexing, idempotency, connection pooling. On the frontend you understand how the browser actually works — rendering, state, the network layer — not just one framework's happy path.
  
• Stack-agnostic ability — we're not hiring for one language or framework. Your competence comes from understanding, so you can be productive in whatever stack the problem calls for, on either side.
  
• A real sense for UX — you build interfaces for the person using them, not just to satisfy the ticket. You care whether dense, complex data is actually understandable on screen.
  
• Defensive, failure-aware thinking — you instinctively ask "what happens if this fails halfway, gets called twice, or the network drops?" and design accordingly, from the API down to how the UI handles an error state.
  
• Systematic debugging. When something breaks — anywhere in the stack — you form a hypothesis, reproduce it, and narrow it down; you don't try random fixes. Critical when you can't google your way out live.
  
• Self-sufficiency and resourcefulness — you can figure things out from source code, docs, and first principles rather than needing a live internet lifeline.
  
• Dependency discipline — you're thoughtful about pulling in third-party libraries on both ends, knowing they may need to be vendored, audited, and left un-updated for long stretches offline. (Frontend dependency trees can get heavy fast — you keep that in check.)
  
• Ownership of data integrity — you treat the database as sacred, and care about migrations, backups, and consistency.
  
• Comfort with constraints and process — security discipline, careful data handling, and working within an air-gapped environment are part of the job, not obstacles to route around.
  

Bonus (nice to have)

Any of these are a plus — we don't expect all or even most:

• Experience with geospatial/mapping frontends (e.g. Leaflet, OpenLayers, MapLibre, deck.gl) and self-hosted tile serving.
  
• Experience with air-gapped, on-prem, embedded, or high-security deployments; reproducible builds; offline package mirroring.
  
• Depth in more than one language or framework, on either side of the stack.
  
• Experience rendering or working with large raster/imagery or spatial datasets.
  
• Familiarity with containerization for isolated environments (Docker/K8s).
  
• Experience with data migration, backup, and recovery in production.
  
• Comfort reading an unfamiliar library's source to understand it.