satelliteforecastingagriculture

Combining Satellite-Derived Vegetation Indices with Futures to Predict Wheat Price Reversals

UUnknown

2026-02-13

10 min read

Practical 2026 tutorial: combine NDVI satellite data with MPLS and other wheat futures to predict Thursday-to-Friday bouncebacks with code, SQL, and deployment tips.

Hook: Turn satellite NDVI into actionable wheat trade signals — faster, reproducible, and cloud-native

Technology teams and quant traders building commodity signals face three recurring pain points: fragmented global datasets, unclear update cadence and licensing, and brittle pipelines that fail when satellite or market feeds lag. This tutorial shows how to combine NDVI satellite data with wheat futures time series (including MPLS spring wheat) to predict short-term wheat price reversals — the kind of early Friday bouncebacks traders report after Thursday weakness — with reproducible code, SQL, and operational guidance for 2026.

What you'll learn (fast)

Which 2026 satellite NDVI sources are production-ready and how to ingest them (Sentinel‑2, MODIS, VIIRS, Planet/PlanetScope considerations)
How to map NDVI to exchange contracts (MPLS / Chicago SRW / KC HRW) and compute regional aggregates
Feature engineering recipes that anticipate bouncebacks (anomalies, rate-of-change, soil moisture proxies)
Modeling pipelines (LightGBM + Transformer/LSTM hybrids) and a labeling/backtest method for Thursday-to-Friday reversals
SQL and Python examples to implement in TimescaleDB and cloud workflows (Airflow, Prefect, or serverless cron)

The 2026 context: why this works now

Two trends made NDVI-to-futures forecasting materially more practical by late 2025 and into 2026:

Open-data hosting matured: Sentinel‑2 surface reflectance and MODIS L2/L3 products are widely available on cloud public datasets (AWS, GCP) with faster access patterns and cheaper egress for enterprise plans.
ML for time series advanced: Transformer-based time-series models, self-supervised pretraining, and vectorized feature stores in 2024–2026 have reduced model training cost and improved few-week forecast skill for commodity signals.

High-level pipeline

Ingest satellite NDVI (daily/weekly tiles) and futures tick/candle time series
Aggregate NDVI by contract-weighted production regions and compute features
Label historical Thursdays that were followed by early Friday gains (bouncebacks)
Train & validate models with cross-validation and event-aware backtesting
Deploy model, run daily inference before the US open, and generate alerts/dashboards

Data sources and licensing (practical choices for 2026)

Pick sources based on latency, spatial resolution, and licensing:

Sentinel‑2 (ESA) — 10–20m resolution NDVI (L2A surface reflectance). Good spatial detail for region-specific crop health. Hosted on AWS/GCP public datasets. License: Copernicus (open).
MODIS (Terra/Aqua) — daily global coverage, 250m NDVI (useful as gap-filler and long-term baseline). License: open.
VIIRS — good for cloud-penetrating composites and daily anomalies.
PlanetScope / SkySat — commercial, sub-3m daily revisit; high cost but excellent for paid pilots. In 2025–26, enterprise contracts improved programmatic access; evaluate carefully for licensing/cost.
Market data — CME/ICE feeds for Chicago SRW, KC HRW, MPLS spring wheat. Use a vendor with tick/candle APIs or direct exchange feed for low latency.

Ingest NDVI: sample Python using xarray + s3fs (Sentinel‑2 on AWS)

Below is a simplified example to load precomputed NDVI (cloud-masked) from an S3 prefix and resample to weekly mean. Adjust for your bucket/key layout.

# Python: read NDVI tiles from S3, compute weekly mean
import xarray as xr
import s3fs
import pandas as pd

s3 = s3fs.S3FileSystem(anon=True)  # or authenticated
prefix = 'sentinel-s2-l2a-ndvi/tiles/2025/'
keys = s3.ls(prefix)

# open with xarray (NetCDF/Cloud-optimized GeoTIFF recommended)
ds = xr.open_mfdataset([f's3://{k}' for k in keys], engine='rasterio', concat_dim='time')
# assume time dimension exists and variable 'ndvi'
daily_ndvi = ds['ndvi']
weekly_ndvi = daily_ndvi.resample(time='7D').mean()

# reduce to region bounding box (example: US northern plains)
region = dict(min_lon=-105, max_lon=-95, min_lat=40, max_lat=49)
subset = weekly_ndvi.sel(x=slice(region['min_lon'], region['max_lon']), y=slice(region['max_lat'], region['min_lat']))
weekly_mean = subset.mean(dim=['x','y'])
print(weekly_mean)

Tip: use cloud-optimized GeoTIFFs (COGs) and rasterio/vsi-s3 for scalable reads.

Map NDVI to futures contracts (geospatial weighting)

Each contract reflects production in different geography and crop class. For example:

MPLS — spring wheat; emphasize northern plains (ND, MN, MT)
KC HRW — hard red winter; emphasize central/southern plains
Chicago SRW — soft red winter; emphasize Midwest & Ohio Valley

Steps:

Define polygon sets for major producing counties (USDA NASS county map) or use international equivalents for Russia, EU, Canada, Argentina.
Compute area-weighted NDVI per polygon and then contract-weighted average using production share.
Store aggregates in a time-series DB for join with market ticks.

Example SQL schema (TimescaleDB)

-- timescale hypertable for NDVI aggregates
CREATE TABLE ndvi_weekly (
  ts timestamptz NOT NULL,
  contract text NOT NULL,
  region_id text NOT NULL,
  ndvi_mean double precision,
  ndvi_sd double precision,
  observation_count int
);
SELECT create_hypertable('ndvi_weekly', 'ts');

-- futures candles
CREATE TABLE futures_candles (
  ts timestamptz NOT NULL,
  contract text NOT NULL,
  open double precision,
  high double precision,
  low double precision,
  close double precision,
  volume bigint
);
SELECT create_hypertable('futures_candles', 'ts');

Labeling bouncebacks: operational definition

A repeatable label is crucial. Define a Thursday drop + Friday AM gain as a 'bounceback' event:

Bounceback = (Thursday close < Thursday open by at least X bps) AND (Friday 09:30–11:00 local exchange window shows net positive return > Y bps)

Example parameters: X = 0.5% decline, Y = 0.3% intraday gain. You can tune X/Y by backtest. Label historical Thursdays with 1/0 accordingly.

SQL labeling example

-- flag Thursday events and Friday AM returns
WITH thur AS (
  SELECT date_trunc('day', ts) as day, contract,
         last(close, ts) FILTER (WHERE date_part('dow', ts)=4) as thur_close,
         first(open, ts) FILTER (WHERE date_part('dow', ts)=4) as thur_open
  FROM futures_candles
  GROUP BY day, contract
), fri_am AS (
  SELECT date_trunc('day', ts) as day, contract,
         first(close, ts) FILTER (WHERE date_part('dow', ts)=5 AND date_part('hour', ts) BETWEEN 9 AND 11) as fri_am_close,
         first(open, ts) FILTER (WHERE date_part('dow', ts)=5) as fri_open
  FROM futures_candles
  GROUP BY day, contract
)
SELECT t.day, t.contract,
       (t.thur_close - t.thur_open)/t.thur_open as thur_ret,
       (f.fri_am_close - t.thur_close)/t.thur_close as fri_am_ret,
       CASE WHEN (t.thur_close < t.thur_open * 0.995) AND ((f.fri_am_close - t.thur_close)/t.thur_close > 0.003) THEN 1 ELSE 0 END as bounceback
FROM thur t
JOIN fri_am f USING (day, contract);

Feature engineering recipes (what improves signal)

NDVI anomalies: NDVI deviation from multi-year weekly baseline (z-score over 3–5 year window).
NDVI trend/delta: 7-day and 21-day NDVI rate-of-change (ROC).
Vegetation stress index: combine NDVI with land surface temperature (LST) or modeled soil moisture proxies if available.
Cloud-coverage flags: quality masks — don’t trust NDVI under >30% cloud cover.
Market microstructure: Thursday close volatility (realized vol), open interest change, and volume spikes.
Macro flags: weather advisories, export policy news (encoded as binary features).

Modeling approaches: hybrid wins in practice

In production we recommend a hybrid approach:

Baseline logistic or LightGBM using tabular features (NDVI aggregates, deltas, vol, OI). Fast to train and robust.
Sequence models (Transformer or LSTM) trained on recent windows to capture temporal dependencies — use when you have >3 years of aligned weekly data.
Ensemble of the two with probability calibration (Platt scaling) and expected P&L ranking. For model explainability, incorporate open-source toolkits and reviews such as model explainability and detection tool roundups to help with auditability.

Python example: LightGBM training skeleton

import lightgbm as lgb
from sklearn.model_selection import TimeSeriesSplit
from sklearn.metrics import roc_auc_score

X, y = load_training_matrix()  # features aligned to Thursday
tscv = TimeSeriesSplit(n_splits=5)
models = []
for train_idx, val_idx in tscv.split(X):
    dtrain = lgb.Dataset(X.iloc[train_idx], label=y.iloc[train_idx])
    dval = lgb.Dataset(X.iloc[val_idx], label=y.iloc[val_idx])
    params = {'objective':'binary', 'metric':'auc', 'learning_rate':0.05}
    m = lgb.train(params, dtrain, valid_sets=[dtrain,dval], early_stopping_rounds=50)
    models.append(m)
print('CV AUC:', np.mean([roc_auc_score(y.iloc[val_idx], m.predict(X.iloc[val_idx])) for m, (train_idx,val_idx) in zip(models, tscv.split(X))]))

Sequence model note (Transformer)

Use a sliding window of recent NDVI + market features (e.g., last 8 weeks). Transformers can capture cross-feature interactions and weekly seasonality. Pretrain with self-supervised objectives (masked time-step prediction) for improved robustness in 2026 workflows.

Backtest, cross-validate, and realistic execution

Key backtest considerations:

Event-aware split: ensure no lookahead into Fridays when labeling Thursday events.
Slippage and execution window: model predicts before the open; simulate market impact and slippage conservatively. Keep an eye on market structure changes that can affect execution assumptions.
Walk-forward validation: retrain monthly with rolling windows to adapt to seasonality and policy changes.
Statistical significance: test P&L vs. null stratified by season (planting vs. harvest periods).

Monitoring and production considerations (2026 best practices)

Data provenance: log satellite product IDs, MGRS tiles, and market tick batch IDs; maintain lineage for audits — see approaches for automating metadata capture in DAM/metadata workflows.
Model drift: monitor feature distributions and backtested edge; trigger retrain when NDVI anomaly distributions shift beyond thresholds.
Latency: weekly NDVI update is usually enough for bounceback signals, but keep an hourly market feed for labeling and execution. Consider edge compute or regional serverless inference to reduce round-trip time.
Cost control: use cloud-hosted raster indexes and query only required tiles to limit egress. See a CTO's guide to storage and egress for practical cost controls: storage cost strategies.

Integrating with operational stacks: example flows

Airflow / Prefect DAG (high-level)

Task 1: Ingest NDVI weekly products (COGs) and write aggregates to TimescaleDB
Task 2: Ingest futures candles and compute Thursday/Friday labels
Task 3: Feature engineering and store in feature store
Task 4: Train or score models; output signals to trading system

Edge case: cloud cover and imputation

When Sentinel‑2 is cloudy, fallback to MODIS/VIIRS composites or use temporal interpolation. Flag imputed features and consider lower weight for days with >40% imputed pixels.

Practical example: from Thursday drop to Friday AM bounceback signal

Walkthrough (illustrative):

Thursday 16:00 CT — futures close down 0.7%. The pipeline computes market features (OI drop, vol spike).
Daily job retrieves latest weekly NDVI aggregate for MPLS region: NDVI is 1.8 standard deviations below 5-year baseline and 21-day ROC is -6%.
Model scores probability=0.68 for bounceback (threshold 0.6). The system emits an alert and a ranked list of contracts by expected return.
Execution system places limit or market orders in Friday AM window with conservative sizing and slippage model.

Note: the above is an operational recipe; evaluate legal/regulatory constraints before live trading.

Evaluation metrics and KPIs

Precision/Recall on labeled bounceback events (for signal accuracy)
Expected return per trade and max drawdown (P&L perspective)
Time-to-detect (latency between data availability and signal generation)
Feature availability rate (percent of NDVI tiles non-cloudy)

Code and query snippets to integrate quickly

JavaScript: call your inference API

// Fetch precomputed signal for MPLS contract
fetch('https://api.yourdomain.com/signals?contract=MPLS')
  .then(r => r.json())
  .then(signal => console.log('Bounceback prob', signal.prob))
  .catch(err => console.error(err));

SQL: join NDVI weekly to futures Thursday label

SELECT f.day, f.contract, n.ndvi_mean, n.ndvi_sd, f.thur_ret, f.fri_am_ret
FROM futures_labels f
LEFT JOIN ndvi_weekly n ON n.ts = f.day - interval '1 day' AND n.contract = f.contract
WHERE f.contract = 'MPLS';

2026 trends to watch (operational and strategic)

Increased commercial EO access: more high-cadence commercial constellations are offering pipeline-friendly APIs. Consider pilot buys for high-signal regions.
Model explainability: regulators and stakeholders require explainability; incorporate SHAP for tabular models and attention visualization for sequence models — and consult model-tool roundups such as open-tool reviews when choosing explainability stacks.
Pretrained time-series models: shared checkpoints (transformer-based) reduce cold-start risk for new commodities.
Edge compute: for ultra-low latency alerting near exchanges, serverless inference deployed regionally lowers round-trip time.

Common pitfalls and how to avoid them

Pitfall: assuming NDVI immediately translates to price. Fix: include market microstructure and macro flags; validate seasonally.
Pitfall: using uncalibrated commercial imagery with restrictive licensing. Fix: audit license terms and maintain provenance metadata — see automated metadata capture patterns.
Pitfall: leaking future market data into labels. Fix: event-aware splits and strict cutoff times for features and labels.

Actionable takeaways

Start with open NDVI: ingest Sentinel‑2 + MODIS to build robust baselines before adding commercial imagery.
Label clearly: define bouncebacks (Thu drop + Fri AM gain) and backtest with conservative execution assumptions.
Hybrid modeling: use LightGBM for reliability + Transformer/LSTM for sequence context, then ensemble.
Productionize: use TimescaleDB (or vectorized feature store), schedule weekly NDVI jobs, monitor drift and data quality. Review storage and egress guidance in a CTO storage guide: storage cost playbook.

Example: recommended checklist to deploy in 2–6 weeks

Provision cloud storage and public EO access (AWS/GCP public datasets).
Ingest 3 years of weekly NDVI and match to futures candles; store in TimescaleDB.
Build features, label bouncebacks, and train baseline LightGBM.
Run walk-forward backtest and simple P&L simulation with slippage.
Deploy scoring endpoint; run live paper-trade for 1–3 months and monitor KPIs.

Final considerations and ethical notes

Satellite-derived agricultural monitoring has societal impacts, from market prices to food security. Use data responsibly. Maintain transparency about model limits and avoid strategies that amplify market instability during stress periods.

Call to action

If you want a ready-to-run starter kit: we provide production-grade connectors to Sentinel‑2 and MODIS, example TimescaleDB schemas, and prebuilt LightGBM + Transformer reference models that you can adapt for MPLS and other wheat contracts. Start a free pilot to ingest 3 years of NDVI + futures, run the tutorial pipeline, and evaluate signal performance in your environment.

Unknown

Contributor

Senior editor and content strategist. Writing about technology, design, and the future of digital media. Follow along for deep dives into the industry's moving parts.