Backend Engineer, ML systems

What matters most

• Satellite-data APIs

  Source-backed: Build backend services that fuse SAR and multispectral data and deliver geospatial analytics to analysts. Preparation: Be ready to explain how an API would expose useful results while keeping request handling and failures understandable.

• Imagery data at scale

  Source-backed: Model large raster and imagery datasets and build queries and data pipelines that hold up at scale. Preparation: Review how data layout and query patterns affect performance; geospatial tools are listed as bonuses, not requirements.

• Offline production inference

  Source-backed: Turn ML models into reliable, monitored, self-hosted services and build imagery inference pipelines under GPU constraints. Preparation: Walk through the steps from a working model to an offline service, including health checks and failure handling.

• Self-contained evaluation and analyst workflows

  Source-backed: Contribute to tools that chain steps and call local tools, fail gracefully, and use local evaluations, logging and monitoring to judge changes. Preparation: Consider how to trace a workflow and compare outcomes when there is no simple pass/fail answer.

• Disciplined work in an air gap

  Source-backed: Builds must be reproducible and offline-friendly; deployment and updates follow controlled, secure processes. The role also emphasizes systematic debugging, careful data handling and clear communication of blockers. Preparation: Have a clear method for narrowing down faults without relying on internet access.

Likely challenges to think through

• Balancing inference speed and capacity

  Likely challenge, not a confirmed problem: Batching can improve throughput but increase response latency, while GPU capacity limits both. Prepare to explain how workload measurements would guide batch sizes and how to detect an unhealthy pipeline.

• Diagnosing uncertain outputs

  Likely challenge, not a confirmed problem: An analyst-facing chain may complete technically yet produce an unreliable result. Prepare an approach for tracing local tool calls, recording outcomes safely and using repeatable evaluations to decide whether a change helped.

• Shipping updates without cloud conveniences

  Likely challenge, not a confirmed problem: Offline dependencies and controlled updates make rapid fixes harder to reconcile with reproducibility and security. Prepare to discuss dependency packaging, build verification and a systematic way to isolate faults before proposing an update.

Topics to prepare

• Backend request lifecycle

  Required fundamentals include reasoning from an incoming request to an outgoing response. Revision exercise: trace a hypothetical geospatial API request through input handling, data retrieval, processing, failure handling and response generation; explain where you would investigate latency or incorrect results.

• Systematic debugging

  The posting explicitly asks for hypothesis-driven debugging. Revision exercise: given an intermittent incorrect analytics response, write down a reproducible case, two competing hypotheses and the evidence that would distinguish them.

• Offline and security constraints

  The systems run on isolated, on-prem hardware; builds, updates and monitoring must work without internet access. Revision exercise: explain what changes when runtime downloads, external inference endpoints and push-to-cloud updates are unavailable. Treat any proposed deployment approach as preparation, not a stated company process.

• Inference performance tradeoffs

  The role involves imagery inference, batching, latency, throughput and GPU constraints. Revision exercise: compare small and large batches for a hypothetical local model and explain what measurements would guide the choice.

• Evaluating uncertain outcomes

  The posting calls for self-contained evaluations of systems where correctness can be fuzzy, including agentic workflows that call local tools. Revision exercise: define example success and failure cases for a multi-step analyst workflow, including how you would detect a graceful failure.

• SAR and multispectral data context

  GalaxEye describes a platform integrating SAR and multispectral imaging and calls geospatial experience a bonus. Optional revision exercise: explain at a high level what each data type represents and list questions you would ask before combining their imagery; specialist experience is not stated as required.

Skills to revise

• Implement a geospatial API slice

  The role builds backend services and APIs for analyst-facing geospatial analytics. Practice suggestion: implement a small endpoint over sample or synthetic imagery metadata, then test valid inputs, missing data and an error response.

• Model and query imagery metadata

  The work includes database design, queries and data flows for large raster and imagery datasets. Practice suggestion: design records linking an image to its sensor, footprint and processing status; write queries for an area and time range, and explain how you would check them as the dataset grows.

• Run a model locally

  Hands-on ML exposure is required; locally running or self-hosting a model is described as ideal. Practice suggestion: run a small model without an external inference endpoint, expose a local prediction path and record what happens on invalid input. No particular serving tool is required.

• Instrument and evaluate a pipeline

  The role calls for self-contained logging, monitoring and evaluations. Practice suggestion: add local logs and a repeatable set of test inputs to a small inference pipeline; compare outputs and failures before and after a deliberate change.

• Check an offline build

  The posting describes reproducible, offline-friendly builds and controlled updates. Practice suggestion: assemble a small service with its dependencies available locally, repeat the build without network access and document any missing dependency or non-reproducible step. This is an exercise, not a claimed employer deployment procedure.

• Prepare a backend project walkthrough

  Choose a project you can explain from incoming request to response. Show API design, data handling, a failure you debugged systematically, and what you changed. The role emphasizes backend fundamentals and hypothesis-driven debugging.

• Sketch a satellite-imagery data flow

  As a design exercise, draw how SAR and multispectral imagery could enter a pipeline, be stored and queried, and reach an analyst-facing API. Label assumptions and discuss how large raster datasets affect the design.

• Explain a local model-serving example

  Prepare a walkthrough of any model you have run locally, or a clearly hypothetical serving design. Cover the inference request path, batching, latency versus throughput, GPU limits, and how you would detect service failures without an external endpoint.

• Draft an offline deployment plan

  Outline how you would package dependencies, reproduce a build, and deploy or update a service on isolated on-premises hardware. Mark security and data-handling decisions as questions rather than assuming GalaxEye's procedures.

• Design a small evaluation and monitoring exercise

  Propose sample inputs, expected checks, logs, and metrics for an imagery pipeline or a tool-chaining workflow. Include how you would investigate uncertain outputs and graceful failures using self-contained evidence.

• Collect evidence of learning and communication

  Prepare one concise account of learning an unfamiliar technical topic: what you read or tested, how you verified understanding, where you got stuck, and when you raised a blocker. These behaviors are explicitly emphasized in the posting.

• Write questions about the working constraints

  Ask which imagery formats and analyst workflows matter first, what local hardware and deployment constraints apply, and how the team evaluates model or workflow changes. Use the answers to refine your design assumptions.