FieldLens: Orchard Vigor Monitoring That a Grower Would Actually Pay For — Sentinel-2 NDVI + Local Gemma

Liang Jacky — Fri, 16 Oct 2026 13:28:34 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

FieldLens turns a drawn orchard boundary into plain-language growing advice.

A grower draws a plot on the map. FieldLens pulls Sentinel-2 imagery through Google Earth Engine, computes an NDVI vigor time series for that plot, and a locally running Gemma model turns the curve into a short report: what changed, what it might mean, and what to check in the field. (Where no local model is available, a deterministic rule engine covers the same steps — labeled in-app as a fallback.)

We're starting with high-value orchards in Meizhou — Dapu honey pomelo and citrus — at 199 yuan per plot per year. The buyer is not a tech company. It's a grower who already walks the orchard and wants to know which block to check first.

Why would a grower pay for this when Sentinel-2 data is free? Because they're not buying data — they're buying a shortcut: instead of walking every block to find the struggling one, the report tells them which block to check first. The 199 yuan isn't priced on our costs (near zero per report, thanks to the local model). It's priced on the grower's decision: cheap enough to say yes to without a meeting.

What the report deliberately won't do: diagnose a disease, or prescribe pesticide doses. It says what the NDVI curve shows, flags what looks unusual, and tells the grower to go check in person.

Demo

Live demo: https://fieldlens-api.onrender.com/ — the tool page is at /app.

Note: the demo runs on Render's free tier — if it has been idle a while, the first load may take ~30 seconds to wake up; everything after that is fast.

How to try it in 30 seconds: open the demo, click "Load demo field", then generate the report. No account, no drawing required.

An honest note on scope: the live demo above runs the UI and the sample field on a transparent rule-engine fallback (labeled in-app as "Rule-based fallback"); the full GEE + local Gemma chain runs on my own machine — setup is in the README. The sample polygon is illustrative, not a real farm's boundary, and every threshold is a literature value cited in the README.

Code

Repo: https://github.com/liangjacky8921/fieldlens (Public)
The README covers setup (ollama pull gemma2:2b, earthengine authenticate), the /api/ndvi endpoint, and a data-sources section with a source note on every threshold.

How I Built It

Frontend: map drawing (Leaflet) + bilingual UI (English default, Chinese reports for real growers).
NDVI: NDVI = (B8 − B4) / (B8 + B4) on COPERNICUS/S2_SR_HARMONIZED, Sentinel-2, ~5-day revisit.
Interpretation thresholds (all sourced in README, not invented):
- NDVI ≥ 0.70 = high-vigor canopy (published sweet-orange study).
- NDVI > 0.25 = vegetation vs soil (published sooty-mould study).
- Citrus-orchard NDVI ranges from published studies, including how low values can go under stress or infection — the report treats a drop as a reason to go look, not a diagnosis.
Report: local Gemma (gemma2:2b via Ollama) with a lang parameter (English default, Chinese for growers). Alert rules (e.g. drop > 0.10) are project settings, labeled as such — not literature values.
Sample field: an illustrative polygon inside the real Dapu honey-pomelo geographical-indication protection zone (116°18′–116°56′E, 24°01′–24°41′N). It's labeled "Sample field" in the app — not a real farm's boundary.

The NDVI pipeline is one file (app/gee_ndvi.py). Per-scene mean is computed twice: once with QA60 cloud masking, and once unmasked as a fallback for scenes where cloud cover masks the whole plot. Scene-level means are then reduced to a single value per revisit date, and any scene with a null (fully cloud-masked) mean is dropped rather than counted.

# Dual-track per-scene NDVI mean: QA60-masked, falling back to unmasked mean
# so a fully cloud-covered scene still contributes instead of being silently dropped.
masked = ndvi.reduceRegion(reducer=ee.Reducer.mean(), geometry=geom, scale=10)
unmasked = ndvi.unmask().reduceRegion(reducer=ee.Reducer.mean(), geometry=geom, scale=10)
return ee.Algorithms.If(
    ee.Algorithms.IsEqual(masked.get('nd'), None),
    unmasked.get('nd'),
    masked.get('nd'),
)

Why Open Innovation Matters

All economic, not ideological:

The unit economics only work because the model is local. A per-report cloud API bill would eat the 199 yuan/plot/year price. Local Gemma has no per-call charge, so the price can stay low enough for a grower to say yes.
The data stays on the farm. Plot boundaries and orchard health are business-sensitive. Nothing is uploaded to a vendor server for inference.
Open data + open weights = auditable numbers. Sentinel-2 is open Copernicus data; every threshold in the README carries its source. A grower (or a judge) can check where each number came from.

First User

We're in talks with a Meizhou pomelo cooperative to run an on-site validation in November — real blocks, real walking, comparing the report's "check this block first" ranking against the grower's own walk order.

Prize Categories

Best Use of Gemma — report generation runs on local Gemma 2B via Ollama; the live demo surfaces the labeled fallback path because Ollama can't run on Render's free tier.
Best Use of Render — frontend + FastAPI backend + GEE-backed NDVI pipeline deployed on Render; /health reports gee_ready: true.
Overall (Week 2: Side Hustle) — a grower would actually pay for this.

DEV Community: Liang Jacky