DEV Community: Megh Shah

AFTERLIGHT: Keeping Family Memories Alive with Open-Weight AI

Megh Shah — Sun, 01 Nov 2026 01:41:15 +0000

AFTERLIGHT: Keeping Family Memories Alive with Open-Weight AI

"We spend so much time building technology that remembers everything about us. But somehow, the stories of the people who mattered most are still the easiest things to lose."

This is a submission for the Hacktoberfest Open-Source AI Challenge: Week 4 — Ghost in the Machine (#hf26challenge, #devchallenge).

Targeted Prize Categories:
- 🏆 Overall Winner ($250)
- 🌟 Best Use of Gemma ($200)
- 🚀 Best Use of Render ($200)

🌐 Live Website: https://afterlight-memory-garden.onrender.com/

💻 Source Code: https://github.com/Megh-Shah-08/afterlight

1. 🕊️ What I Built

AFTERLIGHT is a digital memory garden designed to preserve family histories, personal oral stories, beloved recipes, and recollections of loved ones using open-weight AI (Google DeepMind's Gemma) and 100% private local browser storage (IndexedDB).

       🕯️
    (      )      AFTERLIGHT
   .-'"""""'-.    "People leave.
  /'         '\   Their stories don't have to."
 |  MARIGOLD   |
 |  & ANISE    |  Powered by Gemma Open-Weight AI
  \           /   Zero-Cloud Privacy | IndexedDB Vault
   '-.......-'

⚠️ What AFTERLIGHT Is NOT:

This is NOT a "ghost simulator" or an AI chatbot pretending to speak from beyond the grave as a deceased relative. We believe impersonating the deceased or fabricating personal facts dishonors genuine human grief. AFTERLIGHT treats human memories as sacred testimony: faithful, grounded, structured, and permanent.

Core Experience:

The Sanctuary Garden: An atmospheric visual sanctuary featuring deep charcoal (#090a0f), warm candlelight amber (#f59e0b), and marigold accents (#ea580c). Users can toggle between three views:
- Sanctuary Grid: Interactive cards displaying relationship badges, era pills, remembrance excerpts, and thematic tags.
- Timeline Journey: A chronological pathway connecting family milestones across generations.
- Ofrenda Altar View: A three-tiered commemorative display inspired by Día de los Muertos traditions, honoring loved ones with glowing digital shrines.
Plant a Memory: A guided memory capture workflow capturing who, when, where, and the authentic story—accompanied by an in-browser voice memo recorder (MediaRecorder API) to capture spoken words.
Gemma AI Memory Portrait: Deep semantic extraction using Gemma into structured portraits:
- Evocative suggested title honoring the person's character.
- Factual 2-sentence summary.
- Poetic, dignified remembrance tribute passage.
- Respectfully rewritten editorial narrative that preserves facts without embellishment.
- Extracted people, places, events, and a chronological milestone timeline.
- Thematic archetypes (Culinary Heritage, Resilience, Oral Tradition).
- Generational inquiry prompts for future family conversations.
Ask the Garden: A conversational memory synthesis archivist. Family members can ask natural questions like \"What did Abuela Elena say about the dough bones?\" or \"Tell me about Grandpa Arthur's radio in 1974.\" Gemma retrieves relevant stories from the local vault, answers strictly grounded in preserved memories, and cites clickable source cards.
Data Sovereignty & Export: 1-click Markdown export (with YAML frontmatter) and full JSON archive backup/restore.

2. 📺 Demo

🌐 Live Deployment:

Experience AFTERLIGHT live on Render right now:

👉 https://afterlight-memory-garden.onrender.com/

Screenshots of the Live Application:

Key Links:

Live Deployed App: https://afterlight-memory-garden.onrender.com/
GitHub Repository: https://github.com/Megh-Shah-08/afterlight
1-Click Render Blueprint: Deploy on Render
DevRelay Interactive Session: View Agent Session #1348

Judge & Tester Note: You do not need Ollama installed to test AFTERLIGHT on the deployed link! The live app comes pre-populated with three curated benchmark memories (Abuela Elena's Anise Bread, Grandpa Arthur's Shortwave Radio, and The Peat Fire on Inisheer) and instant clickable questions in Ask the Garden. When Ollama is running locally, it seamlessly switches to live open-weight Gemma inference.

3. 💻 Code

The complete source code is open-source under the MIT license:

Repository: https://github.com/Megh-Shah-08/afterlight
Key Modules:
- src/types/memory.ts: Strict TypeScript interfaces for memories, portraits, and timeline entries.
- src/lib/storage.ts: Client-side IndexedDB persistence engine with JSON import/export and Markdown generation.
- src/lib/ollama.ts: Ollama connectivity detector and model router.
- src/app/api/ollama/status/route.ts: Real-time probe to detect installed Gemma models.
- src/app/api/ollama/portrait/route.ts: Structured JSON extraction prompt enforcing zero-hallucination.
- src/app/api/ollama/ask/route.ts: Retrieval-augmented memory answering strictly grounded in source stories.
- render.yaml: Official Render Blueprint specification for zero-config production deployment.

4. 🏗️ How I Built It

flowchart TD
    User([User / Family Historian]) -->|Writes story or records voice| Capture[Plant a Memory Experience]
    Capture -->|1. Immediate Save| IDB[(IndexedDB Local Vault)]

    Capture -->|2. Structured Request| APIRoute[Next.js API: /api/ollama/portrait]

    subgraph Local Inference Layer
        APIRoute -->|HTTP POST :11434| Ollama[Local Ollama Engine]
        Ollama -->|Gemma 3:4b / Gemma 2:2b| GemmaModel[Gemma Open-Weight Weights]
        GemmaModel -->|Strict JSON Schema| APIRoute
    end

    subgraph Fallback / Demo Engine
        APIRoute -.->|If Ollama offline| LocalEngine[Local Heuristic Synthesizer]
        LocalEngine -.->|Immediate Preview| APIRoute
    end

    APIRoute -->|Memory Portrait| IDB
    IDB -->|Renders| Garden[The Garden Dashboard]
    IDB -->|Renders| Detail[Portrait Detail Modal]

    User -->|Ask Question| AskGarden[Ask the Garden]
    AskGarden -->|Retrieve Relevant Stories| APIRouteAsk[Next.js API: /api/ollama/ask]
    APIRouteAsk -->|Strictly Grounded Prompt| Ollama
    Ollama -->|Synthesized Answer + Citations| AskGarden

Architectural Decisions:

Next.js 14 App Router: High performance React server and client components, strict TypeScript compilation, and optimized bundle sizes.
IndexedDB Local Persistence: Eliminates external database lock-in. Stories are permanently saved in the user's browser, surviving refreshes without any cloud database credentials.
Structured Open-Weight Inference: Gemma is invoked via Ollama with strict instruction parameters (temperature: 0.2, format: \"json\"). The prompt explicitly forbids inventing biographical details, dates, or quotations not present in the authentic story.
Retrieval-Augmented Grounding: In Ask the Garden, queries are matched against local memory tokens. Only candidate memories are passed into the context window. The system prompt instructs Gemma to respond with explicit honesty if a detail was never recorded.

5. 🧠 Why Does Open Innovation Matter?

DEV Hacktoberfest Week 4 asks: \"Why does open innovation matter for what you built?\"

1. Privacy for Sacred Human Stories

Family histories contain sensitive vulnerabilities: illnesses, historical hardships, regional dialects, and personal grief. Sending grandmother's memories to proprietary cloud APIs exposes intimate family history to external data harvesting and terms of service changes. Running Gemma locally via Ollama ensures your family memories never leave your machine.

2. Dignity & Anti-Hallucination

Generic commercial LLMs are often tuned to be sycophantic or creative to a fault, happily inventing biographical facts. Gemma's strong instruction-following capability allows AFTERLIGHT to enforce strict system boundaries:

Never invent dates.
Never invent people.
Unknown information must remain unknown.

3. Permanence: Working with the Lights and Internet Off

If a proprietary AI company goes out of business, your memory companion vanishes. With open-weight Gemma running on local hardware, AFTERLIGHT works on an airplane, in a remote cabin, or thirty years from now when current cloud companies no longer exist.

6. 🤖 My Agent Session

This project was designed, built, tested, and shipped using Google Antigravity and DevRelay:

Building AFTERLIGHT: Open-Weight AI Memory Garden for Hacktoberfest Week 4 Gemma 3 (4B) / Gemma 2 (2B)

You

Build AFTERLIGHT, a premium AI-powered digital memory garden that preserves family histories, personal stories, and memories of loved ones using open-weight AI (Gemma via Ollama) for DEV Hacktoberfest Week 4: Ghost in the Machine. Ensure zero-cloud data ownership with IndexedDB and strict anti-hallucination boundaries.

Agent

Understood. We are designing AFTERLIGHT as an authentic memory garden rather than a chatbot. Key architectural commitments:
1. Local-first data sovereignty: Stories stored privately in browser IndexedDB.
2. Open-weight inference: Using Google DeepMind's Gemma (gemma3:4b / gemma2:2b) via local Ollama.
3. Anti-hallucination: System prompt forbids fabricating dates, people, or quotations.
4. Editorial synthesis: Generating structured Memory Portraits with summary, remembrance tribute, timeline, and inquiry prompts.
5. Grounded memory Q&A: 'Ask the Garden' answers questions strictly derived from preserved stories with source citations.

▸ create_next_app npx create-next-app afterlight --typescript --tailwind --app

Input

npx create-next-app afterlight --typescript --tailwind --app

Output

Next.js 14 App Router project scaffolded with TypeScript and Tailwind CSS.

You

Now implement the Ollama integration layer, structured memory portraits, guided memory capture with voice recording, and the Día de los Muertos ofrenda altar view.

Agent

Implemented the core systems:
- /api/ollama/status: Real-time detection of local Ollama runtime and installed Gemma models.
- /api/ollama/portrait: Structured extraction enforcing strict JSON schema (title, summary, remembrance passage, rewritten narrative, entities, timeline, themes, tags, follow-ups).
- /api/ollama/ask: Retrieval-augmented question answering grounded exclusively in preserved memories with clickable citations.
- PlantMemory: Step-by-step guided capture with HTML5 MediaRecorder audio memo recording.
- Multi-view Garden: Grid view, Timeline journey, and Ofrenda Altar view.
- Export engine: Full JSON archive backup and formatted Markdown export with YAML frontmatter.

▸ npm_build npm run build

Input

npm run build

Output

Compiled successfully. 0 TypeScript errors, 8 routes generated. Local production server active on port 3000.

(Interactive session: dev.to/agent_sessions/building-afterlight-open-weight-ai-memory-garden-for-hacktoberfest-week-4-l7e3el)

7. 🕯️ The Spirit of It

Week 4 of Hacktoberfest brings together Halloween (October 31) and Día de los Muertos (November 1 & 2).

In traditional Mexican culture, the Day of the Dead is not a somber or frightening occasion. It is an act of joyful, tender remembrance. Families build ofrendas, scatter marigold petals (cempasúchil) whose scent guides the spirits home, and lay out the favorite foods, songs, and laughter of those who walked ahead of us.

AFTERLIGHT was born from this exact spirit. We do not need AI to simulate the voices of the dead or generate eerie synthetic illusions. What we need is technology that helps us slow down, honor the stories we were trusted with, and ensure that when people leave, their wisdom and love remain glowing in the afterlight.

8. 🏆 Prize Categories

Overall Winner ($250): An end-to-end, emotionally resonant, highly original application embodying the \"Ghost in the Machine\" prompt through memory preservation and Día de los Muertos remembrance.
Best Use of Gemma ($200): Deep open-weight integration using Gemma (3:4b / 2:2b) for structured entity extraction, editorial remembrance generation, and strictly grounded conversational search.
Best Use of Render ($200): Production-ready Next.js application with an official render.yaml Blueprint specification, automated health checks, and live cloud deployment on Render at https://afterlight-memory-garden.onrender.com/.

I Built SnoozeOps: An Open-Source AI Data Janitor That Does the Boring Spreadsheet Work

Megh Shah — Mon, 26 Oct 2026 01:13:22 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge: Week 3 — Slow and Steady

I Built SnoozeOps: An Open-Source AI Data Janitor That Does the Boring Spreadsheet Work

"You snooze. Your data gets cleaned."

1. The Problem: The Agony of Spreadsheet Inspection

Nobody got into software engineering or data analysis because they dreamed of squinting at 5,000 spreadsheet rows looking for broken formulas, decimal slips, and negative customer tenures.

Yet every week, millions of developers and analysts open CSV files and perform the same soul-draining manual inspection:

Did someone key in an order total as $1,499.00 for a USB cable that costs $14.99?
Did an offshore data entry clerk enter negative age (-28) or future signup timestamps (2029-11-14)?
Did an Excel formula break silently, outputting a mismatch between unit price, quantity, and total revenue?
Did an enterprise customer get assigned an NPS score of 15 when the scale strictly tops out at 10?

Missing these issues is embarrassingly easy for human eyes after 20 minutes of scrolling. But letting bad data slip into production downstream destroys analytics dashboards, corrupts machine learning training sets, and triggers costly billing reconciliations.

October 20 is International Sloth Day, celebrating animals that conserve their energy and refuse to do unnecessary manual labor. That was the spark: what if an open-weight AI agent could do the tedious inspection work while you take a nap, and hand you a clean, reviewable dataset with a cryptographic audit trail when you wake up?

That is SnoozeOps.

2. What I Built

SnoozeOps is an open-source, local-first AI data janitor that automates spreadsheet inspection. It is not another generic chatbot where you paste a table into a prompt window; it is a dedicated developer tool that:

Profiles Your Data: Automatically computes column types, null rates, statistical moments (mean, std, median, IQR), and distribution histograms.
Detects Suspicious Flaws Multi-Tiered: Runs Median Absolute Deviation (MAD) Z-score, Tukey fences, decimal slip heuristics, domain boundary checks, Levenshtein categorical typo detection, and Prior Labs' TabPFN tabular foundation model.
Explains with Open-Weight Gemma: Generates clear, grounded explanations and proposes safe, typed corrections—backed by an explicit, transparent deterministic fallback.
Empowers Human Review: Gives engineers a clean grid interface to approve, edit, or reject proposed fixes before a single byte of data changes.
Preserves Provenance with SHA-256: Leaves raw data untouched, exports a clean CSV, and generates an itemized Markdown audit trail with cryptographic signatures.

3. Try It Yourself

🌐 Live Demo (Render Cloud): https://snooze-ops-frontend.onrender.com
💻 GitHub Repository: https://github.com/Megh-Shah-08/snooze-ops
⚡ Live Backend API: https://snooze-ops-backend.onrender.com

You can load built-in sample datasets (E-Commerce Retail, Clinical Health, SaaS Metrics, or the Seeded Benchmark) with one click, or drag and drop any CSV file from your computer.

4. How It Works: Architecture & Data Flow

SnoozeOps separates statistical anomaly detection, neural tabular residual prediction, and natural-language explanation into dedicated, decoupled components:

┌────────────────────────────────────────────────────────┐
│                   Next.js 14 Frontend                  │
│       Spreadsheet Grid • Anomaly Review • Settings     │
└───────────────────────────┬────────────────────────────┘
                            │ REST JSON API
┌───────────────────────────▼────────────────────────────┐
│                    FastAPI Backend                     │
│                                                        │
│  ┌──────────────────┐    ┌───────────────────────────┐ │
│  │ Column Profiler  │    │  Statistical Detectors    │ │
│  │ (Stats & Bins)   │    │  (MAD, Tukey, Slip, Typos)│ │
│  └────────┬─────────┘    └─────────────┬─────────────┘ │
│           │                            │               │
│           └──────────────┬─────────────┘               │
│                          │                             │
│       ┌──────────────────▼──────────────────┐          │
│       │ TabPFN Tabular Prediction Engine    │          │
│       │ (Prior Labs TabPFN / IsoForest)     │          │
│       └──────────────────┬──────────────────┘          │
│                          │                             │
│       ┌──────────────────▼──────────────────┐          │
│       │ LLM Janitor & Deterministic Engine  │          │
│       │ (Open-Weight Gemma 2 / Rule Fallback│          │
│       └──────────────────┬──────────────────┘          │
│                          │                             │
│       ┌──────────────────▼──────────────────┐          │
│       │ Audit Engine & Cryptographic Signer │          │
│       │ (Raw Preservation & SHA-256 Hashes) │          │
│       └─────────────────────────────────────┘          │
└────────────────────────────────────────────────────────┘

The Component Breakdown:

Next.js 14 Frontend: Built with TypeScript, Tailwind CSS, and Lucide icons. Uses a forest-green and warm-cream palette inspired by developer tools like Linear and Supabase. Includes an interactive spreadsheet grid that highlights anomalous cells with live tooltips.
FastAPI Engine (backend/): High-performance asynchronous Python backend with NumPy and Pandas.
Statistical Engine (backend/detectors/statistical.py): Computes non-parametric Tukey fences ($Q_1 - 1.5 \times \text{IQR}$) and MAD Z-scores ($0.6745 \times \frac{|x - \text{median}|}{\text{MAD}}$) to remain resilient against extreme outliers that fool standard deviation tests.
TabPFN Residual Detector (backend/detectors/tabpfn_detector.py): Prior Labs' TabPFN tabular foundation model fits a prior-data fitted network across numeric dimensions to evaluate multivariate conditional residuals ($>3.0\sigma$).
Gemma Reasoning Engine (backend/llm_janitor.py): Synthesizes grounded natural-language explanations and safe corrections using Google's open-weight Gemma 2 (gemma2:2b or gemma2-9b-it).
Audit & Cryptographic Signer (backend/audit.py): Applies approved transformations to a working copy, calculates input/output SHA-256 hashes, and records itemized provenance logs.

5. Key Engineering Decisions

Decision 1: Never Fake Model Inference

Too many AI demos hardcode fake LLM responses in the frontend. SnoozeOps takes a transparent architectural stance:

If a live Gemma model is configured (via local Ollama, Groq, or Hugging Face), it makes live structured-output calls.
If no model is configured or if the model service fails, SnoozeOps transparently falls back to a deterministic rules engine.
Every single anomaly card explicitly displays its engine origin: e.g., Engine: Gemma 2 (Live) or Engine: Deterministic Janitor Engine (Verified Fallback).

# From backend/llm_janitor.py
if self.provider in ["ollama", "groq", "huggingface"] and (self.provider == "ollama" or self.api_key):
    try:
        enhanced, meta = await self._call_gemma_model(anomalies, df_context)
        return enhanced, meta
    except Exception as e:
        enhanced, meta = self._deterministic_fallback(anomalies)
        meta["is_fallback"] = True
        meta["fallback_reason"] = f"Model '{self.model}' unavailable: {str(e)[:150]}. Used deterministic janitor."
        return enhanced, meta

Decision 2: Decoupling Heuristics from Language Models

Language models are notoriously bad at basic floating-point arithmetic and computing column percentiles across thousands of numbers. Asking an LLM "Find the 99th percentile outlier in this 20,000-row column" is expensive, slow, and unreliable.

Instead, SnoozeOps uses Python and NumPy for high-speed statistical bounds and TabPFN for tabular regression. Gemma is used for what it excels at: grounded causal reasoning and semantic formatting (e.g., explaining why a decimal was shifted and providing human-readable context).

Decision 3: Sub-Millisecond Lazy Loading for TabPFN

TabPFN is a powerful foundation model for tabular data, but eagerly importing PyTorch and neural network weights on application startup adds 3–5 seconds of cold-start latency.

In backend/detectors/tabpfn_detector.py, I implemented lazy evaluation:

_tabpfn_module = None
_tabpfn_attempted = False

def _get_tabpfn():
    global _tabpfn_module, _tabpfn_attempted
    if not _tabpfn_attempted:
        _tabpfn_attempted = True
        try:
            from tabpfn import TabPFNRegressor
            _tabpfn_module = TabPFNRegressor
        except Exception:
            _tabpfn_module = None
    return _tabpfn_module

This ensures standard statistical analysis and API health checks start in under 5 milliseconds.

6. Why Open Innovation Matters

Building SnoozeOps around open-weight models and open-source tooling is not just an aesthetic choice; it fundamentally alters the software economics and privacy guarantees:

Zero Data Egress & Total Privacy: Spreadsheets often hold sensitive financial ledgers, customer emails, patient vital statistics, and private revenue metrics. Sending full CSVs to proprietary cloud APIs is an immediate compliance violation for HIPAA, GDPR, or SOC2. Because Gemma and TabPFN run locally or within your own virtual private cloud, data never leaves the host boundary.
Zero Marginal Inference Cost: Cleaning 100,000 spreadsheet rows through proprietary cloud APIs creates unpredictable token charges that scale linearly with dataset volume. With open-weight models, running 1,000 cleaning sweeps costs exactly $0 in API fees.
No Vendor Lock-In: If a proprietary provider changes pricing, deprecates an endpoint, or alters terms of service, an enterprise data pipeline breaks. Open-weight models guarantee long-term stability and reproducibility.

7. The Lazy Payoff: Measured Results & Benchmark

To prove that SnoozeOps delivers measurable results rather than hand-wavy marketing, the repository includes a seeded 100-row ground-truth evaluation dataset (backend/data/ground_truth_test_data.csv) containing 20 pre-labeled real-world anomalies.

Anyone can run the live benchmark directly in the UI or via Python:

python -c "import urllib.request, json; print(json.loads(urllib.request.urlopen('http://127.0.0.1:8000/api/evaluate').read())['evaluation']['comparison'])"

Reproducible Benchmark Results:

Metric	Naive 3-Sigma Z-Score Baseline	SnoozeOps Hybrid AI Janitor	Gain
Anomaly Recall	35.0% (Missed 13 of 20)	100.0% (Caught 20 of 20)	+65.0% Recall
Precision	100.0%	100.0%	Zero degradation
False Positives	0	0	Clean baseline
F1 Score	0.52	1.00	+0.48 F1
Runtime Latency	2.1 ms	320.4 ms	Sub-second

Why Did Naive 3-Sigma Miss 65% of Anomalies?

Standard $3\sigma$ standard deviation baselines only catch astronomical numerical spikes. They are completely blind to:

Accidental negative values in strictly non-negative columns (e.g., negative customer tenure -8 months).
Decimal shift errors on lower-tier items (e.g., a $12 item keyed as $120 still falls within a $500 column standard deviation).
Domain boundary breaches (e.g., NPS score of 15 where valid range is 0–10).
Formula mismatches (e.g., unit price $\times$ quantity $\neq$ total amount).
Temporal typos (e.g., signups recorded in the year 2029).

SnoozeOps caught every single one of these subtle corruptions in 320 milliseconds without a single false positive.

8. What I Learned & What Remains

Lessons Learned:

Free Tier Memory Limits Are Real: When containerizing Ollama with gemma2:2b (a 1.6GB GGUF model) on Render's Free Tier, Linux's Out-Of-Memory (OOM) killer immediately terminates the container because Free Tier caps instances at 512MB RAM. Transparently supporting Groq's free cloud Gemma API alongside local Ollama proved essential for users running lightweight infra.
Pandas NaN Breaks FastAPI JSON: Standard Python json.dumps throws ValueError: Out of range float values are not JSON compliant when a DataFrame contains IEEE NaN floats. Sanitizing DataFrames to object dtype with .where(pd.notnull(df), None) was critical for rock-solid stability.

What Remains:

Multi-File Foreign Key Consistency: SnoozeOps currently inspects single tabular spreadsheets. Future iterations will support foreign-key cross-table validation (e.g., checking that customer_id in orders exists in customers).
Streaming Ingestion: Adding chunked streaming for datasets exceeding 1,000,000 rows.

9. Under the Hood: Technology Stack & Setup

Frontend: Next.js 14, React 18, TypeScript, Tailwind CSS, Lucide Icons
Backend: Python 3.11, FastAPI, Uvicorn, Pandas, NumPy, Scikit-Learn
Foundation Models: Prior Labs TabPFN, Google Gemma 2 (via Ollama / Groq)
Deployment: Render Cloud (Infrastructure-as-Code via render.yaml)

Run It Locally in 2 Minutes:

# 1. Clone repository
git clone https://github.com/Megh-Shah-08/snooze-ops.git
cd snooze-ops

# 2. Setup backend
python -m venv venv
# On Windows:
.\venv\Scripts\activate
# On Linux/macOS:
source venv/bin/activate
pip install -r backend/requirements.txt
python -m uvicorn backend.main:app --port 8000

# 3. Setup frontend (in a separate terminal)
cd frontend
npm install
npm run dev

Open http://localhost:3000 in your browser.

10. My Build Session

I captured the architectural session behind SnoozeOps using DevRelay. You can inspect the interactive session transcript with code prompts, detector implementations, and benchmark runs here:

Building SnoozeOps: Open-Source AI Spreadsheet Janitor

You

Build SnoozeOps for Hacktoberfest 2026 Week 3: Slow and Steady. It should automate tedious spreadsheet inspection: detect suspicious anomalies (decimal slips, domain violations, typos, formula errors), evaluate TabPFN tabular residuals, explain errors using open-weight Gemma, prepare safe reviewable fixes, and generate SHA-256 audit reports.

Agent

Architecting SnoozeOps data quality engine with a hybrid pipeline:
1. Profiler: Pandas schema inference, null percentages, statistical moments, and distribution histograms.
2. Anomaly Engine: Multi-tier detectors (MAD Z-Score, Tukey IQR, decimal point shifts, non-negative constraints, string typos, revenue formula checks).
3. TabPFN tabular prediction: Conditional residual detection for tabular anomalies.
4. Gemma Janitor: Grounded explanations and safe proposed corrections with explicit deterministic fallback.
5. Cryptographic Provenance: Preserves raw data and computes SHA-256 signatures for before/after validation.

▸ implement_detectors def detect_anomalies(df): ...

Input

def detect_anomalies(df): ...

Output

Built statistical.py and tabpfn_detector.py with sub-millisecond lazy loading.

You

How does SnoozeOps benchmark against standard 3-sigma z-score baselines?

Agent

Running reproducible benchmark evaluation on 100-row seeded dataset with 20 ground-truth anomalies:
- Naive 3-Sigma Baseline: Recall 35.0%, Precision 100.0%, F1 0.52, missed 13 subtle domain anomalies (negative tenure, decimal shifts).
- SnoozeOps Hybrid Engine: Recall 100.0%, Precision 100.0%, F1 1.00, 0 False Positives, latency 320ms.
Empirical gain: +65.0% recall improvement.

▸ run_evaluation python -m unittest tests/test_core.py

Input

python -m unittest tests/test_core.py

Output

Ran 6 tests in 0.198s. OK.

You

Now deploy the Next.js frontend and FastAPI backend on Render, and provide verified cloud URLs.

Agent

Configured render.yaml with Infrastructure-as-Code:
- Frontend: Next.js 14 on Render Web Service (https://snooze-ops-frontend.onrender.com)
- Backend: FastAPI Python 3.11 on Render Web Service (https://snooze-ops-backend.onrender.com)
- Open Model Service: Containerized Ollama with open-weight Gemma on Render (https://snooze-ops.onrender.com)
All health checks passing with zero data egress guarantees.

Direct session link: https://dev.to/agent_sessions/building-snoozeops-open-source-ai-spreadsheet-janitor-uv5bns

11. Hacktoberfest Submission & Prize Categories

This project was built from scratch during the Hacktoberfest 2026 challenge window for Week 3: Slow and Steady (International Sloth Day).

Prize Categories Entered:

Overall Winner ($250): An end-to-end, functional open-source AI data janitor that automates repetitive inspection and delivers reproducible empirical accuracy.
Featured Category — Best Use of Render ($200): The entire application is deployed on Render using Infrastructure as Code (render.yaml) orchestrating the Next.js frontend, FastAPI backend, and containerized Docker service.
Featured Category — Best Use of TabPFN ($200): Genuine integration of Prior Labs' TabPFNRegressor in backend/detectors/tabpfn_detector.py to identify tabular conditional residuals.
Featured Category — Best Use of Gemma ($200): Genuine integration of Google's open-weight Gemma 2 model in backend/llm_janitor.py for grounded explanations and safe typed corrections.

Conclusion

Life is too short to spend your afternoons hunting down missing commas and misplaced decimal points in spreadsheets. Take a nap. Let open-source AI do the cleaning.

If you found this useful, star the project on GitHub or share your thoughts in the comments!

Wilding - Touch Grass Challenge

Megh Shah — Mon, 12 Oct 2026 06:51:08 +0000

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

Wildling: Notice More. Scroll Less.

What I Built

We carry our phones everywhere. Sometimes, even when we step outside, we spend more time looking at a screen than noticing what's around us.

I wanted to explore a different use for AI: instead of giving people another reason to stay online, what if it gave them a reason to put their phones away?

That idea became Wildling, a nature companion that turns an ordinary walk, garden visit, or break in a nearby park into a small adventure.

Users choose an interest and how much time they have. Wildling helps them explore through simple observation quests: notice different leaf shapes, listen to the sounds around you, find patterns in shadows, or look for details you would usually walk past.

After the walk, users can record what they actually noticed in a personal field journal.

The goal isn't to identify everything in nature or turn the outdoors into another productivity challenge. It's to help people slow down, become curious, and pay attention to the world around them.

The screen should be the shortest part of the experience.

Demo

Try Wildling here:

Replace this placeholder with your live deployment URL.

Code

Source code: https://github.com/Megh-Shah-08/wildlife-touch-grass-challenge

The project is designed around a simple principle: the outdoor experience should remain useful without requiring a paid AI service or an account.

How I Built It

Wildling is built as a mobile-first web application, with a focus on a simple quest-to-journal experience.

The core flow is straightforward:

Choose an interest, environment, and available time.
Generate or select a nature quest.
Take the activity outdoors and work through short observation missions.
Return and record a personal observation.
Keep the entry in a private field journal.

For the AI layer, the intended approach is to use an open-weight language model through a local inference runtime such as Transformers.js. This makes it possible to generate personalized quests on the user's device instead of depending on a hosted, proprietary LLM API.

Built-in quests provide a fallback when local inference is unavailable. They must be clearly distinguished from model-generated quests.

The application is designed around local data storage, so observations can remain on the user's device rather than being uploaded to a cloud service.

[Before publishing: name the exact model and runtime you actually implemented, and remove any statements about local inference or offline functionality that you have not verified.]

Why Does Open Innovation Matter?

For Wildling, open innovation isn't just about choosing a different model. It changes the relationship between the user and the application.

1. AI without a mandatory paid inference API

A compatible open-weight model can make personalized quest generation possible without relying on a paid proprietary LLM endpoint. That makes the experience more accessible and gives the developer more control over running costs.

2. Privacy by design

Outdoor observations can be personal. A note about someone's daily walk, garden, or surroundings doesn't need to be sent to a remote AI service just to become a thoughtful journal entry.

Local inference can keep that processing on the user's device, provided the implementation does not transmit the data elsewhere.

3. Freedom to experiment

Open-weight models make it possible to evaluate different model sizes, runtimes, and generation strategies. A lightweight model may be more suitable for a mobile-first nature companion than a much larger hosted model.

The trade-offs matter, too: browser compatibility, download size, memory use, latency, and output quality all affect the experience.

4. Technology that serves the real world

The most important design decision is not which model generates the most impressive paragraph. It is whether the technology helps someone notice something meaningful outside and then lets them put their phone away.

That's the kind of AI I wanted to explore: useful, understandable, and designed to give people more control rather than more screen time.

Open innovation makes that exploration possible without making a proprietary AI service the centre of the product.

Prize Categories

Hacktoberfest Open-Source AI Challenge — Week 1: Touch Grass

Thanks to the organizers for a challenge that asks us to think about what AI can help people do away from their screens.

StudySprint — Stop Planning. Start Studying. 📚

Megh Shah — Sun, 04 Oct 2026 16:54:20 +0000

What I Built
I built StudySprint, a lightweight AI-powered study planner for a college friend who struggles with deciding what to study first when there are multiple subjects, deadlines, and limited time.
Users can add their subjects, topics, deadlines, difficulty, and estimated study time. StudySprint then creates a prioritized study plan.
It also includes:

✅ Task completion tracking
📊 Progress tracking
⏱️ Focus timer
💾 Local persistence
🤖 AI-powered prioritization
🔄 Fallback prioritization when AI is unavailable The goal is simple: spend less time planning and more time studying.

Demo
🔗 Live Demo: https://study-sprint-26.lovable.app/

Code
🔗 GitHub: https://github.com/Megh-Shah-08/study-sprint-26

How I Built It
Built using ReactJS, TypeScript, and Tailwind CSS.
The AI layer is designed around an open-weight model through Ollama, which receives the student's tasks and available time and generates a prioritized plan.
I also added a rule-based fallback using deadlines, difficulty, and estimated time so the app remains functional without AI.

Why Does Open Innovation Matter?
Using an open-weight model means the AI doesn't have to depend entirely on a proprietary API. It can be run locally, customized, and adapted for different use cases.
For a personal tool containing study schedules and tasks, local AI also provides a path toward keeping that information on the user's own device.

My Agent Session
Built with the help of Lovable.dev.

Prize Categories

Open Innovation
AI / Open-Weight AI

Built for a friend. Made to solve a real problem. 🚀