Inspiration
This idea started with me waiting. On Monday I opened my coding agent and typed, word for word: "yo yk how we were waiting for hacktober dev.to week 3 topic. why were we waiting?" I had been refreshing the challenge page for the new theme, and before that the Week 2 page for results, and before that the petrol price board. I spend a silly amount of my week checking pages for one sentence that isn't there yet.
What it does
Wait For It is a web page where you type what you're waiting for in plain words, add a link if you have one, and then stop checking. It looks for you, rarely and on purpose:
- You write "the Week 2 winners are announced" with the challenge link, or "پاکستان میں پٹرول کی قیمت بدل جائے" (tell me when the petrol price changes in Pakistan) with no link at all.
- Gemma 4, an open-weight model, reads the page (or the past week's Google results) and answers two questions: has it happened, and when should I look next? If the hosted Gemma is unavailable, gpt-oss-120b, another open-weight model, answers through Groq instead.
- When it has happened, or the date moved, you get a browser notification and a short voice note, in English or Urdu.
- The rest of the time it stays quiet. A watch for something a month away gets looked at once a week, not every hour. If the page names a time ("results at 12 PM tomorrow"), it looks halfway there as a safety check, then a minute after 12.
Who gets to be lazier: anyone waiting on a page that will change once. Students waiting for results, people waiting for a price to drop, developers waiting for a release, and me, waiting for hackathon results. The effort it saves is the refreshing and the second-guessing, which for me is many small checks a day.
Try it: the live site | the code | the video
The live page is at https://waitforit.onrender.com. Click "Turn on notifications" once; it sends a test notification straight away so you know they reach you.
The quickest way to see the whole loop is the 2 min / 5 min / 10 min buttons under the form. Each watches a practice page on the site whose "doors open" at that time: it reads the time, sleeps, wakes a minute after, and tells you, with a voice note. On the live site, all three caught the change exactly one minute after the doors opened. Below your own watches, "Running for everyone" shows three real watches anyone can look at.
What a first check looks like. I typed "Linux 7.4 is released" and the kernel.org link, and Gemma's first look came back in about 5 seconds:

The real watches I left running overnight, including two that answer in Urdu. Each card shows what Gemma found, when it will look again, and the expected date it pulled from the page:

How I built it

The architecture is deliberately boring, because the interesting part is the decision in the middle:
- A free pinger (cron-job.org) calls
/api/tickevery 5 minutes with a secret key (the diagram shows my first setting, 30). That keeps the free Render server awake and runs only the watches whose next check is due. Checks due within a few minutes also get a timer on the server, so "a minute after 12" means 12:01, not the next ping. Nothing has to stay on, including my PC. - For a watch with a link, the server fetches the page, strips menus, footers and hidden HTML, and hashes the text. If the hash matches last time, nothing could have changed, so Gemma isn't asked at all.
- For a watch without a link, it asks SerpApi for the past week's Google results instead. Gemma turns the person's sentence into a short query once, when the watch is created, because searching the literal Urdu sentence found nothing.
- Gemma 4 (26B A4B, the open-weight mixture-of-experts model, hosted on Google AI Studio) gets the request, today's date, what it told the person last time, and the page. It replies with JSON: a status (happened, changed, delayed or nothing), a short summary in the person's language, the earliest and latest likely dates, how many hours until it should look again, and a quote.
- On October 24 my AI Studio credits ran out and every call started failing. Since then, when AI Studio can't answer, the same prompt goes to gpt-oss-120b (OpenAI's open-weight model, Apache 2.0) on Groq's free plan, and AI Studio is tried again every 6 hours. Groq's free plan allows 8,000 tokens a minute, so long pages are trimmed to fit. Every check on the page says which model read it.
- MongoDB Atlas holds the watches, their last 50 checks, the browser push subscriptions, the voice notes and the daily counters.
- ElevenLabs turns the summary into a voice note (Flash v2.5 handles Urdu) only when something happened or was delayed, and only when you press play, so notes nobody listens to cost nothing.
The model never gets the last word
The first version trusted Gemma's status. That is exactly what keyword alerts get wrong in the other direction: they trust the page. So now Gemma has to show its work. For any news it must copy a few words from the page, and code checks that those words are really there before anyone is told:
// A quote that skips words ("India were champions... beat New Zealand") counts if every piece is there.
export function quoted(quote, text) {
const norm = (s) => String(s).toLowerCase().normalize('NFKC').replace(/\p{M}/gu, '').replace(/[^\p{L}\p{N}]+/gu, ' ').trim();
const t = norm(text);
const pieces = String(quote).split(/\.{3}|…/).map(norm).filter(Boolean);
// Long enough to mean something: two words, or a number like a version ("158.0").
const enough = (q) => q.includes(' ') && (q.length >= 6 || (q.length >= 4 && /\d/.test(q)));
if (!pieces.length || !pieces.every(enough)) return false;
return pieces.every((q) => ` ${t} `.includes(` ${q} `) || (q.length >= 12 && t.replace(/ /g, '').includes(q.replace(/ /g, ''))));
}
If the quote isn't on the page, the status is downgraded to "nothing", the check is saved with the rejected quote for me to look at, and no notification or voice note goes out. The same idea runs through the rest of the code:
- Gemma picks when to look next, but code clamps it to between 30 minutes and 7 days, and forces a look at least every 6 hours once the earliest likely date is within 3 days. In the eval Gemma once asked to sleep for 720 hours (the 2027 Cricket World Cup); the code cut that to a week.
- Gemma can say a watch is done, but for anything that happens again ("tell me when the price changes"), code ignores that and keeps watching. I added this after the petrol watch found a two-day-old price cut on its first look and switched itself off.
- Before a watch is saved, one short call decides whether the sentence is something a page could show. "asdf", "the thing happens" and "my friend texts me back" are turned away with a reason, before any search is spent; typos, Urdu and Roman Urdu ("petrol ki qeemat kam ho jaye") get through.
- A watch that finds nothing about itself in 5 checks in a row stops itself, instead of checking a wrong link for 45 days.
- If the model misses a time the person typed ("posted at 3 PM"), code picks it out of the sentence. The page fetcher refuses private addresses and checks every redirect hop.

Every key has a hard daily cap stored in the database, because I am a student on free tiers:
| Per check | Typical | Daily cap in code |
|---|---|---|
| Gemma call, page watch | 10,383 tokens in, 122 out, about 4 s | 400 calls |
| Backup call on Groq | page trimmed to about 5,000 tokens | 300 calls |
| Model call when the page is unchanged | 0 (skipped by the hash) | n/a |
| SerpApi search, no-link watch only | 1 search | 8 searches |
| ElevenLabs voice note, on play only | one sentence, 150 characters at most | 8 notes |
On top of that: at most 5 watches per person, 10 new ones per address a day, 80 new-watch attempts a day across the whole site, and every watch ends after 45 days. Background checks may use only 70% of each cap, so visitors still get through, and practice watches share one saved voice note. No account has a card on file, so the worst a busy day can do is pause a feature until midnight. I'll delete the keys when judging is over.
Plain Node (no framework), about 1,500 lines, MIT licensed. To run it yourself with nothing but your own PC: clone the repo, npm install, ollama pull gemma4:e4b-it-qat, cp .env.example .env, npm start, then press "2 min". I tested exactly those steps on a fresh clone: local Gemma caught the practice page's doors opening on the minute.
What I measured
A watcher is only as good as its "has it happened?" call, so I built a test set before writing this up. I picked 36 real pages on October 21, wrote a question for each, and labelled every answer by reading the page itself, separately from Gemma:
- 15 release pages (kernel.org, python.org, nodejs.org, go.dev, the Rust blog, Deno's GitHub releases, Firefox release notes), mostly in pairs on the same page: "Linux 7.3 is released" (yes) and "Linux 7.4 is released" (not yet).
- 21 Wikipedia pages for events: the 2026 World Cup final (happened), the 2030 World Cup (not yet), GTA 6 (scheduled for November 19), the Nobel Peace Prize winner (announced) and its ceremony (December 10, not yet), and so on.
- 19 have happened and 17 haven't. The "not yet" pages are the hard ones, because they are full of words like released, announced and champion.
Each page is saved once, so every run reads the same text, and node eval/run.mjs runs the real check (the same checkWatch the server uses, including the quote check) next to a keyword rule that fires when a done-sounding word is on the page. That rule is what a "tell me when this page changes" alert effectively does.

| 36 pages | Correct | False alarms | Missed |
|---|---|---|---|
| Keyword rule | 18 | 15 | 3 |
| Gemma 4 + quote check | 35 | 0 | 1 |
Challenges
All of these are real, and most of them changed the code:
- On October 24 my AI Studio credits ran out, and every check failed with "prepayment credits are depleted". Getting a new free key from Pakistan needed a card, which I don't have, so I added the Groq fallback above. The first version of it failed on every real page, because a full page plus its links came to about 8,700 tokens against Groq's free limit of 8,000 a minute. Pages are now trimmed to fit.
- The same day I found the cron-job.org pinger had been switched off since setup, so my "running overnight" watches had only ever been checked once. It's on now, every 5 minutes.
- My own test, "waiting for it to reach 7:03" on a Tokyo clock page, got a next check an hour away. The model only looked for times on the page, assumed Pakistan time for a Tokyo clock, and didn't know whether 7:03 meant morning or evening. It now uses the time in your own sentence, the page's time zone and the next 7:03 that comes, and I re-ran the same Tokyo page: next check 2.6 minutes later, then "Tokyo time is now past 7:05".
Voice notes were made for every piece of news, heard or not, on a plan that runs out monthly. Now they're made on play.
The one miss is Artemis II. The page says it launched on April 1, 2026 and landed April 11. Gemma read "launch date April 1, 2026" as a plan and said it hadn't happened, even though today's date (October 21) was in the prompt. Dates in the past written like schedules are still a weak spot.
My first full run scored 19 of 36, and 16 of those failures were mine: the free tier limits tokens per minute, and long pages (8,000 to 14,000 tokens each) hit it after two calls. The app now waits as long as Google's error says and carries on, which means a run takes about a minute per page.
One label was wrong, and it was my fault. I marked "Firefox 158 is out" as not yet because my search pattern missed it; Gemma said it was out, and 158.0 and 158.0.1 are both on the page. I fixed the label and added Firefox 159 as the "not yet" case.
The quote check was too strict twice: it refused "158.0" (too short) and a quote with "..." joining two sentences from the T20 World Cup page. Both were true. Version numbers and quotes with gaps now count when every piece is on the page.
The local version was quietly broken until I tested it properly. Ollama gives a model a 4,096-token context by default, so on a 10,000-token page local Gemma only ever saw the first 2,051 tokens and mostly answered with nothing. The Ollama call now asks for 12,288 tokens; 20,480 was too big for my 6 GB GPU and pushed half the model onto the CPU.
What it can't do
- Pages that only render with JavaScript, or sit behind a login, come back nearly empty. University portals are the obvious example. A headless browser would fix it, at a cost I haven't paid yet.
- It reads the first 14,000 characters of a page. If the news is at the bottom of a very long page, it won't see it.
- No-link watches depend on Google having the news in the past week, and on 8 searches a day for the whole site.
- Minute-exact checks rely on a timer in the server's memory. If the server restarts in the minute before one is due, the 5-minute ping catches it instead, a few minutes late. It happened once while I was redeploying.
- Clock pages that draw the time with JavaScript (most of them) show it nothing; it says so instead of pretending.
- Notifications need the browser to have been allowed once, and iPhones only show web push for sites added to the home screen.
- The test set is 36 pages picked by one person on one day. It shows the idea works and where it breaks; it isn't a benchmark.
Accomplishments: the lazy payoff
I used it for the things I was actually waiting for. These are the five watches I started on October 22 at about 2:45 AM my time, and Gemma's first answers. When the credits ran out on October 24 I cleared them and started three of them again as the public examples on the site (Python 3.16, Linux 7.4 and the Urdu petrol watch), so their history starts from that day:
| Watch | First answer | Next look Gemma chose |
|---|---|---|
| The Week 2 winners are announced (the challenge page) | Expected during the week of October 19 | 6 hours (inside the window) |
| Petrol price in Pakistan changes (Urdu, no link) | No new change since the last cut | 24 hours |
| Linux 7.4 is released (kernel.org) | 7.3 is the latest, 7.4 not yet | 24 hours |
| GTA 6 comes out (Wikipedia) | Still November 19 | 7 days |
| Python 3.16 is released (python.org, Urdu) | Not yet, expected around October 2027 | 7 days |
How much refreshing that replaces depends on how anxious you are, so here is the comparison against someone who checks three times a day, using the schedule rules above and assuming the dates on the pages hold:
| Watch | Until | Person checking 3 times a day | Wait For It's looks |
|---|---|---|---|
| GTA 6 | November 19 (28 days) | 84 | about 9: weekly, then every 6 hours in the last 3 days |
| Linux 7.4 | early December (about 45 days, no date on the page) | about 135 | about 45: daily, since it has no date |
| Python 3.16 | October 2027 | over 1,000 | about 60: weekly for a year, then every 6 hours |
| Week 2 winners | this week | 3 a day | 4 a day, and I don't have to do any of them |
The Week 2 watch was the one I cared about most, and the results came on October 23.
And for every one of those looks where the page hasn't changed, Gemma isn't even asked. That is the whole point: the only looks these pages need from now on are Gemma's, and I can close the tabs.
What I learned
Make the model show its work. Gemma's answers only became trustworthy once it had to quote the page and code checked the quote. That one rule took false alarms from 15 (keyword alerts) to 0. The second lesson: test the local setup for real. Ollama's default context window quietly cut every page to its first 2,051 tokens, and I only found out by measuring.
What's next
- A headless browser for pages that only render with JavaScript, so university result portals work.
- Reading past the first 14,000 characters on long pages.
- A bigger test set, labelled by more than one person.
- Watches you can share, so a whole class can wait on one results page with one check.
Running it on your own PC
git clone https://github.com/miawab/waitforit.git && cd waitforit
npm install
ollama pull gemma4:e4b-it-qat
cp .env.example .env
npm start # http://localhost:3000, then press "2 min"
No accounts needed: watches save to a local file, notification keys are made for you, and the server checks due watches every minute by itself. I tested exactly these steps on a fresh clone and local Gemma caught the practice page's doors opening on the minute.
Because Gemma's weights are open, one setting (OLLAMA_URL) switches Wait For It to gemma4:e4b-it-qat on your own machine, so a private page never leaves your PC. On my 6 GB GTX 1660 Super it got 5 of 6 eval pages right, at 42 to 124 seconds a page against about 4 seconds hosted. A watcher that looks once a day can afford that.
Timeline: what existed before the event and what was built during it
- Before October 16 (pre-existing): nothing of Wait For It. The Gemma calling code is adapted from my earlier open-source project scamcheck (started October 19, also inside this event), credited in the README.
- During the event (October 20 to 22): all of it: the watcher, the quote check, the scheduling rules, the web page and push notifications, the Urdu voice notes, the 36-page eval, the Render and Atlas setup, and the video.
- October 24 (during the event): my AI Studio credits ran out, so I added the open-weight gpt-oss-120b on Groq as a fallback, plus the practice page and buttons, exact-time scheduling (time zones, "a minute after"), the sentence check, auto-stop, test notifications, voice notes made on play, and the run-it-yourself setup.
- Also entered in: DEV's Hacktoberfest Week 3 challenge (same project).
- Third-party: Gemma 4 (Google, open weights) on Google AI Studio or Ollama, gpt-oss-120b (OpenAI, open weights) on Groq as the fallback, SerpApi, ElevenLabs, MongoDB Atlas, Render, cron-job.org, Remotion and edge-tts for the video. AI assistance: built with Claude Code as my coding agent, which also helped draft this write-up; every number comes from the eval output in the repo or the live site.