DEV Community

Souvik Biswas
Souvik Biswas

Posted on

Leaf Peep: an open model reads the trees, so you know where to walk this weekend

#devchallenge #hf26challenge #gemma #digitalocean

Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass Submission 🌿

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

Every October the same question comes up: are the leaves turning yet, and where? Foliage reports are weekly, regional and vague. The trees two streets over don't show up in them.

Leaf Peep is a shared, live map of fall colour, built by the people who are already out walking:

  1. Score a tree. Point your phone at a tree and tap once. Gemma 4 reads the photo and returns:
    • a 0 to 100 colour score;
    • a stage: still green, turning, near peak, peak, past;
    • the colours it sees;
    • a guess at the tree;
    • one line for the walker.
  2. Back to the walk. The spot drops onto the map, and the app gets out of your way.
  3. Know where to go next. Every spot keeps a daily colour history, which Leaf Peep turns into a forecast like "peak in about a week". You can also search by meaning: "red maples by the water".
  4. Walk with others. Pick any name on your first photo (it stays anonymous, on your phone), climb the Top walkers leaderboard, and like other people's trees.

It's for weekend walkers, dog walkers, run clubs, and anyone who'd rather catch peak colour than read about it a week late. Each visit is about ten seconds of screen time, and the reason to open it is to go outside.

I built it after a weekend stroll in and around Manhattan this October, from the trees along W 192nd St to Madison Square and Central Park. I kept wondering the same thing at every corner: is this the good stuff, or is the park ten blocks away better right now? I wanted something that tells me where the colour is near me this weekend, and then lets me put the phone away and keep walking.

Demo

Try it live: Open Leaf Peep. It works best on a phone: tap Score a tree, pick any name you like (no account, no email), and point the camera at one tree. On iPhone, Add to Home Screen runs it full screen.

sbis04.github.io

The demo was recorded in the Home Screen version of the app on an iPhone 18 Pro simulator and narrated with ElevenLabs (Eleven v3, voice "Eric"). Some of the map history is seed data: free-licence Manhattan foliage photos from Wikimedia Commons and Pexels, scored by Gemma under a few made-up walker names.

Scoring a tree, liking a walk, and the leaderboard in dark mode

Hybrid search on desktop

Code

GitHub logo sbis04 / leaf-peep

Snap a tree on your walk. Gemma 4 reads its autumn colour and maps where fall foliage is peaking. Hacktoberfest 2026.

Leaf Peep

Where the colour is, this week. Snap a tree on your walk. Gemma 4, an open-weight vision model, reads how far its leaves have turned, and the spot lands on a shared map of where fall foliage is peaking, with a forecast for when each spot will peak.

Leaf Peep on iPhone: the map, a scored tree, and a forecast in dark mode

Open the app · Landing page · Demo video · Built for the Hacktoberfest 2026 Open-Source AI Challenge: Touch Grass

What it does

Score a tree Likes and leaderboard Hybrid search Dark mode
Score a tree Likes and leaderboard Hybrid search Dark mode
Camera first, any name on your first photo (no account). Gemma 4 returns a 0–100 colour score, a stage, the colours it sees and a tree guess. Like other walkers' trees; the board ranks walkers by photos, then likes. “Red maples by the water” finds lakeside maples: pgvector for meaning plus Postgres full-text for words. Follows the system theme. Draggable bottom sheet on phones, side panel on
…
View on GitHub

MIT licensed. Run it on a laptop with Ollama and Docker, or on DigitalOcean with ./deploy/up.sh.

How I Built It 

phone ──► Node API ──► Gemma 4      (DigitalOcean serverless inference, or Ollama on a laptop)
              ├──────► MiniLM        (open embedding model, in-process)
              └──────► Tiger Data    hypertable + continuous aggregate  → forecast
                                     pgvector HNSW + full-text GIN      → hybrid search
Enter fullscreen mode Exit fullscreen mode

Gemma 4 does the reading. Every photo goes to Gemma with a JSON schema, so the reply is always a valid object: stage, color_score, colors, trees, scene, note, plus is_foliage. That last field lets the app politely reject a selfie or a screenshot.

I tested three Gemma sizes on the same photos:

Model Green canopy Turning Peak Time per photo
2B "e2b", local 40 (wrongly "turning") 75 80 to 90 ~2 s
7.5B, local on my Mac 5 65 95 ~5 to 10 s
31B, DigitalOcean serverless inference 5 65 98 to 100 ~1.5 s

The 2B model over-scored green trees, and tightening the prompt didn't fix it. With open weights, each switch was a one-line config change, and I could measure the difference myself instead of trusting a vendor's model card.

DigitalOcean runs it.

  • Model: production calls gemma-4-31B-it on DigitalOcean's serverless inference, using a Model Access Key that can only call Gemma. Each photo costs well under a tenth of a cent, so no GPU sits idle.
  • App: a $12/month Droplet runs it with Docker Compose: Caddy for HTTPS and the Node app.
  • Deploy: deploy/up.sh creates and deploys the whole thing. deploy/down.sh destroys it so billing stops, which matters for a hackathon budget.

Tiger Data powers the forecast and the search. The data lives in a free Tiger Cloud service. TLS is verified against Tiger's own CA rather than switched off, and locally the same schema runs on Tiger's timescaledb-ha image.

  • sightings is a hypertable. Location is rounded to a ~1 km grid cell before it's stored.
  • cell_daily is a continuous aggregate of each cell's average colour per day. The forecast is plain SQL: regr_slope over three weeks, then (85 − today) / slope days until peak.
  • Hybrid search: Gemma also writes a one-line scene description ("a cluster of sugar maples on the shore of a small lake"). I embed it with all-MiniLM-L6-v2, store it in pgvector with an HNSW index, and index the same text with Postgres full-text. A search ranks spots by meaning and by words, fuses the two rankings with reciprocal rank fusion, and dims everything else on the map. "Red maples by the water" finds the lakeside maples even though nobody typed "water".

Gotchas worth sharing:

  • Freshness. My first continuous-aggregate policy materialized right up to now, so a photo you'd just taken stayed invisible for up to five minutes. Setting end_offset => '1 day' keeps today in real-time mode.
  • Grid cells. Math.round(v / 0.01) * 0.01 gives -73.96000000000001, which silently split one grid cell into two. I now round with toFixed(2).
  • Safari. It ignored the hidden attribute on an element styled display: flex, so the result sheet showed "0/100" while Gemma was still reading. One global [hidden] { display: none !important } fixed it.

Front end: one page.

  • Map: Leaflet with MapLibre rendering OpenFreeMap vector tiles. They're open too, with no API key.
  • Type: Fraunces for headings, Instrument Sans for body text, DM Mono for numbers.
  • Colour: the leaf-colour ramp doubles as the legend.
  • Layout: a bottom sheet on phones, a side panel on wide screens, light and dark themes, and a scan sweep over the photo while Gemma reads.

Why Does Open Innovation Matter?

A photo is a location. A picture of a tree on your street, plus its GPS, says where you walk. In Leaf Peep:

  • every photo is re-encoded so no EXIF or GPS survives;
  • the location is rounded to a ~1 km cell before anything is stored;
  • the model can run on hardware I choose, including a laptop with no third party in the loop. That's how I recorded the demo.

It has to be nearly free to run. A community map only survives if scoring costs nothing to keep alive. Open weights mean I can run Gemma on my own Mac for free, or pay fractions of a cent per photo on DigitalOcean, and switch between the two without changing code.

I could test the model, not just trust it. When the small model over-scored green trees, I swapped sizes, re-ran the same photos and measured the difference in an afternoon. The whole stack is open and swappable: model, embeddings, inference server, database engine, map tiles. My first cut of the demo was even narrated by Kokoro, an open-weight TTS model running on my laptop.

Taking it outside

I took my own photos from that October stroll around Manhattan and ran every one of them through Leaf Peep, with Gemma 4 running on my Mac:

Where Gemma's score What it said
W 192nd St, Washington Heights 65, near peak "Enjoy the beautiful colors along this peaceful autumn walk."
A single tree near Madison Square 90, peak "Enjoy the brilliant colors as you wander through this beautiful urban scene."
The Lake, Central Park, with the San Remo behind it 65, near peak "The water reflects the beautiful tapestry of autumn colors surrounding you."
Gapstow Bridge, Central Park 70, near peak "The colors here are truly breathtaking as the season transitions."

W 192nd St
A single tree near Madison Square
The Lake, Central Park
Gapstow Bridge, Central Park

The surprise was Gapstow Bridge. It's the most colourful photo I took, all reds and oranges, and it only scored 70. Gemma isn't wrong, though. It's a wide shot with evergreen pines and green lawn mixed in, and the score is the share of leaves that have turned. The lone tree near Madison Square, almost every leaf orange, got the 90. So the lesson for using it outside is simple: point the phone at one tree, not the whole view. I changed the hint under the button to say exactly that.

Two more honest notes. Gemma called almost everything "maple", so the tree name is a friendly guess and the colour score is the part to trust. And on my Mac each photo took about 6 to 15 seconds, which is fine on a walk but is why production uses DigitalOcean's serverless inference instead.

Before the walk, I also checked it against a few reference photos at very different points in the season and across every model size. A fully green summer canopy got 5 out of 100 from the 7.5B and 31B models, while the tiny 2B model said 40 ("turning"), the kind of mistake that sends people out a month early. A slide that just says "Quarterly report" was rejected with "Couldn't spot any leaves in that one." Being able to test that myself is exactly why I wanted open weights here.

My Agent Session

I built Leaf Peep in one long session with Claude Code: the app, the hybrid search, the DigitalOcean deploy (and teardown, to keep it free), the iPhone Simulator recordings, and the demo video. Secrets, keys and my location are scrubbed from the transcript.

Building Leaf Peep: Gemma 4, DigitalOcean and Tiger Data for a live fall-foliage map
You

let's participate in this on one https://dev.to/devteam/join-the-hacktoberfest-open-source-ai-challenge-week-1-touch-grass-2450-in-prizes-across-17-4pom?bb=264617

Agent
You

[Request interrupted by user for tool use]

btw, you don't have to used flutter for this, and I think webn is preffered for this

what partner category do you think gets the least submission and is the easiest to win

Agent

Week 1 already has 100+ entries on the first page alone. The list doesn't show which prize categories each entry claims, so I'll pull the post bodies and count the partner mentions.

My pick is Best Use of DigitalOcean. It's a $200 featured category, about one other person has claimed it this week, and it's the easiest one to do as a web app.

About the link you sent: that post announces the winners of the earlier Weekend "Build for a Friend" challenge, not Week 1. Week 1 winners come out the week of Oct 12. It still tells us one useful thing: every one of the 16 categories got a winner. So a category with very few entries isn't left unawarded, and if you're one of only one or two entries, your odds are very good.

Competition this week. I scanned about 440 Week 1 submissions on DEV and checked each post's "Prize Categories" section for the partners it claims:

Category Prize Entries claiming it Posts mentioning it at all
DigitalOcean $200 1 2
Arduino $200 1 4
Temporal $100 1 6
Tiger Data $100 3 5
SerpApi $100 4 8
Tinker / Backboard / Entire / Mastra / Sentry $100–200 ~5 each 7–12
MongoDB Atlas $100 7 20
ElevenLabs / GitHub Copilot $100 14 each 21–26
TabPFN $200 16 25
Render $200 30 60
Gemma $200 118 213

These counts come from keyword matching, so they're estimates, and more entries usually arrive right before the deadline.

Why DigitalOcean:
- It's in the $200 tier, with almost nobody competing for it.
- It fits a web app: host the app on a DigitalOcean server and run the open-weight model there, or use DigitalOcean's GPU servers or its AI platform. That lets you argue "we host our own open model instead of paying for a closed API."
- Arduino is equally empty but needs hardware, so it's a poor fit with about 1.5 days left.
- Gemma is the worst choice despite looking obvious. Over 100 people are competing for it, which is why I'm dropping my earlier Gemma suggestion.

Add Temporal and Tiger Data. One project can enter every category it genuinely uses, and you can only win once per challenge. Each of these has 1–3 entries. For example, a Temporal workflow could send a "go outside now" nudge when the weather clears up, with the location and weather history stored in Tiger Data. They have to be part of how the app actually works, not bolted on, because judges check for meaningful use.

Deadline: Oct 11 at 11:59 PM PDT, about 1.5 days away.

If this works for you, I'll propose a web project idea built around DigitalOcean (with Temporal as an option) and start building. One thing to check first: partners give out credits at hacktoberfest.com/my, so look there for DigitalOcean credits.

You

have a look at the submission in this time range

Agent

Now I'll check how seriously the rival entries in the emptiest categories actually use the partner tech.

I went through the submissions from this week: 575 posts tagged #hf26challenge were published between Oct 5, 18:00 UTC and now. Of those, 523 are actual Touch Grass entries, and 312 of them include the template's "Prize Categories" section. Counts use only entries that explicitly list a category there.

Category Prize Entries How strong the competition is
DigitalOcean $200 2 Weak. One entry only thanks DigitalOcean at the end (AI Gardener). The other is a 539-word post that lists 7 partners in one line each (AI Outdoor Quest). Neither one really uses DigitalOcean.
Arduino $200 1 That one entry actually says it doesn't use Arduino. Nobody really competes here, but you'd need hardware.
Temporal $100 2 Strong. TrailWatch is a hiking check-in app built on durable Temporal workflows, with a video of a "kill the worker mid-trip" test. Hard to beat.
Tiger Data $100 3 Medium. FieldIssue (19 ❤) is solid, but it enters 10+ categories and can only win one.
Tinker / Backboard / Mastra / SerpApi $100–200 5–6 Mostly the same few projects that claim every category.
Entire / Sentry / MongoDB $100 7–9
GitHub Copilot / TabPFN / ElevenLabs $100–200 14–16
Render $200 33
Gemma $200 134

What I'd do:

  1. Go after DigitalOcean ($200). Only two people have entered it, and neither actually uses DigitalOcean. Any web app that genuinely runs on it, with the open-weight model served on DigitalOcean too, would be clearly the best entry. To make the use undeniable:
    • Deploy the web app on DigitalOcean.
    • Run an open-weight model on a DigitalOcean server via Ollama, or through DigitalOcean's AI platform (Gradient) if it hosts open models.
    • Show this with a diagram and screenshots in the post.
  2. Add Tiger Data as a backup ($100). Store things like outing logs or weather history in it. The rivals there are weak or spread across many categories. You can only win once per challenge, so a second category just gives you another chance.
  3. Avoid Temporal. TrailWatch is too strong.
  4. Don't list Gemma as a category. Use Gemma if you like, but with 134 entries, competing there isn't worth it.

Timing: submissions close Oct 11 at 11:59 PM PDT, about 1.5 days from now. The write-up matters most, so we should keep the build small and save several hours for the post. I can also save this session with DevRelay to embed in the post, which judges like.

Should I propose a few web project ideas built around DigitalOcean and get started? Before we start, check hacktoberfest.com/my for DigitalOcean credits and have a DigitalOcean account ready.

You

for this current ongoing one

Agent

Yes, everything in my last message is about the current challenge, Week 1: Touch Grass, which ends Oct 11 at 11:59 PM PDT. I set the Weekend challenge aside after your screenshot.

What I covered for this challenge:
- Window: posts published from Oct 5, 18:00 UTC to now, Oct 10.
- 575 posts carry #hf26challenge, and 523 of them are actual Touch Grass entries.
- 312 of those include the "Prize Categories" section, and the category counts come only from those.

The conclusion is the same. DigitalOcean is the easiest win in this challenge: it's a $200 prize, only 2 entries claim it, and neither actually uses it. Tiger Data ($100, 3 entries) is a good second category.

One caveat: about 211 entries leave out the Prize Categories section, and more will come in before the deadline, so the real counts may be a bit higher. Even so, DigitalOcean is clearly the least contested category that you can realistically use in a web app.

Should I propose a couple of web project ideas around DigitalOcean and start building?

You

yes, give me a few DigitalOcean web project ideas

Agent

Here are four ideas. I avoided the themes that are already crowded this week: side-quest generators, plant or bird ID, trail companions and garden helpers each have dozens of entries.

In every idea, DigitalOcean does real work: the open model runs on DigitalOcean servers (a GPU server, or its Gradient AI platform if it hosts the open model you want), not just the hosting. That's the part the two rival entries were missing.

1. Leaf Peep: a live map of where fall colours are peaking (my pick)
- What it does: people out walking snap a photo of the trees. An open vision model scores how close the colour is to peak (green, turning, peak or past) and pins it on a shared map. Anyone deciding where to walk this weekend opens the map and goes. Each visit takes about 10 seconds.
- DigitalOcean: the web app runs on DigitalOcean's app hosting, photos go into its file storage, and the vision model runs on a DigitalOcean GPU server or Gradient.
- Tiger Data: stores every colour score over time per area, so the app can say "peak in about 3 days" for each spot.
- Why open: photos carry exact GPS locations, and they never go to a third-party AI company. Scoring costs very little per photo, so it can stay free for everyone.
- Why it's strong: fall foliage is named in the challenge brief, it's in season right now, and it earns the "take it outside" bonus naturally.
- Catch: you'd need trees that are actually changing colour near you to demo it for real.

2. Golden Hour: the 40 minutes worth going outside for today
- What it does: combines cloud cover, haze and sunset time to predict tonight's best light window near you. It sends one short alert, like "Go at 5:42, west-facing hill, 70% chance of colour," then stays quiet. Afterwards you rate how the sky actually looked.
- DigitalOcean: a scheduled job on DigitalOcean checks the forecast, and the open model on Gradient writes the alert. The app itself is hosted there too.
- Tiger Data: stores the forecast against what users said they saw, so predictions improve over time. That makes the database essential, not decoration.
- Why open: it runs on a schedule for every user, which would be expensive on a paid closed API but stays cheap on your own server. Works anywhere there's a sky.

3. Plan It Out: your group chat becomes one actual outing
- What it does: paste or upload a group-chat export. The open model works out who's free when and where everyone lives. It proposes one outdoor meetup that fits the weather and sends everyone a calendar invite.
- DigitalOcean: the model and app run on your own DigitalOcean server, so the chats are processed there and then deleted.
- Why open: friends' private messages should never go to a closed AI company. This gives the clearest privacy story of the four, and it's fast to build.
- Catch: it's the weakest fit for Tiger Data.

4. Run Window: a run coach with no app to open
- What it does: you describe your preferences once, e.g. "5k, no rain, under 28°C, free after 6pm." An agent watches the forecast and messages you only when a good window opens. There is no screen to check at all.
- DigitalOcean: a scheduled agent plus the open model, both on DigitalOcean.
- Tiger Data: stores the forecast history alongside the runs you logged.
- Catch: this overlaps with an existing entry, "Clean Air Window," so it's less original.

My recommendation: #1 if trees are changing colour where you are; otherwise #2. Both make DigitalOcean and Tiger Data essential parts of the app, both fit the theme strongly, and both can be built as a small web app in about a day, leaving time for the write-up.

Which one do you want? Once you pick, I'll set up the project, the DigitalOcean deployment and the model serving, and start drafting the post alongside the build.

You

let's do #1

Agent

The leaf-peep folder is open in a new VS Code window, with git set up and dependencies installed. Next I'm writing the database schema, server and map page.

Noted. Commits will be under your name only, with no Claude co-author line, and I'll commit as I go. I'll also save that preference for future sessions and add an MIT license now.

Now the server:

Next I'll start a local TimescaleDB in Docker and load the schema.

The schema applied cleanly, including the hypertable and the auto-refreshing daily summary. Now I'll connect your repo, commit the server and push.

Pushed to sbis04/leaf-peep. Next, a quick test of how well the model scores a few foliage photos, using test images from Wikimedia Commons:

Thanks. I'll need DigitalOcean and Tiger Data access at deploy time; I'll list exactly what to set up after this local test. Starting the server and scoring the three photos now:

The larger 7.5B gemma4 gets all three photos right: green 5, turning 65, peak 95. It's slower (about 5–6 seconds per photo) but still fine for one photo per walk, so I'll make it the default.

Now I'll load some realistic backdated test data so the forecast and map have something to show. This goes into the local database only, and I'll clear it before deploying.

The forecast works: one spot "Peak in ~7 days" (score 56 and rising), two "Peak now", and one "weeks away". Now I'll test the UI in Chrome at desktop and mobile widths.

The panel looks right in dark mode, but the map tiles aren't loading. Checking why:

I'm testing the full photo upload in the browser now.

The test exposed two bugs: the API returned photo: null for that spot, and the error screen shows a stale "0/100" and an empty image. Checking the first one:

That's a bug in my test-data script (the photo paths got merged into one string), not in the app. I'll fix the seed data, then fix the error screen.

Light and dark mode are already supported (it follows the system setting). I'll add a manual toggle that remembers your choice, and fix the error screen at the same time.

Now I'll test the full upload flow and the light theme in the browser:

The upload flow works in light mode: the photo, the score counting up, the stage chip, colour swatches and the model's note all show. Next I'll close it and check the map popup.

Light mode looks clean. But the list shows only 4 spots after my upload, and I expected 5. Checking:

Fixed: a new photo now shows on the map immediately. Committing, then testing at mobile width.

The mobile result sheet looks good. Confirming the upload was stored at the Manhattan location, then committing:

The stored location is right, but it exposed a floating-point bug: -73.96000000000001. Grid cells are grouped by exact value, so one cell could split into two. Fixing:

Checking that the Docker image builds and runs:

You chose the GPU droplet, and you have a DigitalOcean account. I'll install doctl (DigitalOcean's command-line tool) now.

doctl is installed. I need three things from you. I can't create accounts or type credentials for you, so these are yours to do:

1. Sign in to DigitalOcean. Create an API token in the DigitalOcean console (API → Tokens, with read and write access), then run this in the prompt here and paste the token when asked:

! doctl auth init

2. Create a Spaces key (Spaces Object Storage → Access Keys) for photo storage. Then copy the template and fill in SPACES_KEY and SPACES_SECRET yourself:

! cp ~/MobileDev/leaf-peep/.env.example ~/MobileDev/leaf-peep/.env

.env is gitignored, so the keys never reach GitHub.

3. Set up Tiger Cloud. Sign up at console.cloud.timescale.com (free tier) and create a service. Put its connection string in .env as DATABASE_URL, ending in ?sslmode=require.

What I'll do once those are in:
- Create the RTX 4000 GPU server and the Spaces bucket, then set up the database schema on Tiger Cloud.
- Deploy with Docker Compose, download Gemma onto the server, and get HTTPS working on a <ip>.sslip.io address.
- Test it end to end on the live URL, on desktop and mobile.

While you do this, I'll write the README and start the DEV post draft. The deadline is still Oct 11 at 11:59 PM PDT.

Sources: DigitalOcean Droplet pricing, DigitalOcean serverless inference, Gradient AI Platform updates

You

btw does digital ocean provide any credits for testing or for this jhacakthomn

Agent

You're registered for Hacktoberfest 2026 and for Global Hack Week: Hacktoberfest, which is running right now. I'll check both events for sponsor credits:

I found no DigitalOcean credits for you through any of the usual routes:

  • Your MLH events: your registered events have only two sponsor offers right now:
    • Hacktoberfest 2026: 3 months of ElevenLabs Creator (not useful for this project).
    • Global Hack Week: Hacktoberfest: Cursor Pro codes.
  • The challenge post: it lists credits from Tinker, Render, Backboard and ElevenLabs at hacktoberfest.com/my. DigitalOcean isn't among them.

Worth checking yourself:
- hacktoberfest.com/my: that dashboard is the source of truth, and I can't read it. "Connect your DigitalOcean account" is one of its stickers, so look there for a DigitalOcean perk.
- The DigitalOcean billing page: DigitalOcean has historically given new accounts a free trial credit. You already have an account, so it may not apply. If you do have credit, check whether it covers GPU servers before relying on it.

If there are no credits, budget for:
- The GPU server: about $0.76/hr, roughly $18 a day.
- Billing: you're charged per second, and a powered-off server is still charged. Only destroying it stops billing.

To keep the cost down, I'd go for "GPU for the demo, then shrink":
1. Create the GPU server, record the demo and take screenshots tonight or tomorrow.
2. Keep it up through the deadline (about $20–30 total).
3. After that, decide whether to keep it for judging or swap to a cheap CPU server. I'd keep the same server and its address either way.

Next step on your side: run ! doctl auth init, add your Spaces key to .env, and set up Tiger Cloud. I'll take it from there.

You

continue

Agent

Now the DEV post draft, following the submission template. Wherever the post needs your own experience (the walk, real photos), I'm leaving marked placeholders rather than inventing anything.

The draft is ready. Checking whether the credentials are in:

Since your last "continue", I've written the README (pushed to GitHub) and drafted the DEV post. I can't deploy yet: doctl still isn't signed in and there's no .env.

The post draft is at $SCRATCH/post.md. It follows the submission template and makes the case for the DigitalOcean, Tiger Data and Gemma categories with specifics. It has TODO spots that only you can fill:
- why you wanted to build this;
- your real "took it outside" walk;
- the live URL, demo video and screenshots, once deployed;
- the embedded agent session.

To unblock deployment, run these here:

  1. Sign in to DigitalOcean. Create a token in the console under API → Tokens with read and write access, then paste it when prompted: ! doctl auth init
  2. Create the env file, then fill in SPACES_KEY and SPACES_SECRET from Spaces Object Storage → Access Keys: ! cp ~/MobileDev/leaf-peep/.env.example ~/MobileDev/leaf-peep/.env
  3. Set up Tiger Cloud. Create a free service at console.cloud.timescale.com and put its connection string in .env as DATABASE_URL.

Leave SITE as it is; I'll fill it in once the server has an IP. Once you say go, I'll create the GPU server and the Spaces bucket, load the schema into Tiger Cloud, deploy, download Gemma, and test the live site end to end.

You

let's do one thing let's do the digital ocean setup and make it totally usable and maybe test once

but for the demo let's use on ndevice gemma

Agent

Before I build anything, one point needs clarifying, because the two readings of "on-device" lead to very different work:

The plan is clear: the demo gets recorded against Gemma on your Mac, and the DigitalOcean GPU server stays up as the live site. Checking whether the credentials are in yet:

The automatic database setup works locally. Committing:

Nice, that's a new account. One catch with those credits: the $5 is an Inference Cloud Trial, meant for DigitalOcean's serverless model API. It would cover only about 6.5 hours of the GPU server ($0.76/hr). New accounts also often need to request access before they can create GPU servers.

So once you're signed in, I'll check whether DigitalOcean's serverless catalog has an open vision model (Gemma or similar):
- If it does: I'll point the app at it. The app already supports that endpoint type, so it's a configuration change. Scoring then runs on DigitalOcean's infrastructure and is paid from that $5 at a few cents per photo. The app itself goes on a cheap $6–12/month server, with no GPU to pay for.
- If it doesn't, or GPU access is blocked: I'll fall back to the GPU server and tell you what it costs first.

The deploy setup also needs less from you now. Tiger Cloud and Spaces are optional: by default the server runs TimescaleDB itself and keeps photos on its own disk. Your DigitalOcean API token is the only thing I'm missing.

  1. In the DigitalOcean console, go to API → Tokens → Generate New Token, with read and write access.
  2. Run this here and paste the token when asked: ! doctl auth init

Tell me when that's done and I'll take it from there.

You

done

Agent

That $12 server size isn't offered in New York (nyc3), so I'll use Toronto, the closest region that has it:

Next I'll copy the code to the server once Docker is installed.

Testing the limit locally, set to 2 per hour:

The third request is rejected with 429 as expected. Checking whether the key is in:

The DigitalOcean setup is live except for one piece: the site can't score photos until you add a model key.

What's running: https://[droplet].sslip.io loads over a valid HTTPS certificate, and the health check and the map data feed respond. It's a $12/month server in Toronto (the $12 size isn't offered in New York) running the app, TimescaleDB and Caddy.

Scoring: it uses DigitalOcean's own hosted Gemma 4 (gemma-4-31B-it) instead of a GPU server, which takes the GPU's roughly $18/day off the bill. I scored the same test photos through it from your Mac: green 5, turning 65, peak 100, and the non-tree image was rejected. Each took 2–5 seconds and is paid from your $5 trial credit.

Other changes:
- Each visitor can score at most 30 photos an hour, so strangers can't drain the credit.
- Tiger Cloud and Spaces are optional now: by default the server runs its own TimescaleDB and keeps photos on its disk.
- Commits went to GitHub as I went, under your name only.

What I need from you:
1. In the DigitalOcean console, go to Inference / AI Platform → Model Access Keys → Create. DigitalOcean no longer lets the API create these.
2. Paste the key after MODEL_KEY= in leaf-peep/.env in VS Code. Please don't paste it into this chat. I could make the server use your full-account token instead, but that token controls your whole DigitalOcean account, so I'd rather not put it on a public server.

Then say "go" and I'll copy the key to the server, restart it, and test the live site end to end: scoring a photo, the map, popups, and phone and desktop layouts in light and dark mode.

For the demo video, run the local app at http://localhost:8080/?at=40.7794,-73.9632. That uses Gemma on your Mac and keeps your location in Manhattan.

You

where is it [Image #4]

[Image: source: ~/Desktop/Screenshots/Screenshot 2026-10-10 at 9.23.30 AM.png]

Agent

It's right there in your sidebar: Inference Engine → Model Access Keys, the last item under that section, below "Model Catalog".

  1. Click Model Access Keys, then Create (the button may say "Create model access key").
  2. Give it a name like leaf-peep-server. If it asks about scope or models, allow serverless inference; limiting it to Gemma 4 is fine.
  3. Copy the key. DigitalOcean usually shows it only once.
  4. In VS Code, open leaf-peep/.env and paste it after MODEL_KEY= with no quotes or spaces, then save.

Don't paste the key into this chat. Say "go" when it's saved, and I'll copy it to the server, restart, and test the live site end to end.

You

[Image #5]

[Image: source: ~/Desktop/Screenshots/Screenshot 2026-10-10 at 9.24.27 AM.png]

Agent

You're on the right screen. Fill it in like this:

  1. Name: leaf-peep-server is good.
  2. Models: choose Select models, not "All models", then tick only Gemma 4. If the key ever leaks, it can't be spent on expensive models like o1 ($15–60 per 1M tokens).
  3. Batch inferencing: leave it unchecked.
  4. Step 2, Select VPC: pick the option that allows public or any-network access. Locking the key to a VPC could block the server's calls, because it reaches the inference API over the public endpoint. If you're unsure, take the default and I'll check it during the live test.
  5. Create it, copy the key, and paste it after MODEL_KEY= in leaf-peep/.env.

Say "go" when it's saved.

You

[Image #6]

[Image: source: ~/Desktop/Screenshots/Screenshot 2026-10-10 at 9.24.56 AM.png]

Agent

That's right: only Gemma 4 is selected (1/77). Click Next to the VPC step and choose the option without a VPC restriction (public access), then create the key.

On cost: Gemma 4 is $0.18 per 1M input tokens and $0.50 per 1M output tokens. One photo plus the prompt is roughly 1,000–1,500 tokens in and about 100 out, so a score costs well under a tenth of a cent. Your $5 credit should cover more than 10,000 photos, easily enough for testing, the demo and judging.

Paste the key after MODEL_KEY= in leaf-peep/.env and say "go".

You

[Image #7]

[Image: source: ~/Desktop/Screenshots/Screenshot 2026-10-10 at 9.25.33 AM.png]

Agent

Select No VPC network on the right, then click Add model access key.

The "Error loading VPCs" message is harmless; you don't need a VPC here. The server reaches DigitalOcean's inference API over its public endpoint, and the key is already limited to Gemma 4.

Copy the key when it's shown (usually only once), paste it after MODEL_KEY= in leaf-peep/.env, and say "go".

You

done

Agent

The key works (200 response) and .env stays out of git. Copying it to the server and restarting:

Fixed. Now the live site in the browser, desktop width first, with the Manhattan location override:

The live upload through the UI works on desktop. A quick check at mobile width:

I'll capture the set now and save every shot to disk for the submission. Desktop light mode first:

Desktop light looks good. Now desktop dark, with a popup on the yellow "peak in ~6 days" tree:

Rendering the screenshots now. On pausing to save cost, I'll explain after the results come in: on DigitalOcean, pausing doesn't actually lower the bill.

The 12 screenshots are rendered. Checking a few for quality, then I'll lay out costs; I have a concrete plan to keep any unintended spending at zero.

You

[Image: original 1170x2532, displayed at 924x2000. Multiply coordinates by 1.27 to map to original image.]

Agent
You

[Image: original 1170x2532, displayed at 924x2000. Multiply coordinates by 1.27 to map to original image.]

Agent
You

[Image: original 2880x1800, displayed at 2000x1250. Multiply coordinates by 1.44 to map to original image.]

Agent

Re-rendering. I'm deleting the extra rows from earlier shoot runs first, so the list stays clean:

Destroying the server now. First I'll write deploy/up.sh and deploy/down.sh, so the live site can be rebuilt with one command when you're ready to publish.

The server is destroyed and its billing has stopped. I'll make sure nothing else on the account is billable:

The account is clean: no servers, volumes, snapshots, reserved IPs or load balancers, and month-to-date usage is $0.00. Committing the scripts, UI fixes and screenshots:

Pushed. Next: a UI pass, then the full video with voiceover. Checking the new screenshots and what tools are available for video:

You

[Image: original 1170x2532, displayed at 924x2000. Multiply coordinates by 1.27 to map to original image.]

Agent

The schema applied on the pgvector image. Next I'll give the test spots realistic scene descriptions so search has something to match, then try some queries:

"golden trees on a trail" now returns just the honey locust. Testing the whole flow in the browser: score a new photo (which checks that Gemma fills in the new scene field), then search for it.

The phonemizer library can't find its data folder. I'll point it at the bundled copy:

The bundled espeak build on macOS ignores the data path we pass it. I'll install Homebrew's espeak-ng and point Kokoro at that instead:

Demo mode is ready. Next: booting the iPhone 18 Pro simulator, setting a clean status bar (9:41, full battery) and light mode, then recording Safari.

You

[Image: original 1206x2622, displayed at 920x2000. Multiply coordinates by 1.31 to map to original image.]

Agent

Safari is still loading the page (see the progress bar). Waiting, then checking again:

You

[Image: original 1206x2622, displayed at 920x2000. Multiply coordinates by 1.31 to map to original image.]

Agent

The app looks great in real iOS Safari on the iPhone 18 Pro: the map sits above the Dynamic Island area, with Safari's floating tab bar below. Recording the demo now:

You

[Image: original 2400x652, displayed at 2000x543. Multiply coordinates by 1.20 to map to original image.]

Agent

Adding a ?theme= URL option so the Simulator can record dark mode too, then recording all the phone scenes:

Checking all four recordings frame by frame for consistency:

The desktop clips are re-recorded. Now I'm building the video's shared visuals: backgrounds, phone and browser frames, captions and title cards, all rendered from HTML in the app's fonts.

A page load timed out while waiting for the network to go idle. I'll wait for fonts directly instead:

You

[Image: original 2304x864, displayed at 2000x750. Multiply coordinates by 1.15 to map to original image.]

Agent

Each segment is fine on its own, so the problem is in the joining step. Grabbing frames at specific times from the final video:

You

[Image: original 2880x1800, displayed at 2000x1250. Multiply coordinates by 1.44 to map to original image.]

Agent

I'm optimizing the screenshots for the landing page; the full-resolution originals are 43 MB. Then I'll build the page itself.

Images are now 7.1 MB total and the video 8.2 MB. Writing the landing page: same palette and fonts as the app, light and dark mode, and responsive from phone to wide screen.

Previewing the landing page locally at desktop and phone widths:

You

[Image: original 300x5488, displayed at 109x2000. Multiply coordinates by 2.75 to map to original image.]

[Image: original 700x2934, displayed at 477x2000. Multiply coordinates by 1.47 to map to original image.]

Agent

The README matches the last commit, so the warning was only about my own earlier edit. Re-reading it, then writing the new version:

Committing everything (README, landing page, screenshots, video) and checking the repo's visibility before turning on GitHub Pages:

The repo is public and Pages is enabled. I'll wait for the first build and confirm the landing page and video load:

Everything is built and tested end to end, the repo is public, and the landing page is live. Nothing is costing you money right now.

Links
- Landing page: https://sbis04.github.io/leaf-peep/ (hero image, demo video, how it works, search, architecture, run-it-yourself).
- Code: https://github.com/sbis04/leaf-peep. It's MIT licensed, with a new README covering the architecture diagram, how to run it, deployment and the project layout. I checked git history first; no keys or tokens are in it.
- Demo video (72 s, 1080p): docs/leaf-peep-demo.mp4, also on the landing page. It's iPhone 18 Pro Safari recordings from the Simulator plus desktop scenes, in one consistent frame and caption style, narrated by Kokoro running locally. The phone scenes use Gemma on your Mac, and the scan is shown at 2× with a caption saying so. The map history is labelled as demo data on screen.
- Screenshots in docs/screenshots/: framed iPhone shots and desktop shots, both in light and dark mode. Web-sized copies are in docs/img/.

Added since the DigitalOcean setup
- Tiger Data search: "red maples by the water" finds the lakeside maples. It combines meaning-based search (MiniLM embeddings stored in pgvector) with Postgres keyword search.
- UI:
- a scan sweep over the photo while Gemma reads it;
- a "Scored by gemma4 · 9.2 s" line on each result;
- the score sheet now collapses before a spot's popup opens.
- Bug fixes:
- Safari showed "0/100" while Gemma was still reading;
- the local model was dropping out of memory between photos;
- the panel footer was clipped.

Cost: the DigitalOcean server is destroyed, and the account shows $0.00 month-to-date usage with no servers, volumes or snapshots left. ./deploy/up.sh rebuilds the live site in about 5 minutes ($12/month, about $0.40/day), and ./deploy/down.sh stops billing. GitHub Pages is free. Scoring on DigitalOcean only costs per photo, from your $5 credit.

Left for you (deadline: Oct 11, 11:59 PM PDT):
1. Fill in the post's TODOs. The draft is leaf-peep/.drafts/dev-post.md, which git ignores. Add why you built this, and ideally a real walk with real scores; that bonus is something I can't write for you. Upload the video to YouTube and paste its ID.
2. Tiger Cloud (optional). The app runs on Tiger's open-source TimescaleDB image with pgvector. If you finish the Tiger Cloud signup, put DATABASE_URL in .env and I'll verify the schema and search there.
3. Live URL (optional). If you want one for judges, say so and I'll run up.sh right before you publish.
4. Publish. Once the draft is ready, I can stage it as an unpublished draft on DEV via DevRelay, and save this agent session for the "My Agent Session" section. Neither happens without your yes.

Still running locally: the Node server, the TimescaleDB Docker container, and the iPhone Simulator. Tell me if you want them stopped.

You

just crewated tiger cloud account

Agent

Pick Shared (Free) in the top-left. The screen currently has 0.5 CPU selected, which costs $0.0586/hr (about $43/month). It would draw down your trial credit, and could bill you once the trial ends. The free tier is plenty for this app's data.

The other settings:
1. Region: AWS US East (N. Virginia), us-east-1. It's closest to the Manhattan demo and the Toronto server. Ignore the per-hour prices on the region tiles; they're for paid compute.
2. Database type: keep the default, which includes TimescaleDB. Don't choose "Create with plain PostgreSQL".
3. Environment step: if it offers vector support (pgvector or pgvectorscale), turn it on. If not, that's fine; the schema enables the extension itself.
4. Name it leaf-peep and create it.
5. Copy the connection string (it starts postgres://[REDACTED]). Paste it into leaf-peep/.env as:

DATABASE_URL=postgres://[REDACTED]

Again, in the file, not in chat.

Say "go" when it's saved. I'll run the schema on Tiger Cloud and confirm pgvector, the hypertable and the continuous aggregate work there. Then I'll test scoring, forecast and hybrid search end to end against it.

You

[Image #9] this ok

[Image: source: ~/Desktop/Screenshots/Screenshot 2026-10-10 at 10.46.05 AM.png]

Agent

Yes, that's right: Shared (Free) in us-east-1, shown as $0.0000/hr and "Always zero cost". 1 GiB of storage is plenty, since photos are stored elsewhere and the database only keeps small rows and embeddings.

Click Continue:
- Environment: if it offers time-series and vector (pgvector/pgvectorscale), turn them on. Otherwise keep the defaults.
- Name: leaf-peep, then create it.

Then paste the connection string into leaf-peep/.env as DATABASE_URL=postgres://[REDACTED] and say "go".

You

doesn't let me select enviroenmnt [Image #10]

[Image: source: ~/Desktop/Screenshots/Screenshot 2026-10-10 at 10.46.23 AM.png]

Agent

That's expected. The free tier fixes the environment to "Development", so it skips that step, and that's fine for this app. Our schema turns on vector and timescaledb itself, and I'll confirm both are available once it's connected.

  1. Rename the service to leaf-peep (optional), then click Create service. It stays $0.0000/hr.
  2. Copy the connection string when it appears. The password is usually shown only once, so you may want to download the config file it offers.
  3. Paste it into leaf-peep/.env as DATABASE_URL=postgres://[REDACTED], and say "go".
You

pasted

Agent

The connection works, but certificate verification fails with "self-signed certificate in certificate chain". Before loosening anything, I'll check who actually issued the certificate:

The pinned CA is ca.timescale.com, valid until October 2027. The Docker image needs that file too. Now testing against Tiger Cloud with full verification:

Updating the DEV post draft to say the data lives on Tiger Cloud:

Tiger Cloud is connected and tested end to end, and it's on the free tier, so it costs nothing.

  • Secure connection: Tiger signs its certificates with its own CA, which is why the first connection attempt failed. Rather than turning verification off, I pinned Tiger's public CA certificate (db/tiger-ca.pem), so the app checks it's really talking to your Tiger service. The connection runs over TLS 1.3.
  • Schema: it applied cleanly. TimescaleDB 2.30.2 and pgvector 0.8.7 are enabled, along with the hypertable, the daily summary, the vector index and the full-text index.
  • App test (with Gemma running on your Mac, so no DigitalOcean credit was spent):
    • two photos were scored (95 peak, 65 near peak) and stored with their scene descriptions;
    • the map data came back;
    • searching "red maple leaves" found the maple on both meaning and keywords.

I then deleted those two test rows, so Tiger Cloud starts empty for real photos.
- Deploy: ./deploy/up.sh now uses Tiger Cloud automatically, because DATABASE_URL is in .env.
- Docs: the README and the post draft (.drafts/dev-post.md) now say the data lives on Tiger Cloud. Changes are committed and pushed.

Still open for you before the deadline (Oct 11, 11:59 PM PDT): the post's TODOs (your reason for building it, the real walk, a YouTube upload of the video), and telling me whether you want the live site up for judges. Once the draft is ready, I can stage it on DEV as an unpublished draft. Local note: the Node server, Docker database and iPhone Simulator are still running on your Mac.

You

can you open the video in finder

Agent

I've opened a Finder window with the video selected: leaf-peep/docs/leaf-peep-demo.mp4 (72 seconds, 1080p, about 8 MB). Press Space to preview it with Quick Look.

You

keep the currenrt video but is it possible to have more human like voice for the presentation video?

Agent

Yes. The current video stays as it is, and I'd make a second version with a new voice track. There are three ways to get a more natural voice:

Glad you like it. Next I'll find the exact ElevenLabs model ID in DigitalOcean's catalog and how it's called. It's a Fal-hosted model, which likely uses a different endpoint from chat models.

I've hit a blocker. DigitalOcean is now refusing all inference calls on your account, not just ElevenLabs. Gemma returns the same "402 … This account has been blocked", whether called with your account token or the Gemma-only key. Earlier today the same Gemma calls worked.

What I can see:
- The account status still shows active.
- Month-to-date usage is $0.10, probably the hour or two the server ran.
- The block covers DigitalOcean's whole inference service.

It's most likely a billing hold on the new account, for example no payment method on file, or the trial credit not covering that usage. I can't see or change that from here.

This matters beyond the voice: the live deployment uses DigitalOcean's Gemma for scoring. Until this is cleared, ./deploy/up.sh would bring up a site that can't score photos. Everything local (Gemma on your Mac) and Tiger Cloud is unaffected.

What I'd check: DigitalOcean console → Billing. Look for a banner or a missing payment method. If nothing's obvious, open a support ticket quoting request ID [id].

For the voice, while that's sorted out:
- ElevenLabs directly (still recommended): your MLH Hacktoberfest registration has an offer for 3 months of ElevenLabs Creator, no credit card required. Eleven v3 is the same voice we were about to use, and it still counts for Best Use of ElevenLabs. Claiming it uses up one code from MLH's limited supply, so I won't claim it without your yes. You'd also paste the ElevenLabs API key into .env yourself.
- Chatterbox (open-weight, local): free, more natural than Kokoro, and fits the "open" story. It needs a one-time setup of about 2 GB.

Should I claim the ElevenLabs code, or go with Chatterbox?

You

l;et's do ElevenLabs directly

Agent

I've claimed the code. It's shown only here and won't go into any file:

ElevenLabs code: MLH-XXXXXXXX (3 months of Creator, no credit card). The redemption link is https://elevenlabs.io/?coupon=REDACTED.

Your steps (account sign-up and API keys are yours to handle):
1. Open the redemption link, then sign up or log in. The coupon should apply automatically; if not, enter it under Subscription.
2. Go to Profile → API Keys → Create. If it lets you limit permissions, enable Text to Speech and read access to Voices; nothing else is needed.
3. Add a line to leaf-peep/.env:

ELEVENLABS_API_KEY=...

Say "go" when it's saved. I'll list a few natural narrator voices and render the same ten narration lines with Eleven v3 in each. You pick the voice, then I'll build the second version of the video. The first version stays as is.

You

[Image #11]

[Image: source: ~/Desktop/Screenshots/Screenshot 2026-10-10 at 10.56.43 AM.png]

Agent

Choose ElevenCreative (already selected on the left) and click Continue. It includes Text to Speech, which is all we need.

After that:
1. Check that the coupon applied. Your plan under Subscription should show Creator; if not, enter MLH-XXXXXXXX there.
2. Create an API key under Profile → API Keys (Developers → API Keys in some layouts), with Text to Speech and Voices read access.
3. Paste it into leaf-peep/.env as ELEVENLABS_API_KEY=... and say "go".

You

[Image #12]

[Image: source: ~/Desktop/Screenshots/Screenshot 2026-10-10 at 10.59.18 AM.png]

Agent

Those permissions are right: Text to Speech → Access and Voices → Read, with everything else off.

One more suggestion: at the top, set the credit limit to something like 20000 instead of Unlimited. The narration is about 800 characters, so voice samples plus the final render use roughly 5,000 credits. A cap means a leaked key can't drain your plan.

Then click Create Key, paste the key into leaf-peep/.env as ELEVENLABS_API_KEY=..., and say "go".

You

pasted the key, go

Agent

The four male US samples are in the Finder window I opened: leaf-peep-voice-samples/, outside the repo. Select a file and press Space to play it. Each one reads the first two narration lines (about 10 seconds):

  • chris.mp3: charming, down-to-earth.
  • eric.mp3: smooth, trustworthy. This is my pick for a product walkthrough.
  • will.mp3: relaxed optimist.
  • roger.mp3: laid-back, resonant.

Which one should I use? I'll then render all ten lines in that voice, retime the scenes around the new line lengths, and build leaf-peep-demo-v2.mp4 next to the original. One small change for the second version: the line "Even this voice is an open-weight model, Kokoro, running locally" no longer fits. I'll replace it with a short credit, e.g. "Voice by ElevenLabs", on the card.

You

use eric

Agent

Using Eric. I'm rendering all ten lines in his voice with Eleven v3. Line 9 now credits ElevenLabs instead of Kokoro, with a matching card. Scene lengths will be retimed around the new line lengths.

The web search didn't turn up a free clip that matches, so I'll search Pexels' video library directly in the browser:

That tab is still showing the local app, so Pexels didn't load. Trying a fresh tab:

Pexels did load in the original tab; the screenshot was just taken too early. Closing the extra tab and looking at the results:

Results are coming in. I'll try a more specific autumn query and pull the clip titles and links from the page rather than eyeballing thumbnails:

The preview-image links were blocked, so I'll open the top candidate pages and look at them directly, starting with the two closest matches:

The video players show black in screenshots. Instead I'll get each clip's small preview file, download it, and inspect frames locally:

Version 2 is assembled: 92.6 seconds, with healthy audio levels (average −23 dB, peaks −3.9 dB). Checking frames at the key moments:

Version 2 of the video is done, and I've opened a Finder window with it selected: leaf-peep/docs/leaf-peep-demo-v2.mp4 (93 seconds, 1080p, 20 MB). The original leaf-peep-demo.mp4 is still there.

What's different in version 2:
- Voice: Eric, a male US voice from ElevenLabs (Eleven v3).
- Script: rewritten to sound like you talking, e.g. "So… every October, I end up asking the same thing…", "Phone back in your pocket. Keep walking.", "Then… go touch some grass."
- Opening: free Pexels stock footage. A man walks up to an autumn tree, looks up at the colour and raises his phone. Then a close-up of a hand framing the trees on a phone cuts into the iPhone app.
- Retimed: the scan now plays at 1.5× so each line lands on its moment, and the voice card and outro match the new lines.
- Credits: the Pexels creators are credited in the README only, not in the video, as you asked.

Other updates:
- Caption fix: the forecast caption now says "about a week" to match the voice, in both videos.
- Landing page and README: both now point to version 2. The page should update within a minute or two.
- Post draft: now credits ElevenLabs for the narration and adds Best Use of ElevenLabs, which explicitly includes "generate narration for your demo". That's one more category, with only about 16 entries.

Still open:
- DigitalOcean inference block: still unresolved. It only matters if you want the live deployment; check Billing or contact support.
- Your post TODOs: your reason for building it, a real walk, and a YouTube upload of leaf-peep-demo-v2.mp4.
- Deadline: Oct 11, 11:59 PM PDT.

You

~/Downloads/9947020-hd_1920_1080_30fps.mp4

what about this one

Agent

It's a good clip. It shows the same man in the plaid jacket as two of the opening shots, standing among bright yellow, near-peak trees with his phone raised, and the colour is better than anything in the current opening.

One catch: the original title is "Man making video call in park". His phone's back faces the camera and he's looking off to the side, talking, so on its own it reads more like a video call than taking a photo of a tree. It works well as a middle shot though, with the cut to him clearly photographing right after.

What I'd suggest for the opening:
1. "Man in park in autumn": he walks in and looks up at the colour.
2. This clip: standing in the yellow trees, phone up.
3. "Man taking picture of lake": he frames a shot with the phone.

That makes it one person across all three shots. The current walk-up shot uses a different man with a backpack, so this is more consistent. The tradeoff is that the "walking up to a tree" moment becomes weaker, since the backpack shot is the only one with a clear walk toward a tree.

Should I swap it in? I'd either replace the backpack shot (one man throughout) or keep the backpack walk-up as the first shot and use this one in place of "Man in park in autumn". It's about 3 minutes to re-render either way.

You

can we also add some backgroudn subtle music royalty free aswlel

Agent

Yes. I'll add a soft, royalty-free music bed under the narration, ducked so the voice stays clear. In the same re-render I'll swap in your clip.

The opening becomes: the backpack walk-up to the tree, then your clip (yellow trees, phone up), then him photographing. That keeps the walk-up moment and adds your better colour; it's easy to change if you'd rather go one-man-only.

For music I'll look at Pixabay Music, which is free to use with no attribution required, consistent with the footage:

Promising tracks include "Autumn Acoustic Guitar", "Sunlit Leaves", "Acoustic Autumn" and "Modern Classical Autumn". Getting their audio files to compare:

Checking the mix: the music should sit higher in pauses (like the silent title card) and lower under speech:

Your clip is in, at about 5 seconds. The per-section level readings came back empty because my quiet logging flag suppressed them. Re-running:

I've added a soft music bed to the second version, so the pauses are no longer silent, and swapped in your clip. It's in the Finder window I opened: leaf-peep/docs/leaf-peep-demo-v2.mp4 (93 seconds, 20 MB).

  • Music: "Autumn Acoustic Guitar" by YuraSoop, free to use from Pixabay. It runs continuously under the whole video and fades in and out at the ends.
  • Pauses: the title card and the gaps between lines are now filled. There the music sits at about −26 dB, quieter than the voice but clearly there.
  • Under speech: it dips automatically to about 10 dB below Eric's voice, so the narration stays clear.
  • Your clip: it's in the opening at about 5 seconds, the plaid-jacket man in the yellow trees with his phone up. The sequence is: the backpack walk-up to the tree, then your clip, then him taking the photo.

The landing page uses the new file. The README credits the music and the Pexels footage; there are no credits in the video itself. Changes are committed and pushed.

To try another track, three more are in leaf-peep-voice-samples/music/: "Sunlit Leaves", "Acoustic Autumn" and "Modern Classical Autumn". Tell me which and I'll re-mix in about a minute.

You

~/MobileDev/leaf-peep/docs/leaf-peep-demo-v2.mp4

this video is perfect

let memiplaod to youtube

Agent

Glad it came out right. Here's a title and description you can paste into YouTube:

Title

Leaf Peep: an open model reads the trees, so you know where to walk this weekend

Description
```
Snap a tree on your walk. Gemma 4, an open-weight vision model, reads how far its leaves have turned, and the spot lands on a shared map of where fall colour is peaking, with a forecast for when each spot will peak.

Built for the Hacktoberfest 2026 Open-Source AI Challenge: Touch Grass (DEV).

• Gemma 4 scores every photo (DigitalOcean serverless inference, or Ollama on a laptop)
• Tiger Data: hypertable + continuous aggregate for the forecast, pgvector + full-text for hybrid search
• Photos lose their GPS; locations are rounded to ~1 km

Landing page: https://sbis04.github.io/leaf-peep/
Code (MIT): https://github.com/sbis04/leaf-peep

Narration: ElevenLabs. Music: "Autumn Acoustic Guitar" by YuraSoop (Pixabay). Stock footage: Pexels. Map history shown is demo data.
```

Tags: hacktoberfest, gemma, open source ai, digitalocean, tiger data, pgvector, fall foliage, autumn, web app

Settings: use the first frame or docs/img/video-poster.jpg as the thumbnail. Set visibility to Public or Unlisted; either can be embedded on DEV.

Once it's up, send me the link. I'll put {% youtube VIDEO_ID %} into the Demo section of the post draft, and can add it to the landing page too.

You

can you create a youtube thumbnailk that I can use

Agent

I'll make two YouTube thumbnail options at 1280×720 using the video's own look and assets. Both use big text that stays readable when the thumbnail is shown small:
- Option A: a real autumn photo from the footage as the background, with a bold hook on the left and the framed iPhone showing a "95 · PEAK" result on the right.
- Option B: the app's paper background with the brand title, plus the same iPhone and a photo inset.

I've made both YouTube thumbnails, at 1280×720 and well under YouTube's 2 MB limit. They're in the Finder window I opened, in leaf-peep/docs/youtube/:

  • thumbnail-a.jpg (my pick): the man in the yellow trees raising his phone, the hook "Is it peak yet?", and a floating "Scored by Gemma 4 · 95/100 · PEAK" card. It reads clearly even when YouTube shows it small.
  • thumbnail-b.jpg: the brand version. A big "Leaf Peep", "Where the colour is, this week.", and the framed iPhone showing the red maple scored 95, over the same autumn photo.

To set one, go to YouTube Studio → your video → Details → Thumbnail → Upload file.

I've also added your YouTube video (https://youtu.be/uMD2_-Qsu6A) to the post draft's Demo section, a "Watch on YouTube" link on the landing page, and the README's demo link. Changes are committed and pushed.

For the post, what's left is what only you can write: why you built it and your real walk. The draft is at leaf-peep/.drafts/dev-post.md. When it's ready, I can stage it on DEV as an unpublished draft for you to review.

You

publisjed

Agent

Nice. I assume you mean the YouTube video, since I don't see a Leaf Peep post on your DEV account yet. Your most recent post there is the Weekend Challenge entry, "Memories: Personal Media Viewer for TV…".

That earlier post is a good guide for this one. It's personal and specific ("I built it for especially my mom…"), it shows real measurements, and it embeds the agent session. The Leaf Peep draft already has the measurements and architecture. It still needs your voice in two places, which I can't write for you:
1. Why you built it, one or two sentences. Who or what made you want this?
2. Taking it outside: if you can, score a few real trees on a walk and note what came back. For example, "the maple by my building scored 72, near peak." That's the bonus judges asked for.

Two things I can do now:
- Stage the post on DEV as an unpublished draft from .drafts/dev-post.md, so you can finish those two bits in DEV's editor and publish when you're happy.
- Save this agent session with DevRelay and add the {% agent_session … %} embed, like in your Memories post.

Should I do both? Nothing gets published without your go-ahead. The deadline is Oct 11, 11:59 PM PDT.

You

what's left?

Agent

The build, demo and assets are all done. What's left is mostly the DEV post. Deadline: Oct 11, 11:59 PM PDT.

Must do (only you can):
1. Write your personal lines in the draft (leaf-peep/.drafts/dev-post.md):
- why you built it (1–2 sentences);
- ideally a real walk: score a few actual trees and mention what they scored. Judges asked for this as a bonus.
2. Publish the post on DEV with the devchallenge and hf26challenge tags. Include all four prize categories: DigitalOcean, Tiger Data, Gemma and ElevenLabs.

I can do (say the word):
3. Stage the draft on DEV as unpublished, so you can finish it in DEV's editor.
4. Save this agent session with DevRelay and add the embed to the post, like in your Memories post.

Optional:
5. Fix the DigitalOcean inference block (Billing, or a support ticket quoting request [id]). This only matters if you want a live URL for judges; then I'd run ./deploy/up.sh. The landing page, video and code are already public without it.
6. Set the YouTube thumbnail (docs/youtube/thumbnail-a.jpg), if you haven't already.

Housekeeping:
- Still running on your Mac: the Node server, the local TimescaleDB container, the iPhone Simulator, and Ollama's Gemma model in memory. I can stop them.
- Current spend: DigitalOcean $0.10, Tiger Cloud free tier, ElevenLabs on the MLH coupon, GitHub Pages free.

You

pelasse fill them up nicely

  • why you built it (1–2 sentences);
    • ideally a real walk: score a few actual trees and mention what they scored. Judges asked for this as a bonus.

btw don't use em dashes anywhere in the post

Agent

I'll fill both in, but one thing first: I can't write a real walk you didn't take. Made-up scores in a contest entry would mislead the judges, and the bonus is specifically for actually taking it outside. So I'll do this:

  • Why you built it: a draft in your voice, based on the project's premise. Please check it rings true.
  • Taking it outside: an honest version built on what really happened: real photos of real trees, the actual scores Gemma gave, and the model comparison. If you take a short walk and send me 2–3 photos of trees, I'll score them for real and swap in your actual results.

Then I'll strip every em dash from the post.

No dashes remain. One honest detail to add: on the gold tree, Gemma guessed "maple", but the photo is actually an ash tree, per the source photo's title. Saying so makes the post more credible:

I've filled both sections in leaf-peep/.drafts/dev-post.md and removed every em dash (and en dash) from the post.

Why you built it (under "What I Built"):

I built it because every October my feed fills up with foliage photos from places I'll never get to in time. I didn't want another week-old report. I wanted something that tells me where the colour is near me this weekend, and then lets me put the phone away and go.

I wrote this in your voice, so please make sure it's true for you, and tweak it if not.

Taking it outside (new section, "What it said about real trees"): I couldn't invent a walk, so this section reports the real tests instead. It covers Gemma's actual results on real tree photos from Wikimedia Commons:
- Green canopy: 5/100 from the bigger models, while the small model wrongly said 40.
- Gold ash tree: 65, near peak. It guessed "maple", which the post points out honestly.
- Red maple: 95–100, peak.
- Non-tree image: a slide that just says "Quarterly report" was correctly rejected.

It ends with why that made open weights matter: you could test it yourself.

To earn the real "took it outside" bonus: take 2–3 photos of trees on an actual walk and drop them here. I'll score them with Gemma and add a short "On my walk" paragraph with your actual results. That's worth doing if you have 15 minutes outside before the deadline.

The only TODO left in the post is the agent-session embed. Should I save this session with DevRelay and stage the whole post on DEV as an unpublished draft?

You

[Image #13] [Image #14] [Image #15] [Image #16] here are soem pictires I took during a weekend stroll in october

[Image: source: ~/Downloads/img4.jpg]

[Image: source: ~/Downloads/img1.jpg]

[Image: source: ~/Downloads/img2.jpg]

[Image: source: ~/Downloads/img3.jpg]

Agent

These are great: Washington Heights (W 192nd St), Madison Square, the Lake with the San Remo behind it, and Gapstow Bridge. I'll score all four with Gemma 4 on your Mac, the same model as the demo, through the app's real scoring endpoint. The app re-encodes the photos, which strips their GPS, and these scores go only to your local database.

The shell didn't split those name pairs. Redoing it explicitly:

Now writing both sections in the post:

Both sections are written using your real October stroll and Gemma's actual scores. The post still has no em or en dashes.

Why you built it:

I built it after a weekend stroll in and around Manhattan this October, from the trees along W 192nd St to Madison Square and Central Park. I kept wondering the same thing at every corner: is this the good stuff, or is the park ten blocks away better right now? Foliage reports are weekly and regional. I wanted something that tells me where the colour is near me this weekend, and then lets me put the phone away and keep walking.

Taking it outside: a table of your four photos with Gemma's real scores and notes, followed by the photos themselves:

Where Score
W 192nd St, Washington Heights 65, near peak
A single tree near Madison Square 90, peak
The Lake, Central Park 65, near peak
Gapstow Bridge, Central Park 70, near peak

Below the table, the takeaways:
- The surprise: Gapstow, your most colourful shot, scored only 70. The wide view includes evergreen pines and green lawn, while a single tree scored 90. So the advice is to point the phone at one tree, not the whole view. That's now really in the app: I changed the hint under the button to say so.
- Honest notes: Gemma calls nearly everything "maple", and photos take 6–15 seconds on your Mac.
- Earlier checks: a short recap of the reference tests (the green canopy, and the rejected non-tree slide).

Your four photos are in docs/walk/ as web-sized copies, re-encoded so they carry no GPS or camera metadata. They're committed and pushed so the post can show them.

The post is complete apart from the agent-session embed. Should I save this session with DevRelay, add the embed, and stage the post on DEV as an unpublished draft for your final review?

You

yes, save the session and stage the draft

Agent

The scan found a few things to look at. Checking each in context before adding scrub rules:

Every remaining hit is harmless: either my own scan patterns, or your macOS username in ls output. To be thorough I'll scrub the username too, then rebuild:

90 of 90 messages

Prize Categories

  • Best Use of DigitalOcean:
    • Gemma 4 runs on DigitalOcean serverless inference, using a model-scoped access key.
    • The app runs on a Droplet via Docker Compose and Caddy.
    • deploy/up.sh and deploy/down.sh launch and tear down the whole thing.
  • Best Use of Tiger Data (Tiger Cloud):
    • pgvector embeddings with an HNSW index, plus Postgres full-text search, give hybrid keyword and vector search fused with RRF.
    • A hypertable and continuous aggregate power the peak forecast.
  • Best Use of Gemma:
    • Gemma 4 scores every photo against a JSON schema.
    • I measured three sizes (e2b, 7.5B, 31B) on the same photos and picked by results.
  • Best Use of ElevenLabs:
    • The demo's narration is generated with ElevenLabs Eleven v3.
    • It started from a conversational script, rendered line by line and timed to each scene.

Top comments (2)

Some comments may only be visible to logged-in visitors. Sign in to view all comments. Some comments have been hidden by the post's author - find out more