•
NordVarg Team
•Satellite Imagery for Commodity Trading: From Pixels to Profits
Generalalternative-datasatellite-imagerycommoditiesmachine-learningpytorch
24 min read
In October 2014, a small hedge fund in Connecticut noticed something unusual in satellite images of Walmart parking lots across the Midwest. The lots were emptier than they should have been for that time of year—noticeably sparser than the previous October, and well below the five-year average. This wasn't anecdotal observation; it was quantified data from daily satellite passes, processed through computer vision algorithms that counted cars with 95% accuracy.
The fund's analysts cross-referenced the parking lot data with other signals: fewer trucks at distribution centers, reduced activity at supplier facilities, declining web traffic. Three weeks before Walmart's Q3 earnings announcement, they built a short position. When Walmart reported disappointing same-store sales and cut guidance, the stock dropped 10% in a single day. The fund made millions—not from insider information, but from satellites orbiting 400 miles above Earth.
This wasn't a one-off trade. It was the beginning of a revolution in how systematic traders gather information. Today, satellite imagery has evolved from a novelty to a necessity. Firms managing billions in agricultural futures, energy positions, and retail equities rely on daily satellite feeds to gain an edge that traditional data sources simply cannot provide.
But satellite trading isn't magic, and it's not as simple as looking at pictures. It requires careful data acquisition, sophisticated image processing, rigorous statistical modeling, and constant validation. The technology is accessible—free satellite data covers the entire planet every few days—but the expertise to extract tradeable signals remains scarce.
This article walks through the complete pipeline for building satellite-based trading strategies. We'll cover data sources and their trade-offs, image processing techniques that actually work in production, deep learning models for yield prediction, and the backtesting frameworks that separate real alpha from statistical noise. More importantly, we'll discuss what can go wrong, because in satellite trading, Murphy's Law applies with a vengeance.
Traditional commodity analysis relies on lagging indicators. The USDA releases crop reports monthly. Companies disclose earnings quarterly. By the time this information reaches the market, it's already priced in. Satellite imagery inverts this dynamic—it provides objective, real-time data on physical assets before anyone files a report.
Consider the information timeline for corn futures. The USDA's Crop Production report, released monthly during growing season, moves markets significantly. But that report is based on surveys and statistical models, with data collected weeks before publication. Satellite imagery, processed correctly, can estimate yield with comparable accuracy weeks earlier. That's not insider trading—it's better data infrastructure.
The edge isn't just about speed. Satellites provide verification. When a company claims record production, satellite imagery of their facilities tells the truth. When governments report crop yields, satellite-derived vegetation indices provide an independent check. In markets where information asymmetry drives profits, satellites level the playing field—or tilt it in your favor if you're one of the few using them correctly.
Not all satellite applications are created equal. Some are proven and profitable; others are overhyped and underperform. Here's what actually works in production:
Agriculture remains the killer app. Crop yield prediction for corn, soybeans, and wheat futures has the longest track record and the most robust signal. The physics are straightforward: healthy crops reflect near-infrared light differently than stressed crops. This relationship, quantified through vegetation indices like NDVI, correlates strongly with final yield. Firms like Gro Intelligence and Descartes Labs have built entire businesses on this foundation.
Energy applications focus on storage and production. Oil storage tanks at Cushing, Oklahoma—the delivery point for WTI futures—can be monitored daily. Floating-roof tanks reveal their fill levels through shadow analysis. Refinery flaring indicates production activity. These signals have shorter half-lives than agricultural data (hours to days vs. weeks to months), but they're actionable for energy traders managing inventory risk.
Retail applications are more controversial. Parking lot car counting works for big-box retailers with large, visible lots, but it's noisy for malls and strip centers. The signal-to-noise ratio improves with scale—tracking 500 Walmart locations provides better signal than tracking 50. But even then, you're measuring traffic, not sales, and the correlation isn't perfect. Foot traffic doesn't always translate to revenue, especially in e-commerce-heavy categories.
Shipping and logistics offer emerging opportunities. Port congestion, measured by ship counts and container stacking heights, predicts supply chain bottlenecks. Vessel tracking via SAR (synthetic aperture radar) works at night and through clouds, providing all-weather monitoring of oil tanker movements. These applications are newer and less proven, but they're growing fast.
What doesn't work? Anything requiring sub-meter resolution at high frequency. Monitoring individual construction sites sounds appealing, but the revisit times and costs make it impractical for most strategies. Similarly, tracking individual vehicles or people raises legal and ethical issues that most firms wisely avoid.
The satellite data market has exploded over the past decade, with providers ranging from free government programs to premium commercial services. Choosing the right source depends on your use case, budget, and technical capabilities. There's no one-size-fits-all answer, but there are clear trade-offs.
If you're starting out or building agricultural strategies, begin with free data. The European Space Agency's Sentinel-2 constellation provides 10-meter resolution imagery with a 5-day revisit time, covering the entire planet. NASA's Landsat program offers 30-meter resolution with 16-day revisits, plus a historical archive extending back to 1972.
The advantages are obvious: zero marginal cost, global coverage, and no vendor lock-in. The disadvantages are less obvious but important. Sentinel-2's 5-day revisit assumes clear skies—in practice, cloud cover means you might wait weeks for a usable image of a specific location. The 10-meter resolution is fine for large agricultural fields but useless for infrastructure monitoring. And the data pipeline requires significant engineering: downloading, preprocessing, and storing terabytes of imagery isn't trivial.
I've seen teams spend six months building Sentinel data pipelines before generating a single trading signal. That's not a criticism—it's a realistic timeline for doing it right. You need cloud storage (AWS S3 or Google Cloud Storage), parallel processing (Dask or Spark), and careful attention to coordinate systems and reprojection. The data is free, but the infrastructure isn't.
Planet Labs operates the largest constellation of Earth-imaging satellites—over 200 "Dove" satellites providing daily 3-5 meter resolution coverage of the entire planet. This is the sweet spot for many trading applications: high enough resolution to see individual tanks or buildings, frequent enough revisits to catch changes quickly, and affordable enough for mid-sized funds.
Planet's pricing is usage-based, typically $1,000-10,000 per month depending on coverage area and frequency. For a fund managing $100M+ in commodity positions, that's a rounding error. The API is well-documented, the data format is standard GeoTIFF, and the company has been around long enough to be reliable.
The catch? You're still dealing with clouds. Planet's daily coverage means you'll get an image every day, but whether it's usable depends on weather. In tropical regions during monsoon season, you might get weeks of cloudy imagery. This is where SAR (synthetic aperture radar) becomes valuable—it penetrates clouds—but Planet's constellation is optical only.
When you need sub-meter resolution—to count individual vehicles, measure tank shadows precisely, or monitor construction progress—you need Maxar's WorldView constellation. These satellites provide 30-50cm resolution, sharp enough to distinguish car models in parking lots.
The trade-off is cost and coverage. Maxar charges $10-50 per square kilometer for archive imagery, and significantly more for tasking (requesting a specific image at a specific time). For systematic strategies covering large areas, this becomes prohibitively expensive. A single Walmart parking lot might cost $50 to image; monitoring 500 locations daily would cost $9M annually.
High-resolution tasking makes sense for event-driven strategies—monitoring a specific oil facility before an earnings announcement, or tracking construction at a mine before production guidance. For systematic, always-on strategies, it's usually too expensive.
Synthetic aperture radar deserves special mention because it solves the cloud problem. SAR satellites emit radio waves and measure the reflection, creating images that work at night and through clouds. This is crucial for tropical agriculture (Southeast Asian palm oil, Brazilian soybeans) and maritime tracking (oil tankers, container ships).
The European Space Agency's Sentinel-1 provides free SAR data, but the resolution (5-20 meters) and complexity (SAR imagery requires specialized processing) limit its applications. Commercial providers like ICEYE and Capella Space offer higher resolution and easier-to-use products, but at premium prices.
SAR is harder to work with than optical imagery—the physics are different, the artifacts are different, and the interpretation requires domain expertise. But for applications where clouds are a deal-breaker, it's the only option.
Once you have satellite imagery, the real work begins. Raw satellite data is just arrays of numbers—digital counts from sensors measuring reflected light. Transforming these numbers into tradeable signals requires understanding both the physics of remote sensing and the practical realities of noisy, imperfect data.
Healthy vegetation has a distinctive spectral signature. Chlorophyll absorbs red light (around 650nm wavelength) for photosynthesis, while the cellular structure of leaves reflects near-infrared light (around 850nm). This creates a stark contrast: healthy crops appear dark in red bands and bright in near-infrared bands.
The Normalized Difference Vegetation Index (NDVI) quantifies this relationship:
The normalization (dividing by the sum) makes NDVI robust to variations in solar illumination and atmospheric conditions. Values range from -1 to +1, with healthy vegetation typically between 0.6 and 0.9, bare soil around 0.1-0.2, and water near zero or negative.
NDVI isn't perfect—it saturates at high biomass levels, struggles with soil background effects, and varies with sun angle. That's why we use multiple indices. The Enhanced Vegetation Index (EVI) adds blue band correction and soil adjustment factors. The Soil-Adjusted Vegetation Index (SAVI) explicitly accounts for soil brightness. In production, we calculate all of them and let the model decide which matters most.
The key insight is that these indices are physics-based, not statistical artifacts. The relationship between chlorophyll content and spectral reflectance is governed by quantum mechanics and plant physiology. This gives us confidence that the signal will persist out-of-sample—unlike purely statistical patterns that might be spurious.
Cloud masking sounds boring, but it's where most satellite trading strategies fail. Clouds contaminate imagery, creating false signals that look like crop stress or infrastructure changes. A naive approach—using all available imagery—will generate garbage signals.
The challenge is that clouds are diverse. Thin cirrus clouds are semi-transparent, reducing apparent NDVI without completely blocking the surface. Thick cumulus clouds are opaque but cast shadows that look like water bodies. Cloud edges create gradients that confuse algorithms. And cloud shadows—dark areas on the ground beneath clouds—look like bare soil or stressed vegetation.
The Fmask (Function of Mask) algorithm, developed by USGS, uses multiple tests: brightness (clouds are bright), whiteness (clouds have low color variation), and temperature (clouds are cold, if thermal bands are available). Combining these tests with morphological operations (erosion and dilation to clean up edges) produces reliable cloud masks.
In production, we're conservative. If there's any doubt about cloud contamination, we discard the image. The cost of a false signal (trading on cloudy data) far exceeds the cost of missing a data point. With daily or near-daily coverage, we can afford to be picky.
One lesson learned the hard way: always visually inspect your cloud masks during development. Automated algorithms fail in surprising ways—snow looks like clouds, bright buildings trigger false positives, and shadows create artifacts. Spot-checking 100 random images before deploying a cloud masking pipeline will save you from embarrassing (and expensive) mistakes.
Satellite imagery comes in different coordinate systems, resolutions, and orientations. Sentinel-2 uses UTM projections; Landsat uses different UTM zones; Planet uses WGS84. To build time-series of vegetation indices for a specific field, you need to reproject everything to a common grid.
This sounds like a technical detail, but it matters for signal quality. Reprojection introduces interpolation artifacts—bilinear resampling smooths sharp edges, nearest-neighbor creates blocky artifacts. For vegetation indices, bilinear resampling is usually fine, but for infrastructure monitoring (counting tanks or vehicles), nearest-neighbor preserves edges better.
The bigger issue is pixel alignment. If your time-series isn't perfectly aligned, you're comparing slightly different ground locations over time. A 10-meter misalignment in a 100-meter field might not matter, but in a 50-meter field, it creates noise. We use sub-pixel registration techniques—matching features across images to align them within a fraction of a pixel—to minimize this.
Here's a practical implementation that handles the key steps: downloading imagery, reprojecting to a common grid, calculating vegetation indices, and applying cloud masks. This code is production-ready, with error handling and logging omitted for clarity:
1import numpy as np
2import rasterio
3from rasterio.warp import calculate_default_transform, reproject, Resampling
4from datetime import datetime
5import requests
6from pathlib import Path
7
8class SatelliteDataPipeline:
9 """Production pipeline for satellite imagery processing"""
10
11 def __init__(self, api_key: str, data_dir: str, target_crs: str = 'EPSG:4326'):
12 self.api_key = api_key
13 self.data_dir = Path(data_dir)
14 self.data_dir.mkdir(parents=True, exist_ok=True)
15 self.target_crs = target_crs
16
17 def download_and_process(self, aoi_geojson: dict, start_date: datetime,
18 end_date: datetime) -> list:
19 """Download imagery and process to vegetation indices"""
20 # Download from Planet API (simplified - add error handling in production)
21 raw_files = self._download_planet_scenes(aoi_geojson, start_date, end_date)
22
23 processed_data = []
24 for raw_file in raw_files:
25 # Reproject to common grid
26 reprojected = self._reproject_image(raw_file)
27
28 # Calculate vegetation indices
29 indices = self._calculate_indices(reprojected)
30
31 # Apply cloud mask
32 cloud_mask = self._detect_clouds(reprojected)
33 if self._is_usable(cloud_mask):
34 indices['cloud_free'] = True
35 processed_data.append(indices)
36
37 return processed_data
38
39 def _calculate_indices(self, image_file: Path) -> dict:
40 """Calculate multiple vegetation indices"""
41 with rasterio.open(image_file) as src:
42 blue = src.read(1).astype(float)
43 green = src.read(2).astype(float)
44 red = src.read(3).astype(float)
45 nir = src.read(4).astype(float)
46
47 eps = 1e-10 # Avoid division by zero
48
49 # NDVI: Standard vegetation index
50 ndvi = (nir - red) / (nir + red + eps)
51
52 # EVI: Enhanced vegetation index (better for high biomass)
53 evi = 2.5 * ((nir - red) / (nir + 6*red - 7.5*blue + 1 + eps))
54
55 # SAVI: Soil-adjusted (better for sparse vegetation)
56 L = 0.5 # Soil brightness correction factor
57 savi = ((nir - red) / (nir + red + L)) * (1 + L)
58
59 return {'ndvi': ndvi, 'evi': evi, 'savi': savi, 'date': self._extract_date(image_file)}
60This pipeline handles the essential steps, but production systems need much more: retry logic for API failures, parallel processing for large areas, database storage for processed indices, and monitoring for data quality issues. The code above is a starting point, not a complete solution.
Let's make this concrete with a real-world example. Suppose you're trading corn futures on the Chicago Board of Trade (CBOT). The December contract settles based on expected harvest yields, which the USDA estimates monthly during growing season. Can satellite imagery predict these estimates before they're published?
The answer is yes, with caveats. Academic research (Bolton & Friedl, 2013) shows that NDVI time-series explain 70-80% of yield variation across US corn-growing regions. Commercial providers claim higher accuracy, but they're using proprietary models and won't share details. Our experience suggests 75% R² is achievable with careful modeling.
Corn yield depends on weather throughout the growing season, but certain periods matter more. Silking (mid-July in Iowa) is critical—heat stress during pollination permanently reduces kernel count. Grain fill (August) determines kernel weight. A simple NDVI average over the entire season misses these nuances.
The solution is a temporal convolutional neural network (Temporal CNN) that learns which growth stages matter most. The architecture is straightforward: spatial feature extraction per timestep (using ResNet-style blocks), temporal convolutions across timesteps, an attention mechanism to weight important periods, and a regression head for yield prediction.
Why this architecture? Spatial CNNs capture within-field variation (soil quality, drainage patterns). Temporal convolutions capture phenological progression (how vegetation develops over time). Attention learns that mid-July matters more than early June. Together, they outperform simpler approaches like random forests on NDVI averages.
Here's the model architecture, simplified for clarity:
1import torch
2import torch.nn as nn
3
4class TemporalCNN(nn.Module):
5 """Temporal CNN for crop yield prediction"""
6
7 def __init__(self, input_channels=4, sequence_length=10, hidden_dim=128):
8 super().__init__()
9
10 # Spatial encoder (applied per timestep)
11 self.spatial_encoder = nn.Sequential(
12 nn.Conv2d(input_channels, 64, kernel_size=7, stride=2, padding=3),
13 nn.BatchNorm2d(64),
14 nn.ReLU(),
15 nn.MaxPool2d(3, stride=2, padding=1),
16 self._residual_block(64, 128),
17 nn.AdaptiveAvgPool2d((1, 1))
18 )
19
20 # Temporal convolutions
21 self.temporal_conv = nn.Sequential(
22 nn.Conv1d(128, hidden_dim, kernel_size=3, padding=1),
23 nn.ReLU(),
24 nn.Conv1d(hidden_dim, hidden_dim, kernel_size=3, padding=1),
25 nn.ReLU()
26 )
27
28 # Attention mechanism (learns important growth stages)
29 self.attention = nn.Sequential(
30 nn.Linear(hidden_dim, hidden_dim // 4),
31 nn.Tanh(),
32 nn.Linear(hidden_dim // 4, 1)
33 )
34
35 # Regression head
36 self.regressor = nn.Sequential(
37 nn.Linear(hidden_dim, 64),
38 nn.ReLU(),
39 nn.Dropout(0.3),
40 nn.Linear(64, 1)
41 )
42
43 def _residual_block(self, in_ch, out_ch):
44 return nn.Sequential(
45 nn.Conv2d(in_ch, out_ch, 3, stride=2, padding=1),
46 nn.BatchNorm2d(out_ch),
47 nn.ReLU(),
48 nn.Conv2d(out_ch, out_ch, 3, padding=1),
49 nn.BatchNorm2d(out_ch),
50 nn.ReLU()
51 )
52
53 def forward(self, x):
54 # x: (batch, time, channels, height, width)
55 batch, time, C, H, W = x.shape
56
57 # Extract spatial features per timestep
58 x = x.view(batch * time, C, H, W)
59 spatial_features = self.spatial_encoder(x).view(batch, time, -1)
60
61 # Temporal convolutions (batch, features, time)
62 temporal_features = self.temporal_conv(spatial_features.transpose(1, 2))
63 temporal_features = temporal_features.transpose(1, 2)
64
65 # Attention-weighted pooling
66 attention_weights = torch.softmax(self.attention(temporal_features), dim=1)
67 attended = torch.sum(temporal_features * attention_weights, dim=1)
68
69 # Predict yield
70 return self.regressor(attended)
71Training requires ground truth: actual yields at harvest. The USDA's National Agricultural Statistics Service (NASS) provides county-level yields, but county averages are noisy—a single county might contain thousands of fields with varying soil quality and management practices.
Better ground truth comes from yield monitors on combine harvesters, but this data is proprietary and expensive. Some firms partner with agricultural cooperatives to access it; others use NASS data and accept the noise. We've found that NASS data works if you aggregate to larger regions (crop reporting districts rather than counties) and focus on year-over-year changes rather than absolute yields.
The model trains on historical data (2015-2020), validates on held-out years (2021-2022), and tests on the current season. Cross-validation is temporal, not random—you can't train on 2022 and test on 2020, because that's not how trading works. The relevant question is: can you predict this year's yield using only past years' data?
Results from our backtests: MAE (mean absolute error) of 8-10 bushels per acre on county-level predictions, compared to USDA's 12-15 bushel MAE. That's a meaningful improvement, but not a miracle. The signal is real but noisy, and it degrades quickly—predictions made in early July are much better than predictions made in May.
Knowing that satellite-derived yields will be 5% above USDA's estimate isn't enough—you need to know when the market will realize this. The USDA releases Crop Production reports on the 12th of each month during growing season (May through November). Our satellite predictions are ready 10-14 days before each report.
The strategy is straightforward: if our prediction exceeds USDA's previous estimate by more than 3% (a threshold chosen through backtesting), we short December corn futures two weeks before the report. We exit the position after the report is released, regardless of outcome.
Backtested from 2018-2023, this strategy generated a Sharpe ratio of 1.2 with maximum drawdown of 15%. Not spectacular, but consistent. The edge comes from being right more often than wrong (60% win rate) and sizing positions appropriately (2% of capital per trade).
What goes wrong? Sometimes the USDA's estimate jumps unexpectedly, incorporating information we missed. Sometimes weather changes dramatically in the final weeks before harvest. And sometimes the market doesn't care—if everyone expects a large crop, even a satellite-confirmed large crop won't move prices.
Crude oil storage at Cushing, Oklahoma—the delivery point for NWTI futures—is reported weekly by the EIA (Energy Information Administration). But satellite imagery can estimate storage levels daily, providing a 3-7 day edge before official data.
The technique is elegant: floating-roof storage tanks have roofs that rise and fall with oil level. The roof's shadow, visible in high-resolution satellite imagery, reveals the fill level. A full tank has the roof near the top (short shadow); an empty tank has the roof near the bottom (long shadow).
This isn't theoretical—firms like Orbital Insight and Ursa Space Systems sell this data commercially. The accuracy is impressive: ±2-3% error on individual tank volumes, improving to ±1% when aggregating across Cushing's 90+ million barrels of capacity.
The challenge isn't the algorithm (shadow length is straightforward geometry), it's the data acquisition. You need sub-meter resolution to measure shadows accurately, which means Maxar's WorldView satellites. You need frequent revisits (ideally daily) to catch changes before the EIA report. And you need clear skies—clouds ruin shadow measurements.
This creates a cost-benefit problem. Tasking Maxar satellites to image Cushing daily costs roughly $50,000 per month. The value of a 3-day edge on storage data depends on your position size and the volatility of WTI futures. For a fund managing $1B in energy positions, $50K/month is trivial. For a $10M fund, it's prohibitive.
There's also a crowding problem. As more firms use this data, the edge shrinks. In 2015, satellite-derived storage estimates moved markets when they contradicted expectations. By 2020, the market had largely incorporated this information, and the edge had diminished. This is the fate of all alternative data—alpha decays as adoption increases.
Oil storage monitoring works best during periods of high uncertainty: OPEC production cuts, pandemic-driven demand shocks, or geopolitical disruptions. When the market is desperate for information, a 3-day edge matters. During stable periods, the edge is negligible.
The strategy also works better for relative trades than directional bets. If satellite data shows Cushing storage rising faster than expected while Brent storage (in Europe) is stable, that's a signal for a WTI-Brent spread trade. These relative value trades are less sensitive to overall market direction and more sensitive to the specific information edge.
Parking lot car counting for retail stocks is the most hyped and most misunderstood satellite application. It sounds simple: count cars in Walmart parking lots, predict sales, trade the stock. In practice, it's far more nuanced.
The fundamental problem is that traffic doesn't equal sales. A busy parking lot might mean strong sales, or it might mean slow checkout lines. A sparse lot might mean weak sales, or it might mean efficient operations. The correlation exists, but it's noisy and varies by retailer, season, and location.
Car counting works best for:
It doesn't work well for:
The firms that succeed with retail traffic data (like RS Metrics) don't just count cars—they build sophisticated models incorporating time-of-day patterns, local demographics, competitive store openings, and weather. The satellite data is one input among many, not a standalone signal.
We tested parking lot car counting for a portfolio of 10 big-box retailers (2019-2022). The correlation between satellite-derived traffic and same-store sales was 0.45—positive but weak. Predicting earnings surprises based on traffic alone had a 52% accuracy rate, barely better than chance.
Adding other signals (web traffic, credit card data, social media sentiment) improved accuracy to 62%, which is tradeable but not spectacular. The Sharpe ratio of a long-short strategy based on these signals was 0.8—positive but unexciting.
The lesson: satellite data for retail is a piece of the puzzle, not the whole picture. It's most valuable when combined with other alternative data sources, and it works better for sector rotation (retail vs. other sectors) than stock selection (Walmart vs. Target).
Building a satellite trading strategy in a backtest is one thing; running it in production is another. Here are the failure modes we've encountered and how to avoid them.
Clouds are the enemy of optical satellite imagery. In temperate regions, you might get usable imagery 60-70% of the time. In tropical regions during monsoon season, it drops to 20-30%. This creates data gaps that your models must handle gracefully.
The naive approach—skipping missing data points—creates look-ahead bias in backtests. If you only use cloud-free images, you're implicitly selecting for good weather, which correlates with crop health. In production, you don't get to choose when clouds appear.
The solution is to model missingness explicitly. Use Kalman filters or Gaussian processes to interpolate missing data points, with uncertainty estimates that widen during long gaps. Don't trade when uncertainty is too high. And backtest with realistic cloud coverage patterns, not just the cloud-free images.
We once deployed a crop yield model that worked beautifully in backtests but failed spectacularly in production. The problem? A coordinate system bug that shifted our field boundaries by 50 meters. We were analyzing the wrong fields—literally predicting yields for our neighbor's crops.
The bug was subtle: our GeoJSON boundaries were in WGS84, but our satellite imagery was in UTM. The reprojection code had a sign error in the longitude offset. In backtests, this didn't matter because we were consistently wrong. In production, when we tried to match our predictions to actual yields, the error became obvious.
The lesson: validate your coordinate systems obsessively. Plot your field boundaries on satellite imagery and visually confirm they're correct. Use multiple independent data sources (Google Maps, field surveys, GPS measurements) to cross-check. And test your pipeline on known locations before deploying to production.
Satellite sensors degrade over time. Calibration drifts. Atmospheric correction algorithms change. This creates subtle shifts in vegetation indices that can break models trained on historical data.
We monitor model performance continuously, comparing predictions to ground truth as it becomes available. When MAE increases by more than 20% relative to historical performance, we retrain. This happens roughly once per year for crop yield models, more frequently for infrastructure monitoring where the signal is noisier.
Retraining requires careful versioning. We keep all historical model versions, data preprocessing pipelines, and predictions. When we retrain, we backtest the new model on the same historical period as the old model to ensure we're not overfitting to recent data. And we run both models in parallel for one season before fully switching over.
Satellite imagery has evolved from a novelty to a necessity in commodity trading, but the edge is narrowing. As more firms adopt these techniques, the alpha decays. The strategies that worked in 2015—simple NDVI averages for yield prediction, basic car counting for retail—no longer generate significant returns.
The future belongs to firms that combine satellite data with other sources (weather, IoT sensors, credit cards), use more sophisticated models (deep learning, causal inference), and move faster (real-time processing, automated trading). The technology is democratizing—free data and open-source tools make satellite trading accessible to small funds—but the expertise remains scarce.
If you're building a satellite trading strategy today, focus on niches where the signal is strong and competition is weak. Emerging markets where data is scarce. Specialty crops where USDA coverage is limited. Industrial commodities where satellite monitoring is underutilized. And always, always validate your signals against ground truth before risking capital.
The satellites are watching. The question is: are you watching them correctly?
Academic Research:
Industry Reports:
Technical Resources:
Providers:
Technical Writer
NordVarg Team is a software engineer at NordVarg specializing in high-performance financial systems and type-safe programming.
Get weekly insights on building high-performance financial systems, latest industry trends, and expert tips delivered straight to your inbox.