uproj

You have the data — using it is the hard part

A catalog, a runtime, and an API — self-hosted

Runs on your own servers. Your data never leaves.

One pipeline, end to end

Connect any data source

A connector is just Python — new sources are a script, not a project.

Three concepts, that's the whole model

Four sources, mirrored on a schedule

All four are stock ingest scripts — same contract as anything you'd write yourself.

Optical indices — one toggle each

Each index is one band, one COG (int16 ×10000). Sentinel-2 and Landsat share the set; only Sentinel-2 has the red-edge for NDRE.

Radar that sees through cloud

Pair radar with optical for a gap-free signal; the composite gives one clean layer per day.

Each piece does one job well

Open standards, not lock-in

Your data stays portable — you are never trapped in our format.

Runs where you need it

On-prem by design — sovereignty isn't an add-on, it's the default.

From a click to a catalogued result

Every run is a sandbox

Hostile or buggy code can only affect its own run — nothing else.

Reliable by default

The contract is tiny

Zip it, upload it — that's a process. No Dockerfile, no infra.

Python, R or Java — same contract

One run contract for every language: same parameters, same storage, same catalog. Pick the runtime in process.yaml — the platform mounts the right image and dependency cache.

Same result, three languages

Proof the runtime is a choice, not a constraint — your team writes in the language it already knows.

process.yaml — declare your parameters

id: s2-ndvi
title: Sentinel-2 NDVI
category: preparation
entrypoint: src/main.py
inputs:
  - name: bbox
    type: bbox
    default: "28.8,-2.8,30.9,-1.0"
  - name: start_date
    type: string
    default: ""
  - name: max_cloud_cover
    type: integer
    default: 60

Categories drive behaviour

Pick a category; sensible scheduling and publishing come for free.

The SDK is just environment variables

import os, json

params = json.loads(os.environ["UPROJ_PARAMS"])
bbox = params["bbox"]

# read inputs straight from object storage via GDAL
src = "/vsis3/inputs/s2-l2a/.../red.tif"

# where to write + how to call back
out_dir = os.environ["UPROJ_OUTPUT_DIR"]
api     = os.environ["UPROJ_API_URL"]
token   = os.environ["UPROJ_SERVICE_TOKEN"]

Walkthrough — an ingest script

# 1. search the source for new scenes in the window
scenes = search(bbox, since=window_start)

# 2. mirror each asset into the catalog's storage
for s in scenes:
    for asset in s.assets:
        copy_to_storage(asset.url, key=object_key(s, asset))

    # 3. register the scene as a catalog item
    register_item(stac_item(s))

Walkthrough — a preprocessing script

# read bands in place, compute the index
red = read("/vsis3/inputs/s2-l2a/.../red.tif")
nir = read("/vsis3/inputs/s2-l2a/.../nir.tif")
ndvi = (nir - red) / (nir + red)

# write a cloud-optimized GeoTIFF + register it
write_cog(ndvi, f"{out_dir}/ndvi.tif")
register_item(stac_item("s2-ndvi", scene_id))

Maps · Analysis — explore results in place

Security in layers

Share deliberately, by default private

Every wider audience is a deliberate choice, never the default.

Operate with confidence

Not a notebook. Not a cloud bill.

Where it goes next