Stillroot: a quiet plan companion for my friend

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend.

What I Built

I built Stillroot, a quiet plant-care companion for my friend Rohan.

The project is built around an everyday dilemma: a few plants on a windowsill, an upcoming weekend away, and the question, "Will someone need to check the soil while I'm gone?"

It's set up as a working gift prototype. The demo comes preloaded with sample data for a pothos, monstera, and basil so anyone can take it for a spin before Rohan connects his real sensors.

Stillroot focuses on three things:

• A 7-day moisture forecast with an estimated range.
• A care plan that adapts to how long he'll be away, plus a ready-to-share note for a friend who's house-sitting.
• A compact, on-device Gemma companion that explains the forecast in plain English.

The interface is intentionally simple: one plant, one forecast, and one clear action. If a sensor reading looks stale, the app flags it before making any predictions. And if dry soil is forecasted while he's traveling, it suggests asking a friend to check on the plant instead of guessing a generic watering schedule.

Demo

Open Stillroot on Render

Try this quick walkthrough:

1. Choose Basil and slide Days away to 7. The status updates to ASK FRIEND.
2. Turn on Simulate a stale sensor reading to see it switch to VERIFY SENSOR.
3. Turn that off and click Before I water to watch Gemma generate advice locally in your browser.
4. Head to Try your own CSV history and upload the included sample file to see custom predictions in action.

Note: Since this runs on Render's free tier, the demo may take around a minute to spin up if it hasn't been visited recently. Gemma downloads on the first run (~350 MB on WebGPU, ~850 MB on CPU fallback) and is cached in your browser for subsequent visits.

Code

GitHub: faraz-shamim/stillroot

The repository includes the frontend app, local prediction runtime, dataset generator, forecast experiments, raw benchmark files, and deployment config. Application code is MIT licensed; TabPFN and Gemma retain their respective licenses.

To run it locally:

npm ci
npm run build
python -m pip install -r requirements.txt
python -m uvicorn backend.app:app --host 127.0.0.1 --port 8000

Open http://127.0.0.1:8000. The README includes instructions for reproducing the TabPFN experiments and running predictions on custom CSVs.

How I Built It

TabPFN provides the forecast

I used Prior Labs' TabPFN v2 running on CPU, feeding it historical soil moisture, temperature, humidity, light hours, pot size, and days since watering to predict the next reading.

To evaluate accuracy, I benchmarked it across 294 rows of data spanning 42 watering cycles, split cleanly by full cycle (196 train / 49 calibration / 49 test) so readings from the same drying cycle never leaked across splits.

Model / Baseline	Error (MAE in relative moisture points)
TabPFN v2	0.4890 MAE
Mean training-drop baseline	0.9766 MAE
Last-reading baseline	6.2986 MAE

TabPFN cut prediction error by roughly 50% compared to the mean-drop baseline, achieving 91.8% empirical coverage on a 90% prediction interval.

The hosted demo serves precomputed TabPFN outputs for fast load times and a light Render footprint, while the local Python runtime allows running TabPFN directly on custom CSV uploads.

You can view the measurement report, dataset card, and experiment code in the repo.

Gemma makes the numbers understandable

Google's Gemma 3 270M instruction model runs right inside the user's browser via a Web Worker using Transformers.js and ONNX Runtime. The app packages the plant's recent telemetry and current care signal into a concise prompt, and the model explains the situation conversationally. Because inference runs client-side, sensor data never leaves the device.

On WebGPU, Gemma answers questions like "What should I check before I water?" in about 7.9 seconds.

One practical detail from the build: the latest embedding operator worked smoothly on WebGPU but broke under WASM. Pinning an earlier compatible conversion resolved the issue for the CPU fallback. Deterministic logic always guides the signal, so the AI focuses on explaining the plan clearly rather than making unpredictable watering decisions.

Render makes it easy to give away

A lightweight FastAPI service on Render's free plan serves the frontend, static prediction assets, and care-policy endpoints. Because Gemma runs directly in the client and TabPFN runs locally during development, the backend stays lean and doesn't need PyTorch or heavy model dependencies in production.

The full stack runs reliably on $0 in infrastructure costs and API fees.

Why Does Open Innovation Matter?

For this gift, openness means Rohan actually understands how his plant monitor works.

Nothing is hidden behind a black box: the care logic is a short, transparent function, the forecast model and benchmarks are easy to inspect, and Gemma runs directly on his hardware without relying on an external API or sending personal home data over the wire. If he wants to tweak the thresholds, test a new plant, or build a version for someone else, the whole system is his to modify.

Open weights and open tooling made it possible to build an intelligent, responsive assistant that costs nothing to run and respects user privacy by design.

Prize Categories

• Best Use of TabPFN — Fast, tabular time-series forecasts evaluated on cycle-aware splits with solid baseline gains.
• Best Use of Gemma — A 270M open-weight model running entirely in the browser via WebGPU/WASM for private, on-device guidance.
• Best Use of Render — A clean full-stack deployment combining FastAPI and static frontend assets on a free-tier web service.