Turning satellites into usable data.

This is my day-to-day work: building the pipelines and interfaces that turn raw satellite imagery and geospatial records into clean, queryable products that teams use every day. It's a full-stack job in the truest sense — from batch data processing deep in the backend all the way to the interactive map a user actually clicks on.

What the platform does

At heart, it answers spatial questions over an enormous, constantly-growing pile of earth-observation data. A user wants to know what's happening inside a particular boundary — an administrative region, a plot of land, an area of interest — and how it's changing over time. Behind that simple question sits terabytes of satellite scenes that can't all be read on demand. My work is the machinery that makes the answer feel instant.

Ingest — cataloguing the imagery

Satellite imagery arrives as huge scenes tagged with time, ground footprint, and spectral-band metadata. Rather than manage files by hand, I index them with STAC (the SpatioTemporal Asset Catalog standard) so scenes become searchable by area of interest and time window. That indexing step is what lets everything downstream ask for exactly the few scenes it needs and ignore the thousands it doesn't — filtering by footprint, date, and cloud cover before anything heavy runs.

Process — batch geospatial pipelines

Once the right scenes are found, they're processed region by region: reprojected to a common coordinate system, clipped to the exact boundary, and reduced to the values that matter downstream. The important design decisions here are about surviving scale rather than clever algorithms:

• Runs are idempotent and resumable — a job over thousands of regions can be interrupted and picked back up without redoing finished work or double-counting.
• Data-quality checks are first-class, so a missing or corrupt scene is recorded and surfaced rather than silently poisoning an output.
• Raster and vector operations meet here — clipping imagery to boundaries with the standard Python geospatial stack, run as repeatable batch jobs, not one-off scripts.

I wrote up the thinking behind this part in more depth in the Lab: Processing a country's worth of raster →

Serve — APIs over a spatial database

Processed results land in PostgreSQL / PostGIS, exposed through Python service APIs. Spatial indexes make area and point lookups fast, and the APIs return GeoJSON that a map can render directly — so a front end can ask "what's inside this boundary?" or "what changed over time?" without ever touching raw imagery again. The whole thing runs on AWS.

Visualise — React dashboards on top

The last mile is making heavy data feel light. Interactive map front-ends in React render the geospatial layers the APIs serve, with filtering and drill-down by region and time so people explore the data instead of just staring at it. That span — owning a feature from the batch job that produces the numbers to the pixel that displays them — is the part of this work I like most.