Full Stack Engineer, On-Prem Systems

About GalaxEye

GalaxEye is a
Space-Tech startup pioneering the world's first Multi-Sensor 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.