How to Use Google Earth Engine for Large-Scale Spatial Analysis
Introduction
Spatial analysis has always been constrained by one stubborn bottleneck: computing power. Processing decades of satellite imagery, running terrain analysis across continental extents, or modeling land cover change over thousands of square kilometers used to require expensive hardware, lengthy downloads, and days of processing time. Google Earth Engine (GEE) changed that equation entirely.
GEE is a cloud-based geospatial platform that gives analysts access to a multi-petabyte catalog of satellite imagery and geospatial datasets, paired with Google’s computational infrastructure. Instead of downloading data and running it on a local machine, you write scripts that execute directly alongside the data in the cloud. The result is analyses that would take weeks on a desktop finishing in minutes.
This article walks through how GEE works, how to get started, and how to build real spatial analysis workflows at scale.
What Makes Google Earth Engine Different
Most GIS workflows follow a familiar pattern: find data, download it, process it locally, visualize results. This works for small areas and short time periods. It breaks down fast when you scale up.
GEE inverts this model. The data lives on Google’s servers. Your code travels to the data, not the other way around. This architecture, called server-side computing, means:
- No data downloads for most tasks
- Parallel processing across thousands of cores automatically
- Access to a continuously updated archive of satellite imagery dating back to the 1970s
- A browser-based IDE called the Code Editor that requires no local software installation
The platform supports two languages: JavaScript (in the browser-based Code Editor) and Python (via the earthengine-api package). Both expose the same underlying API. For production workflows, Python integrates more naturally with data science toolchains. For exploration and visualization, the Code Editor is faster to iterate in.
Getting Access
GEE is free for research, education, and nonprofit use. Commercial use requires a paid license.
To get started:
- Go to earthengine.google.com and click “Get Started”
- Sign in with a Google account
- Submit an access request describing your use case
- Once approved, access the Code Editor at code.earthengine.google.com
Approval typically takes a few hours to a couple of days. Once you have access, the Code Editor environment is immediately available with no installation required.
For Python users, install the API and authenticate:
pip install earthengine-api
earthengine authenticate
This opens a browser window to complete OAuth authentication and stores credentials locally.
Core Concepts You Must Understand First
Before writing any analysis, you need to internalize how GEE thinks about data and computation. These concepts are not optional background knowledge. They directly shape how you write code.
Images and Image Collections
In GEE, a single raster dataset is an Image. It has one or more bands, each representing a measured variable (reflectance, temperature, elevation, etc.). A time series of images is an ImageCollection, which you filter, map over, and reduce.
// Load the Landsat 8 Surface Reflectance collection
var collection = ee.ImageCollection('LANDSAT/LC08/C02/T1_L2')
.filterDate('2022-01-01', '2022-12-31')
.filterBounds(ee.Geometry.Point([-122.4, 37.8]));
print('Number of images:', collection.size());
Geometries and Features
Vector data is handled through Geometry objects (points, lines, polygons) and Feature objects (a geometry plus a dictionary of properties). Collections of features are FeaturCollections, the vector equivalent of ImageCollections.
// Define a polygon area of interest
var aoi = ee.Geometry.Polygon([
[[-122.6, 37.6], [-122.6, 38.0], [-122.0, 38.0], [-122.0, 37.6]]
]);
// Load a built-in vector dataset
var countries = ee.FeatureCollection('USDOS/LSIB_SIMPLE/2017');
var india = countries.filter(ee.Filter.eq('country_na', 'India'));
Deferred Execution
This is the most important concept to understand. GEE does not execute your code line by line as you write it. Instead, it builds a computation graph that is only sent to the server when you explicitly request a result through print(), Map.addLayer(), or an export function.
This means you cannot use standard JavaScript or Python control flow (like for loops over collections) to process GEE objects. You must use GEE’s built-in functional methods: map(), filter(), and reduce().
// WRONG - never loop over a collection like this
// for (var i = 0; i < collection.size(); i++) { ... }
// CORRECT - use .map() to apply a function to each image
var processed = collection.map(function(image) {
return image.multiply(0.0000275).add(-0.2); // Apply scale factor
});
Scale and Projections
GEE performs computations at a specified scale (in meters per pixel). If you do not specify a scale, GEE infers one, which can produce unexpected results. Always specify scale explicitly in reduction operations.
Building a Complete Workflow: NDVI Time Series Analysis
Here is a complete, practical example that demonstrates the core workflow: computing a vegetation index across a large area over multiple years.
Step 1: Define the Study Area and Time Period
// Define a region of interest (here, a bounding box over East Africa)
var roi = ee.Geometry.Rectangle([33.5, -5.0, 42.5, 5.0]);
// Set the time window
var startDate = '2015-01-01';
var endDate = '2023-12-31';
Step 2: Load and Filter the Image Collection
var landsat = ee.ImageCollection('LANDSAT/LC08/C02/T1_L2')
.filterBounds(roi)
.filterDate(startDate, endDate)
.filter(ee.Filter.lt('CLOUD_COVER', 20)); // Keep only images with <20% cloud cover
print('Filtered collection size:', landsat.size());
Step 3: Preprocess and Compute NDVI
function prepareAndComputeNDVI(image) {
// Apply scale factors for Landsat Collection 2
var optical = image.select('SR_B.').multiply(0.0000275).add(-0.2);
var prepared = image.addBands(optical, null, true);
// Compute NDVI: (NIR - Red) / (NIR + Red)
var ndvi = prepared.normalizedDifference(['SR_B5', 'SR_B4']).rename('NDVI');
// Return image with NDVI band and preserve date metadata
return prepared.addBands(ndvi).copyProperties(image, ['system:time_start']);
}
var withNDVI = landsat.map(prepareAndComputeNDVI);
Step 4: Create Annual Composites
var years = ee.List.sequence(2015, 2023);
var annualNDVI = ee.ImageCollection.fromImages(
years.map(function(year) {
var yearCollection = withNDVI
.filter(ee.Filter.calendarRange(year, year, 'year'))
.select('NDVI');
return yearCollection
.median() // Median composite to reduce cloud artifacts
.set('year', year)
.set('system:time_start', ee.Date.fromYMD(year, 6, 1).millis());
})
);
Step 5: Visualize in the Code Editor
var ndviVis = {
min: -0.1,
max: 0.8,
palette: ['#d73027', '#fee08b', '#1a9850'] // Red to yellow to green
};
Map.centerObject(roi, 5);
Map.addLayer(
annualNDVI.filter(ee.Filter.eq('year', 2022)).first(),
ndviVis,
'NDVI 2022'
);
Step 6: Export Results
For large-area exports, GEE writes results directly to Google Drive or Google Cloud Storage. This happens asynchronously in the background.
var exportImage = annualNDVI.filter(ee.Filter.eq('year', 2022)).first().select('NDVI');
Export.image.toDrive({
image: exportImage.toFloat(),
description: 'NDVI_EastAfrica_2022',
folder: 'GEE_Exports',
region: roi,
scale: 30, // 30 meters per pixel (Landsat native resolution)
crs: 'EPSG:4326',
maxPixels: 1e13
});
Working in Python
The Python API mirrors the JavaScript API almost exactly. The main difference is syntax. Here is the same NDVI workflow in Python using geemap, a powerful package that wraps the GEE Python API with an interactive mapping interface:
import ee
import geemap
# Authenticate and initialize
ee.Authenticate()
ee.Initialize(project='your-project-id')
# Define AOI
roi = ee.Geometry.Rectangle([33.5, -5.0, 42.5, 5.0])
# Load and filter collection
landsat = (ee.ImageCollection('LANDSAT/LC08/C02/T1_L2')
.filterBounds(roi)
.filterDate('2022-01-01', '2022-12-31')
.filter(ee.Filter.lt('CLOUD_COVER', 20)))
# Compute NDVI
def compute_ndvi(image):
optical = image.select('SR_B.*').multiply(0.0000275).add(-0.2)
image = image.addBands(optical, None, True)
ndvi = image.normalizedDifference(['SR_B5', 'SR_B4']).rename('NDVI')
return image.addBands(ndvi)
ndvi_collection = landsat.map(compute_ndvi)
ndvi_composite = ndvi_collection.select('NDVI').median().clip(roi)
# Visualize with geemap
Map = geemap.Map()
Map.centerObject(roi, 5)
Map.addLayer(
ndvi_composite,
{'min': -0.1, 'max': 0.8, 'palette': ['#d73027', '#fee08b', '#1a9850']},
'NDVI Composite'
)
Map
Key Datasets Available in the GEE Catalog
GEE hosts hundreds of datasets across environmental, climate, and socioeconomic domains. Some of the most widely used include:
Satellite Imagery
- Landsat 4, 5, 7, 8, 9 (1982 to present, 30m resolution)
- Sentinel-1 SAR (2014 to present, 10m resolution)
- Sentinel-2 Multispectral (2015 to present, 10m resolution)
- MODIS Terra and Aqua products (2000 to present, 250m to 1km)
Elevation and Terrain
- SRTM Digital Elevation Model (30m global)
- ALOS World 3D (30m global)
- NASA DEM (30m global, updated)
Climate and Weather
- ERA5 Reanalysis (hourly global climate, 1940 to present)
- CHIRPS Precipitation (5km, 1981 to present)
- MODIS Land Surface Temperature
Land Cover and Land Use
- ESA WorldCover (10m global, 2020 and 2021)
- Dynamic World (near real-time 10m land use)
- Global Forest Watch / Hansen Forest Change
The full catalog is searchable at developers.google.com/earth-engine/datasets.
Advanced Techniques
Reducing Regions
The reduceRegion() and reduceRegions() methods compute statistics within vector boundaries. This is how you extract zonal statistics.
var stats = ndviComposite.reduceRegion({
reducer: ee.Reducer.mean().combine({
reducer2: ee.Reducer.stdDev(),
sharedInputs: true
}),
geometry: roi,
scale: 30,
maxPixels: 1e13
});
print('Mean NDVI:', stats.get('NDVI_mean'));
print('StdDev NDVI:', stats.get('NDVI_stdDev'));
Cloud Masking
Cloud masking is essential for optical imagery. Landsat Collection 2 includes a QA band that encodes pixel quality:
function maskL8Clouds(image) {
var qaMask = image.select('QA_PIXEL').bitwiseAnd(parseInt('11111', 2)).eq(0);
var satMask = image.select('QA_RADSAT').eq(0);
return image.updateMask(qaMask).updateMask(satMask);
}
var maskedCollection = landsat.map(maskL8Clouds);
Linear Trend Analysis
Detecting change over time is one of GEE’s most powerful capabilities. The linearFit() reducer computes per-pixel trend slopes across a time series:
// Prepare collection with time band
var withTime = annualNDVI.map(function(image) {
var time = image.metadata('system:time_start').divide(1e18); // Normalize
return image.addBands(time.rename('time'));
});
// Compute linear trend
var trend = withTime.select(['time', 'NDVI']).reduce(ee.Reducer.linearFit());
var slope = trend.select('scale'); // Positive = greening, Negative = browning
Map.addLayer(slope, {min: -0.01, max: 0.01, palette: ['#d73027', '#ffffbf', '#1a9850']}, 'NDVI Trend');
Batch Export to Cloud Storage
For programmatic pipelines, exporting to Google Cloud Storage is preferable to Drive:
Export.image.toCloudStorage({
image: exportImage,
description: 'NDVI_batch_export',
bucket: 'your-gcs-bucket',
fileNamePrefix: 'ndvi/east_africa_2022',
region: roi,
scale: 30,
crs: 'EPSG:4326',
fileFormat: 'GeoTIFF',
maxPixels: 1e13
});
Performance Tips and Common Mistakes
Avoid mixing client-side and server-side objects. GEE objects (anything starting with ee.) live on the server. JavaScript primitives live on the client. You cannot use an ee.Number in a JavaScript if statement without calling .getInfo(), which is a blocking round-trip to the server and should be avoided in production code.
Always clip to your AOI before exporting. Unclipped exports over large collections can hit memory and pixel limits unexpectedly.
Use mosaic() or median() for compositing, not first(). Using first() picks whatever image happens to be on top, which may have clouds or artifacts. Median composites are more robust.
Set scale explicitly in all reductions. Letting GEE choose a default scale can produce outputs at unexpected resolutions and inflate computation time.
Monitor the Task Manager. Long exports run as background tasks. Check their status in the Tasks panel (Code Editor) or via ee.batch.Task.list() in Python.
Use ee.List.sequence() and map() for loops. Never try to iterate over a collection with a for loop. It will either fail or only run client-side.
Practical Use Cases
GEE has been used across a wide range of application domains. Some well-established examples include:
Forest monitoring: Detecting deforestation, forest degradation, and regrowth using Landsat time series and the Hansen Global Forest Change dataset.
Agricultural monitoring: Crop type mapping, yield estimation, and drought stress detection using NDVI and EVI time series from Sentinel-2 and MODIS.
Urban expansion: Mapping impervious surface growth over decades using spectral indices and machine learning classifiers applied to Landsat archives.
Flood mapping: Using Sentinel-1 SAR imagery before and after flood events to delineate inundated areas, which optical sensors miss due to cloud cover during storms.
Climate analysis: Computing temperature and precipitation anomalies from ERA5 reanalysis data, downscaled and linked to socioeconomic or ecological datasets.
Conclusion
Google Earth Engine removes the infrastructure barrier to planetary-scale spatial analysis. The combination of a massive, continuously updated data catalog and server-side computing means that analysis workflows that were once the domain of well-funded research teams are now accessible to any analyst with an account and a basic understanding of the API.
The learning curve is real. Server-side execution, deferred evaluation, and the prohibition on standard loops all require a shift in how you think about writing code. But once those concepts click, GEE becomes one of the most capable tools in the spatial data practitioner’s toolkit.
Start with a well-defined question, a small area of interest, and a short time period. Build confidence with the core API patterns. Then scale out. That progression from small proof-of-concept to continent-wide analysis is exactly what GEE was designed to enable.