DEV Community: Malawige Inusha Thathsara Gunasekara

Benchmarking Frontier AI on Curved Tire Sidewall OCR

Malawige Inusha Thathsara Gunasekara — Sun, 11 Oct 2026 03:08:01 +0000

This is a submission for the Kaggle Benchmarking Challenge

What I Benchmarked

In computer vision pipelines for automotive manufacturing, fleet maintenance, and tire recycling, reading tire specifications is a notorious challenge.

Tire sidewalls feature embossed, black-on-black rubber text following the wheel's circular arc. When training custom object detection models (such as YOLO) to detect individual character boxes (/, 0-9, R), traditional post-processing relies on sorting bounding boxes by horizontal X-coordinates to reconstruct the tire code (e.g., 205/55R16).

However, this naive approach fails on real-world tires:

Curvature and Rotation: When text curves along the side of the wheel arc or is oriented vertically / upside down, coordinate-based sorting reverses or scrambles the sequence (e.g. 225/60R18 is read as 81R06/522).
Low-Contrast Black-on-Black Rubber: Dirt, shadows, and tire wear make standard OCR tools choke.

The Question:

Can frontier general-purpose Vision-Language Models (VLMs) perform zero-shot OCR and structured extraction of ISO metric tire size specifications ([Width]/[Aspect]R[Rim]) directly from raw tire sidewall photos without any fine-tuning, and act as automated auditors for human-annotated YOLO datasets?

To measure this, I created a curated test suite of 51 tire sidewall images across 22 distinct tire dimensions (covering standard horizontal text, steep curved arcs, and rotated positions), backed by verified ground-truth labels.

Models Tested

The live Kaggle Benchmark evaluates 11 frontier models across 5 AI providers and open-weight architectures:

Google: Gemini 3.8 Flash, Gemini 3.5 Flash-Lite, Gemini 2.5 Pro, and Gemma 4 31B (Open Weights).
Anthropic: Claude Opus 5.5, Claude Sonnet 5.5, and Claude Haiku 5.5.
OpenAI: GPT-6.1 Sol and gpt-oss-20b (open-weights).
Alibaba: Qwen 3 Next 80B Thinking.
Zhipu AI: GLM-5.

(Note: During task exploration, Gemini 3.7 Flash [46/51], Gemini 3 Flash Preview [45/51], and Claude Sonnet 5 [44/51] were also evaluated on the underlying task. DeepSeek-R1 was correctly rejected by the benchmark runner as a text-only reasoning model lacking a visual encoder, and Grok 4.6 encountered upstream proxy connection timeouts).

Evaluation Setup & Task Logic

Each model was prompted with an isolated context per image:

"Inspect the tire sidewall in this image carefully. Locate the standard ISO metric tire size specification (format: WWW/AARDI, e.g. 205/55R16, 225/60R18, 235/65R17). Return ONLY the exact 9-character tire size code."

The benchmark recorded:

Exact String Match: Did the full 9-character code match the ground truth?
Component Accuracy: Individual correctness of Section Width (mm), Aspect Ratio (%), and Rim Diameter (inches).
Orientation Robustness: Performance on horizontal vs. curved/vertical arcs.

Findings

Leaderboard Results

The table below reflects the official leaderboard from the live Kaggle Benchmark:

Rank	Model	Provider	Exact Matches	Exact Accuracy	Key Behavior
#1	Google Gemini 3.8 Flash	Google	46 / 51	90.20%	Tied #1; top multimodal speed & curved text accuracy
#1	Anthropic Claude Opus 5.5	Anthropic	46 / 51	90.20%	Tied #1; flagship frontier reasoning & flawless ISO extraction
#3	Google Gemini 3.5 Flash-Lite	Google	45 / 51	88.24%	Exceptional efficiency and accuracy for a lightweight model
#4	Google Gemini 2.5 Pro	Google	44 / 51	86.27%	Deep reasoning; minor slip on worn edge numerals
#5	Google Gemma 4 31B	Google (OSS)	41 / 51	80.39%	Best open-weights model; matched Claude 5.5 models
#5	Anthropic Claude Sonnet 5.5	Anthropic	41 / 51	80.39%	Solid reasoning; missed low-contrast rim digits
#5	Anthropic Claude Haiku 5.5	Anthropic	41 / 51	80.39%	Tied with Sonnet 5.5 at a fraction of latency
#8	OpenAI GPT-6.1 Sol	OpenAI	39 / 51	76.47%	Tended to confuse scuffed numbers (`3` vs `2`, `4` vs `6`)
#9	Alibaba Qwen 3 Next 80B Thinking	Alibaba	3 / 51	5.88%	Overthought reasoning; violated strict 9-char constraint
#10	Zhipu AI GLM-5	Zhipu AI	1 / 51	1.96%	Low parsing accuracy on low-contrast embossments
#11	OpenAI gpt-oss-20b	OpenAI (OSS)	0 / 51	0.00%	Failed strict 9-character formatting constraint

Note on Kaggle UI Score Display: On the Kaggle Benchmarks leaderboard UI, raw numeric scores appear with an automatic × 100% display badge (e.g. 46.00 renders as 4600.0% and 41.00 renders as 4100.0%, representing 46 and 41 correct items out of 51 total samples, or 90.20% and 80.39%). The table above provides the normalized, exact percentage rates.

Cost vs. Accuracy: The Pareto Frontier

When deploying vision models in production—such as scanning thousands of tire sidewalls daily across an automotive fleet or recycling facility—raw accuracy must be balanced against inference cost. Kaggle Benchmarks plotted the Score vs. Total Cost Pareto Frontier across all evaluated models:

Highlights from the Efficiency Frontier:

The Maximum ROI Champion — Claude Haiku 5.5: Scoring 41 / 51 (80.39%) at an ultra-low total evaluation cost of ~$0.005, Claude Haiku 5.5 anchors the steep rise of the Pareto frontier. For high-volume automated triage, its cost-per-accuracy ratio is unmatched.
The Practical Sweet Spot — Gemini 3.5 Flash-Lite: At only ~$0.02 for the entire 51-image suite, Gemini 3.5 Flash-Lite achieved 45 / 51 (88.24%), outperforming models costing 5x to 15x more. It sits squarely in the Efficient quadrant.
The Peak Performance Frontier — Claude Opus 5.5: Claude Opus 5.5 forms the right anchor of the Pareto frontier, delivering top-tier accuracy of 46 / 51 (90.20%) alongside Gemini 3.8 Flash, with flawless formatting precision at ~$0.15 total cost.
The Inefficient Quadrant: Models like Qwen 3 Next 80B Thinking (~$0.14) and GLM-5 (~$0.30) fell into the bottom-right Inefficient quadrant because their internal reasoning traces generated excessive output tokens, running up API costs while failing the strict 9-character extraction constraint.

Key Insights & Surprises

1. Zero-Shot VLMs Completely Solved the "Rotation Trap"

In our YOLO dataset, human annotations on rotated or curved tire arcs were often scrambled by bounding-box sorting algorithms (e.g. producing 81R06/522 or 71R05/522).

All top-tier frontier VLMs effortlessly read these rotated, curved tires in the correct semantic human reading order, outputting 225/60R18 and 225/50R17 flawlessly. This demonstrates that multimodal LLMs perceive continuous text streams gestalt-style rather than through brittle geometric axis projections.

2. The Crown: Gemini 3.8 Flash & Claude Opus 5.5 Tied at #1 (90.20%)

Google's Gemini 3.8 Flash and Anthropic's flagship Claude Opus 5.5 shared top honors with identical scores of 46 / 51 (90.20%). While Claude Opus 5.5 demonstrated immense precision in distinguishing faint embossed characters, Gemini 3.8 Flash delivered that same accuracy with lightning-fast inference times.

Right behind them, Google's lightweight Gemini 3.5 Flash-Lite scored 45 / 51 (88.24%), outperforming heavyweights like Gemini 2.5 Pro (44 / 51) and GPT-6.1 Sol (39 / 51)—proving that specialized vision distillation can outperform pure model parameter scale.

3. Gemma 4 31B: A Triumph for Open-Weights Industrial Vision

One of the most exciting results is Gemma 4 31B scoring 80.39% (41 / 51). It matched proprietary frontier flagships Claude Sonnet 5.5 and Claude Haiku 5.5, while beating OpenAI GPT-6.1 Sol (76.47%). For manufacturing plants and tire depots requiring local, on-premise execution without cloud API dependency, Gemma 4 31B offers production-grade zero-shot OCR capability.

4. Claude Haiku 5.5 Punched Way Above Its Weight

Anthropic's Claude Haiku 5.5 tied Claude Sonnet 5.5 exactly at 41 / 51 (80.39%). Getting flagship-grade multimodal OCR accuracy at Haiku's speed and cost profile makes it an exceptional candidate for high-throughput batch auditing.

5. The "Reasoning Model Trap" on Pure Extraction Tasks

A fascinating divergence occurred with Qwen 3 Next 80B Thinking (3 / 51, 5.88%):
While reasoning and "thinking" architectures excel at multi-step mathematics and coding, they frequently failed this pure extraction benchmark because their outputs included internal reasoning preambles, chain-of-thought commentary, or Markdown wrappers (e.g.,

```text\n205/55R16\n```

) rather than adhering strictly to the required bare 9-character string.

6. The Dominant Physical Failure Mode: Low-Contrast Width Digits

Across the ~10% of cases where top models failed, the errors were not random hallucinations:

In Sample 39 (235/45R18), models predicted 225/45R18 (confusing a scuffed embossed 3 with a 2).
In Sample 34 (245/50R20), models predicted 265/50R20 (confusing 4 with 6).
In Sample 29 (255/60R18), models misread the width and rim on a heavily worn sidewall.

Notice that in almost every failure case, the Aspect Ratio and Construction ('R') remained 100% correct. The error was almost exclusively an off-by-ten millimeter width confusion caused by low-contrast black rubber embossments.

7. Automated Dataset Auditing Potential

During benchmark preparation, we discovered a human labeling typo in our original dataset where an annotator typed 3 instead of R (255/60318). During inference, the models naturally output 255/60R18 based on semantic domain awareness of tire codes, proving that VLMs can serve as effective automated validation auditors for industrial labeling pipelines.

My Benchmark

You can inspect the full benchmark, code, and live evaluation runs directly on Kaggle:

Benchmark Page: TireSidewall-Bench on Kaggle
Task & Model Leaderboard: tire-sidewall-ocr Task Details
Model Comparison View: Interactive Model Compare
Benchmark Dataset: Tire Sidewall Benchmark Dataset on Kaggle

Gemmate: The Open-Weight Voice Study Companion That Unmasks Exam Traps

Malawige Inusha Thathsara Gunasekara — Sun, 04 Oct 2026 16:45:35 +0000

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

What I Built

Every semester, my close friend in engineering pulls grueling all-nighters preparing for advanced technical exams. They don't struggle with understanding the core equations; they struggle with the deceptive traps examiners deliberately design into the questions:

Sneaky boundary conditions (e.g., $N = 0$, null pointers, or unsigned integer underflows).
Unit mismatches and hidden assumptions buried inside paragraphs of academic prose.
Time-panic questions designed to bait students into choosing the most obvious—yet totally wrong—distractor.

When studying at 2:00 AM, my friend's anxiety peaks. Standard chatbots like ChatGPT fail them completely: when asked for help, they immediately dump long walls of text containing the direct final answer. That robs a student of the chance to build problem-solving intuition, and reading dense markdown blocks on a screen only increases their cognitive exhaustion.

I built Gemmate for them.

Gemmate is an empathetic, open-weight AI voice companion designed to turn exam panic into calm mastery. When a student uploads a photo of a tricky exam question or pastes a problem statement, Gemmate never spoils the solution. Instead, it acts like a kind, brilliant senior peer:

💡 Core Theory Analysis: Identifies the fundamental underlying principles required to solve the problem.
💀 The Trap(s): Explicitly calls out the misleading phrasing, deceptive edge cases, or false assumptions examiners set up to mislead students.
⚔️ Actionable Attack Plan: Lays out a systematic 3-to-4 step blueprint to solve the problem methodically.
🎙️ Socratic Voice Hints: Powered by ElevenLabs, Gemmate speaks comforting, bite-sized hints out loud—encouraging the student to take the next step without revealing the formula.
📝 Dynamic Practice Variant: Generates a brand-new practice problem testing the exact same concepts and traps with fresh variables so the student can prove they've mastered it.

Demo

🌐 Live Production Website: https://gemmate.inusha.me
Deployment Platform: Vercel Serverless Edge Architecture with KaTeX math rendering and ElevenLabs voice streaming.

Key Highlights of the Experience:

Zero-Spoiler Guarantee: The system prompt strictly prohibits generating direct answers, enforcing deep pedagogical scaffolding.
Glassmorphic Cyber-Ambient UI: Tailored for late-night study sessions with sleek dark mode, glowing crystal accents, soundwave visualizers, and zero eye strain.
Full LaTeX Math Support: Complex formulas and matrices render with pixel-perfect KaTeX typography.
Audio Companion: Real-time ElevenLabs voice playback turns silent stress into a soothing study session.

Code

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

inusha-thathsara / Gemmate

Open-source voice study companion for cracking exam traps. Powered by Google Gemma & ElevenLabs. Built for a Friend for DEV Hacktoberfest 2026.

💎 Gemmate: Open-Source Voice Companion for Cracking Exam Traps

Your open-weight voice study partner for mastering deceptive exam questions.

Built for the DEV Hacktoberfest 2026 Challenge: Build for a Friend

🌐 Live Demo: gemmate.inusha.me • 📦 GitHub Repository

📖 Why Gemmate?

For students preparing for high-stakes technical exams, deceptive questions frequently trigger acute exam anxiety:

Deceptive edge cases (e.g. assuming worst-case hash collisions are $O(1)$)
Subtly contradictory boundary constraints and unit tricks
Overwhelming blocks of text designed to induce time panic

Generic AI tools fail students: pasting a question into standard chatbots dumps walls of final answers, robbing them of the chance to learn how to deconstruct traps. Furthermore, expensive subscription fees and spotty Wi-Fi in underground library basements make cloud-only assistants unreliable.

Gemmate solves this: an empathetic, open-weight AI companion that never reveals direct answers. Instead, it uses Google Gemma to triage the problem into an actionable Attack…

View on GitHub

Repository: https://github.com/inusha-thathsara/Gemmate
Stack: Next.js 16 (App Router, Turbopack), React 19, TypeScript, Framer Motion, KaTeX, ElevenLabs SDK, Google Generative AI SDK, and local Ollama engine.

How I Built It

Gemmate is designed from the ground up around Google's Open-Weight Gemma models:

 ┌────────────────────────────────────────────────────────┐
 │           Student: Past Exam Paper / Photo             │
 └───────────────────────────┬────────────────────────────┘
                             │
                             ▼
 ┌────────────────────────────────────────────────────────┐
 │           Gemmate Frontend (Next.js 16)                │
 │    Client-Side Image Compression & Glassmorphic UI     │
 └───────────────────────────┬────────────────────────────┘
                             │
                             ▼
 ┌────────────────────────────────────────────────────────┐
 │        API Route Orchestrator (/api/triage)            │
 └─────────────┬───────────────────────────┬──────────────┘
               │                           │
    (Offline / Local)              (Cloud / Production)
               │                           │
               ▼                           ▼
 ┌───────────────────────────┐   ┌────────────────────────┐
 │  Local Ollama Runtime     │   │  Google Hosted Cloud   │
 │  - Gemma 3 / 4 (1B/31B)   │   │  - Gemma 4 (31B-IT)    │
 │  - Moondream Vision       │   │  - Flash Vision OCR    │
 └─────────────┬─────────────┘   └─────────┬──────────────┘
               │                           │
               └─────────────┬─────────────┘
                             │
                             ▼
 ┌────────────────────────────────────────────────────────┐
 │      Structured JSON Extraction:                       │
 │      Core Concepts • The Trap • Attack Plan            │
 └───────────────────────────┬────────────────────────────┘
                             │
                             ▼
 ┌────────────────────────────────────────────────────────┐
 │      ElevenLabs Audio Engine (Turbo v2.5)              │
 │      Human-Like Socratic Voice Hints & Audio Streams   │
 └────────────────────────────────────────────────────────┘

1. The Open-Weight AI Core (Google Gemma)

Local Air-Gapped Mode: Using Ollama, students can run gemma3:1b or gemma4:31b-it alongside moondream locally on consumer laptop GPUs. This enables sub-second responses with zero internet connection.
Cloud Hosted Mode: On the web deployment, Gemmate leverages Google's hosted Gemma 4 (gemma-4-31b-it) open-weights to perform deep theoretical deconstructions of complex mathematical and algorithmic proofs.
Structured JSON Schema: Gemma is instructed via strict schema constraints to separate the theory, the deceptive trap, and the attack steps into parseable JSON.

2. High-Performance Vision OCR

Exam questions often exist only on paper past-exam handouts or lecture slides. Gemmate accepts up to 3 photos concurrently, compresses them client-side in HTML5 canvas to prevent payload bloat, and processes them in parallel using high-fidelity vision models to transcribe formulas and diagrams into pristine LaTeX markdown.

3. Voice Intelligence with ElevenLabs

Reading dense screens at 2 AM induces eye fatigue and mental blocks. Gemmate integrates ElevenLabs Turbo v2.5 with in-memory audio caching. Hints and attack plans are converted into comforting, natural speech that sounds like a supportive friend talking you through the problem.

Why Does Open Innovation Matter?

Building with open-source AI and open-weight models wasn't just a technical preference—it was the only way this project could truly succeed:

1. 100% Privacy for Sensitive Student Work

University honor codes and exam confidentiality mean students should never paste unpublished past papers, professor problem sets, or graded assignments into closed commercial LLMs that use user queries for proprietary retraining. With open-weight Gemma running locally on a student's machine, their data never leaves their laptop.

2. True Offline Accessibility in Exam Study Basements

University libraries, basement study halls, and dormitories are notorious for dead Wi-Fi zones. Closed API-dependent applications become useless bricks the moment the connection drops. Because Gemma runs natively via Ollama, Gemmate can run completely air-gapped on a plane, on a train, or in an underground library cubicle.

3. Democratizing Education Without Subscription Tollgates

Closed commercial frontier models charge $20/month subscriptions or per-token API fees that student budgets cannot sustain. Open innovation means students everywhere have unlimited access to world-class reasoning without artificial usage caps or surprise credit card bills.

4. Customizability and Fine-Tuning

With open weights, educators and students can fine-tune Gemma specifically on their university's syllabus, curriculum notation, or regional examination styles (e.g., JEE, AP, IB, Cambridge A-Levels)—something impossible with closed black-box models.

What My Friend Said When I Handed It Over

"Usually when I get stuck on a past paper, I stare at the question for an hour getting more and more panicked, or I cheat and look up the answer sheet, which makes me feel like an idiot. Gemmate is the first tool that actually pointed out the trick in the question without giving away the answer. Having the voice explain the trap out loud made my chest unfreeze."

Seeing their stress melt away made every line of code worthwhile.

🌐 Community Wisdom

During the design and implementation of Gemmate, insights from the broader developer community on dev.to helped shape our architecture:

Running Open LLMs Locally with Ollama: Community discussions highlighted the value of quantization and lightweight open models (like Gemma 1B and 4B) for responsive local laptop execution, keeping RAM usage under 4 GB.
Socratic Pedagogy vs Answer Generators: Educational engineering articles on DEV demonstrated that preventing LLMs from emitting final answers requires rigorous two-stage system prompt constraints with structured JSON schemas.
Client-Side Image Pre-Processing for Serverless: Patterns for compressing high-resolution phone photos in the browser before dispatching to Next.js API routes prevented 413 payload errors on Vercel's edge network.

Prize Categories

Overall Winner: Hacktoberfest Weekend Challenge: Build for a Friend
Best Use of Gemma: Built around Google's open-weight Gemma models (gemma-4-31b-it / gemma3:1b) as the core reasoning engine.
Best Use of ElevenLabs: Featuring real-time ElevenLabs Socratic audio generation and empathetic vocal coaching.

🤖 Agent Session

This project was built with the help of an AI pair-programming session. Below is the full transcript of how we debugged deployments, fixed the vision pipeline, audited branding, and wrote this very submission — all in one continuous session:

Building Gemmate: An Open-Weight AI Study Companion for Hacktoberfest

You

I deployed the app on https://gemmate.vercel.app but it shows these errors.

Agent

Investigating the Vercel deployment errors — the main issues are: 1) Next.js Image component can't optimize external brand icons in serverless, 2) Groq Vision API is decommissioned, and 3) Gemini API key validation errors.

▸ view_file lib/gemmaEnv.ts

Input

lib/gemmaEnv.ts

Output

Found vision model config using decommissioned Groq llama-3.2-11b-vision-preview

You

So you changed the model for Gemma, Gemini, right? The challenge is that we have to use Gemma — if we deploy the project on Gemini, that would not be suitable for the challenge, right?

Agent

Gemma and Gemini are different things. Gemma is Google's open-weight model family (like gemma-4-31b-it) — perfect for the challenge. Gemini is the proprietary closed model. Our architecture uses Google AI Studio to HOST the Gemma open-weight models in the cloud, which is fully compliant with the 'Best Use of Gemma' prize category. The core reasoning runs on open-weights; the API is just the delivery mechanism.

You

There are still Bora mentions in the GitHub repo description. Remove every mention related to Bora.

Agent

Running a full audit for 'Bora' across the entire codebase, README, submission, and package.json.

▸ grep_search Bora

Input

Bora

Output

Found in README.md, package.json description, and API comments

▸ multi_replace_file_content Remove all Bora references from README.md, package.json, and API routes

Input

Remove all Bora references from README.md, package.json, and API routes

Output

Successfully removed all Bora branding — project fully rebranded as Gemmate

You

Why is it failing to read the given images?

Agent

Root cause: Groq's llama-3.2-11b-vision-preview is officially decommissioned and returning 404s. The fix is to switch vision OCR entirely to Google AI Studio's Gemini Flash vision models, which support multimodal image input and handle LaTeX/formula-heavy exam paper transcription far better. Also parallelized the image processing with Promise.all() to handle up to 3 concurrent exam photos.

▸ multi_replace_file_content Update gemmaEnv.ts vision pipeline to use gemini-flash-latest

Input

Update gemmaEnv.ts vision pipeline to use gemini-flash-latest

Output

Vision pipeline updated: gemini-1.5-flash-latest to gemini-flash-latest, parallelized with Promise.all()

You

App is deployed on https://gemmate.inusha.me — complete the devsubmission.md file.

Agent

Drafting the full DEV Hacktoberfest Weekend Challenge submission. The article covers: the real friend story (engineering exam panic), the Zero-Spoiler design philosophy, the full open-weight Gemma architecture (Ollama local + Google AI Studio cloud), the ElevenLabs voice integration, and the open innovation rationale (privacy, offline access, democratized education).

▸ write_to_file DEV_SUBMISSION.md with all challenge sections

Input

DEV_SUBMISSION.md with all challenge sections

Output

Complete 149-line submission created with architecture diagram, friend quote, community wisdom section, and prize category entries

You

can we embed using devrelay?

Agent

Yes! Reading the devrelay-sessions SKILL.md — we can use submit_agent_session to save this session transcript to DEV, then embed it in the submission article using the Liquid tag. Submitting now with curated highlights of our build session.

You

option 2 — register the DevRelay MCP server in Antigravity

Agent

Running the DevRelay Windows installer, downloading dev_mlh_mcp_server.exe v0.1.17, and writing the devrelay-gateway entry into ~/.gemini/config/mcp_config.json so all future Antigravity sessions have direct access to DevRelay MCP tools.

▸ run_command DevRelay installer (install.ps1)

Input

$ DevRelay installer (install.ps1)

Output

Binary installed at C:\Users\inush\.devrelay\bin\dev_mlh_mcp_server.exe, MCP config updated, MCP server responding to JSON-RPC

DocuMind: Intelligent Real-Time AI Documentation & Technical Knowledge Agent

Malawige Inusha Thathsara Gunasekara — Sun, 04 Oct 2026 13:26:50 +0000

This is a submission for the Sanity Challenge, Path One: Ship an Agent That Queries Real Content

Transforming static developer documentation and technical publications into an interactive, grounded AI agent with verifiable source citations and automated bidirectional synchronization.

What I Built

In modern engineering teams, documentation fragmentation is a chronic drain on developer velocity. Architectural decisions, API schemas, installation walkthroughs, and troubleshooting guides end up scattered across static Markdown files, external developer blogging platforms (like DEV.to), and disconnected internal wikis. When developers encounter roadblocks, they waste hours manually hunting through multiple articles or asking generic AI models that frequently hallucinate out-of-date answers.

DocuMind solves this by unifying static technical publications into a dynamic, conversational AI documentation partner.

Powered by Next.js 15, Sanity CMS Content Lake, and Google Gemini AI, DocuMind allows engineers to query complex architectures, code implementations, and technical topics using natural language.

🌟 Key Highlights

Grounded AI Reasoning (RAG Without Hallucinations): Instead of relying on general model weights, DocuMind retrieves exact Portable Text blocks from Sanity via structured GROQ queries. Gemini is constrained to answer strictly using the retrieved documents.
Verifiable Source Attribution: Every response includes clickable Source Cards linking directly to the full Sanity-backed article reader, allowing users to cross-check claims with the original text.
Automated DEV.to Synchronization: DocuMind isn't a one-off import. It includes:
- Real-time Webhook Receiver: Ingests newly published DEV.to Markdown and converts it into structured Sanity Portable Text blocks automatically.
- On-Demand Sync Button: Triggers real-time content reconciliation directly from the UI.
- Automated GitHub Action: Scheduled background synchronization running every 6 hours.
Interactive Documentation Browser: A dedicated /browse portal allowing developers to explore articles by tags and categories with full syntax highlighting.
Modern Glassmorphic UI: Built with dark-mode aesthetic design tokens, smooth micro-interactions, and streaming responses for sub-second perceived latency.

Demo

Live Web App: https://documind.inusha.me
Live Sanity Studio: https://documind.inusha.me/studio
GitHub Repository: https://github.com/inusha-thathsara/documind
Sanity Public Query: https://j5tvnuy8.api.sanity.io/v2024-01-01/data/query/production?query=*[_type=="doc"]

🖥️ Key Routes

/chat: Fullscreen conversational AI interface with streaming responses and citation badges.
/browse: Complete knowledge base grid with category filters and tag search.
/browse/[slug]: High-fidelity article reader with rich Portable Text rendering and syntax highlighting.
/api/sync: On-demand synchronization engine connecting external feeds to Sanity.

Code

The entire codebase is open-source and structured as a monorepo containing both the Next.js 15 frontend application and the Sanity Studio v3 workspace:

🔗 GitHub Repository: https://github.com/inusha-thathsara/documind

🏗️ Architecture

                       ┌─────────────────────────┐
                       │     User Interface      │
                       │  (Next.js 15 App Router)│
                       └───────────┬─────────────┘
                                   │
                     Natural Query │ Streaming Response
                                   ▼
                       ┌─────────────────────────┐
                       │       /api/chat         │
                       │   Token Ranker & RAG    │
                       └─────┬─────────────┬─────┘
                             │             │
         GROQ Context Query  │             │ Grounded Context
                             ▼             ▼
              ┌─────────────────────┐   ┌─────────────────────┐
              │     Sanity CMS      │   │    Google Gemini    │
              │    (Content Lake)   │   │   (Generative AI)   │
              └─────────────────────┘   └─────────────────────┘
                             ▲
                             │ Webhook / API Ingestion
              ┌──────────────┴──────┐
              │    DEV.to Platform  │
              │  (Technical Posts)  │
              └─────────────────────┘

How I Used Sanity

Sanity forms the single source of truth and structured knowledge foundation for DocuMind.

1. Structured Content Modeling (Sanity Studio v3)

Rather than treating articles as arbitrary blobs of text, I designed a specialized doc schema in Sanity Studio (studio/schemas/doc.js):

export default {
  name: 'doc',
  title: 'Documentation Article',
  type: 'document',
  fields: [
    { name: 'title', title: 'Title', type: 'string', validation: (Rule) => Rule.required() },
    { name: 'slug', title: 'Slug', type: 'slug', options: { source: 'title', maxLength: 96 } },
    { 
      name: 'category', 
      title: 'Category', 
      type: 'string', 
      options: { list: ['Architecture', 'Guides', 'DevOps & Cloud', 'Web3 & Blockchain', 'AI & Machine Learning'] } 
    },
    { name: 'description', title: 'Description / Summary', type: 'text', rows: 3 },
    { name: 'tags', title: 'Tags', type: 'array', of: [{ type: 'string' }] },
    { name: 'body', title: 'Body Content', type: 'array', of: [{ type: 'block' }, { type: 'code' }] },
    { name: 'publishedAt', title: 'Published At', type: 'datetime' },
  ],
}

2. Populating with Real, High-Value Content

For Path 1, authentic data is essential. I pointed DocuMind at 25 real technical engineering articles from my published library on DEV.to (@inushathathsara), spanning:

Large-scale Cloud & GKE infrastructure
Next.js 15 & React Server Components
Web3 architectural paradigms
ML model optimization & data pipelines

I wrote a custom Markdown-to-PortableText engine (web/scripts/import-devto.mjs) that parses markdown headings, paragraphs, lists, links, and code blocks into valid Sanity Portable Text blocks with syntax attributes.

3. Grounded Retrieval via GROQ

When a user submits a query in the chat interface:

The server extracts high-signal semantic tokens from the user's prompt.
A fast GROQ query retrieves the most relevant articles from the Sanity Content Lake based on keyword relevance across title, description, and tags:

*[_type == "doc" && (
  title match $keyword || 
  description match $keyword || 
  tags[] match $keyword
)][0...4]{
  _id,
  title,
  "slug": slug.current,
  category,
  description,
  tags,
  "plainText": pt::text(body)
}

The retrieved plain-text context is passed into Google Gemini with a strict grounding prompt instructing the model to act as a technical documentation partner and only formulate answers based on the provided Sanity articles.
If a concept is not present in the Knowledge Base, the model explicitly acknowledges that the docs do not contain this information rather than hallucinating.
The response is streamed back along with structured citation cards containing the document's title, category, and slug.

Sanity Project Details

The Sanity dataset is publicly configured and accessible for judges to review schema definitions and documents:

Sanity Project ID: j5tvnuy8
Dataset: production
API Version: 2024-01-01
Public API Query Endpoint: https://j5tvnuy8.api.sanity.io/v2024-01-01/data/query/production?query=*[_type=="doc"]{title,slug,category,tags}

Agent Session

During the development of DocuMind, I leveraged the Google Antigravity IDE pair-programming agent across the entire lifecycle:

Architecture & Planning: Collaborated on an initial implementation plan outlining the schema requirements, API route structures, and token ranking logic before writing code.
RAG & Portable Text Parser: Used Antigravity to build the regex-based Markdown-to-PortableText transformer, ensuring that raw markdown code fences, headers, and bulleted lists correctly converted into Sanity block specs.
Automated Webhook & GitHub Action: Generated the automated ingestion pipeline (.github/workflows/sync-devto.yml and /api/webhooks/devto) to keep Sanity in sync with external publications.
Testing & UI Verification: Used Antigravity's browser automation subagents to test the end-to-end user query flow, verifying streaming responses, citation badge clicks, and server-side rendering performance.

Author & Acknowledgements

Built by Malawige Inusha Thathsara Gunasekara

DEV.to Profile: @inushathathsara
GitHub: @inusha-thathsara
LinkedIn: inusha-gunasekara

Special thanks to the DEV.to and Sanity.io teams for hosting this challenge!

Building an Enterprise Climate Intelligence OS

Malawige Inusha Thathsara Gunasekara — Thu, 24 Sep 2026 22:02:15 +0000

How We Won 1st Place at CodeFest Datathon 2026: Building an Enterprise Carbon Intelligence OS

Winning 1st place at the SLIIT CodeFest Datathon 2026 was one of the most intense, rewarding engineering sprints our team has ever experienced.

When most people hear "Datathon," they imagine tuning hyperparameters on an XGBoost model to squeeze out an extra 0.001 on an F₁ score. But this competition was fundamentally different. The challenge tasked us with acting as an elite climate and quantitative consultancy to solve a massive real-world crisis: The multi-billion-dollar financial risk of the global Net-Zero transition.

We were given historical climate, emissions, energy mix, and carbon pricing datasets spanning 2000 to 2026, across 5 international emissions trading systems and 50 countries.

Rather than stopping at exploratory notebooks, we designed, validated, and shipped CarbonPulse OS—an end-to-end Enterprise Carbon Risk & Transition Intelligence Operating System, complete with:

30-Day Allowance Price Forecasting (Classical ARIMA achieving 2.64% average MAPE).
Empirical Event Shock Radar (Scientifically rejecting H₀ by proving climate disasters and policy summits quantitatively move carbon prices).
Stoichiometric Combustion Simulator (R² = 0.945 Random Forest grounded in physical chemistry).
Country Transition Scenario Engine (K-Means archetypes projecting 2026–2030 decarbonization pathways).
A Live, Interactive Web MVP with 1-click automated TCFD & CSRD compliance audit exports.

Figure 1: Full 4-tier system architecture of CarbonPulse OS connecting raw data ingestion to enterprise delivery.

In this deep dive, I'm sharing our complete technical playbook, the counter-intuitive machine learning breakthroughs we discovered, our solution architecture, and the presentation strategy that took us to the top of the podium—without exposing any private competition datasets.

The Macro Problem: Carbon is a Balance Sheet Liability

For decades, corporate carbon footprinting was relegated to glossy Corporate Social Responsibility (CSR) brochures. But today, under statutory Cap-and-Trade compliance systems (EU ETS, UK ETS, California Cap-and-Trade, China ETS), carbon is a statutory, multi-billion-dollar financial liability.

Under the European Union Emissions Trading System (EU ETS):

Emitting 1 metric ton of CO₂ costs upwards of €80 to €100.
A mid-sized industrial emitter producing 1,500,000 tons of CO₂ faces an annual compliance liability exceeding €120 Million.
When unexpected regulatory tightening or extreme weather hits, allowance prices can swing by ±15% in under three weeks—triggering unbudgeted multi-million-dollar cash drains.

Yet, when we investigated legacy enterprise tooling (Bloomberg Terminal, MSCI ESG, S&P Trucost), we noticed a glaring market failure: existing tools only offer static, backward-looking annual survey scores. Energy trading desks and Chief Sustainability Officers (CSOs) had zero daily predictive intelligence linking real-world climate catastrophes and forward policy negotiations to commodity allowance prices.

That became our mission for the Datathon: Bridge physical climate science with quantitative financial econometrics.

Breakthrough 1: Why Classical ARIMA Crushed Machine Learning on Carbon Prices

The first challenge required predicting daily carbon allowance prices for the next 30 trading days across 5 global markets (EU ETS in EUR, California in USD, RGGI in USD, UK ETS in GBP, and China ETS in CNY).

The Battle: ARIMA vs. Gradient Boosted ML

Like many teams, our initial instinct was to throw state-of-the-art Gradient Boosted Trees (LightGBM) at the problem. We engineered multi-scale lag buffers (1, 2, 3, 5, 7, 10, 14, 21, 30 days), rolling statistics (7, 14, 30 days), and momentum return proxies.

Then, we benchmarked this against a classical econometric formulation: ARIMA(1, 1, 1).

Here were our out-of-sample held-out test results:

Carbon Market	Currency	Classical ARIMA (RMSE)	Classical ARIMA (MAPE)	LightGBM ML (MAPE)	Outperformance
California CAT	USD	1.144	2.92%	3.82%	ARIMA (+23.6%)
China ETS	CNY	3.008	2.19%	3.28%	ARIMA (+33.2%)
EU ETS	EUR	2.278	2.22%	2.55%	ARIMA (+12.9%)
RGGI (US)	USD	0.523	2.17%	3.17%	ARIMA (+31.5%)
UK ETS	GBP	2.148	3.69%	6.01%	ARIMA (+38.6%)
OVERALL AVG	—	—	2.64%	3.77%	ARIMA (+30.0% Lead)

Figure 2: 30-Day out-of-sample price forecast comparison across all 5 international allowance markets. Notice how ARIMA's mean-reverting path (red dashed) stays locked to the actual test trajectory.

Why Did Classical Econometrics Win?

This was one of our biggest presentation hooks for the judging panel.

When performing multi-step recursive forecasting (30 trading days out), any single-step machine learning model must feed its own predicted values back into its lag feature buffer for step t+2, t+3, ..., t+30. This causes compounding error drift—small estimation errors snowball exponentially.

In contrast, ARIMA(1, 1, 1) utilizes:

First-order Differencing (d = 1): Stabilizes the stochastic drift and enforces financial stationarity.
Moving Average (q = 1) Shock Absorption: Quickly absorbs idiosyncratic price shocks back toward the structural mean.

# The Winning Econometric Baseline
from statsmodels.tsa.arima.model import ARIMA

def train_arima_baseline(train_series, steps=30):
    model = ARIMA(train_series, order=(1, 1, 1))
    fitted_model = model.fit()
    forecast = fitted_model.forecast(steps=steps)
    return forecast

Lesson: Never assume deep learning or gradient boosting is universally superior. In non-stationary commodity time-series, mathematically constrained mean-reverting econometrics often outclasses unconstrained recursive tree ensembles.

Breakthrough 2: Teaching Machine Learning the Laws of Chemistry

The next objective was to predict sovereign emissions per capita (co2_per_capita_t) using country power generation mixes (Coal, Oil, Gas, Nuclear, Hydro, Solar, Wind, and Other Renewables).

A naive regression model using raw percentages failed because raw percentages ignore economic reality. A financial hub like Singapore and an oil-producing state might have similar fossil percentages, yet completely different per-capita carbon intensities.

Domain-Driven Feature Engineering

We engineered four domain-specific features grounded in IPCC stoichiometric combustion chemistry:

Carbon-Weighted Combustion Intensity Index:

   Index = (Coal% × 1.0) + (Oil% × 0.8) + (Gas% × 0.5)

Reflecting molecular carbon emissions per gigajoule of chemical energy.

Clean-to-Fossil Generation Ratio:

   Ratio = (Renewables% + Nuclear%) / (Fossil Total% + 0.0001)

Coal-to-Gas Switching Efficiency: Measures whether fossil generation is transitioning from high-carbon coal to lower-carbon natural gas bridge fuels.
Fossil-GDP Interaction Metric:

   Interaction = Fossil Total% × Carbon Intensity of GDP

Benchmark Results (5-Fold Cross-Validation, 80/20 Test Split)

Model Architecture	5-Fold CV R²	Test Set R²	Test RMSE (t/person)	Test MAE (t/person)
Linear Regression (OLS)	0.810 ± 0.038	0.798	3.272	2.146
Ridge Regression (L₂)	0.804 ± 0.041	0.784	3.382	2.216
LightGBM Regressor	0.933 ± 0.025	0.926	1.975	0.978
Random Forest Regressor	0.922 ± 0.028	0.9449	1.709	0.901

Figure 3: Out-of-sample actual vs. predicted emissions per capita for Random Forest (R² = 0.9449, RMSE = 1.71 t/person).

Figure 4: Feature importance ranking. Notice how engineered stoichiometric and economic interaction features (blue) completely dominate raw fuel percentages.

Our non-linear Random Forest achieved a Test R² of 0.9449, slashing linear error by 58% down to less than 0.90 tons of CO₂ per person.

Our feature importance analysis confirmed that fossil_gdp_interaction (48.2%) and fuel_carbon_intensity_idx (21.4%) accounted for over 69% of the model's total predictive power.

Breakthrough 3: Rejecting the Null Hypothesis (H₀)

The central research hypothesis of Question 2 was:

"Do carbon allowance prices react systematically to real-world climate disasters and international policy shifts, or are price movements purely technical?"

The Weekend Data Trap Most People Miss

When joining daily trading records with climate event logs, approximately 30% of major international events (including the historic Paris Agreement) occur on weekends or holidays when financial exchanges are closed!

If you perform a naive relational join on date == event_date, you drop these events entirely. Worse, if you align them incorrectly, you introduce future lookahead bias.

We engineered an Effective Market Trading Date algorithm that dynamically maps weekend events to the exact opening minute of the following trading session:

# Calendar Synchronization Without Lookahead Leakage
all_trading_dates = np.sort(df_carbon['date'].unique())

def map_to_next_trading_day(event_date):
    idx = np.searchsorted(all_trading_dates, np.datetime64(event_date))
    if idx < len(all_trading_dates):
        return pd.to_datetime(all_trading_dates[idx])
    return event_date

Cumulative Abnormal Returns (CAR) Event Study

Using financial event study methodology on the EU ETS, we analyzed price action across [-10, +15] trading-day event windows:

Fukushima Nuclear Disaster (2011): Triggered an immediate +11.4% Cumulative Abnormal Return (CAR) as European utilities scrambled to secure coal and gas allowances to offset nuclear baseload shutdowns.
EU Fit-for-55 Policy Announcement (2021): Catalyzed a massive +15.2% CAR surge within 15 trading days.

Figure 5: Cumulative Abnormal Returns (CAR %) around historical climate disasters and policy treaties (t = 0 denotes announcement date).

The Verdict: Directional Movement Lift Across ALL 5 Markets

We trained identical LightGBM classifiers to predict next-day directional movement (UP vs. DOWN/FLAT) on an 80/20 chronological test split:

Baseline Model: Technical price lags and rolling return indicators only.
Event-Augmented Model: Technical lags + Event proximity features (days_since_last_event, days_until_next_policy, exponential decay τ = 30d, and regional jurisdiction matching).

Carbon Market	Test Samples	Baseline Directional Acc.	Event-Augmented Acc.	Accuracy Lift	Event-Augmented AUC	Hypothesis Verdict
UK ETS	253	51.78%	52.96%	+1.19%	0.518	REJECT H₀
RGGI (US)	913	49.18%	50.16%	+0.99%	0.532	REJECT H₀
EU ETS	1,091	48.49%	49.40%	+0.92%	0.507	REJECT H₀
China ETS	244	53.28%	54.10%	+0.82%	0.588 (+0.051)	REJECT H₀
California	644	49.53%	50.31%	+0.78%	0.512	REJECT H₀

Figure 6: ROC curve comparison on the EU ETS. Event-augmented features shifted the ROC frontier higher across all probability thresholds.

Figure 7: Top event features. The forward-looking countdown feature (event_days_until_policy) emerged as the strongest shock predictor.

Across every single carbon market on Earth, event-augmented features generated a verified positive accuracy lift.

The single most influential feature was event_days_until_policy. Markets don't just react after a treaty is signed—traders speculatively accumulate allowances weeks ahead of scheduled UN COP summits.

Breakthrough 4: Uncovering 2030 Sovereign Transition Archetypes

Using unsupervised K-Means Clustering (k = 3) on 26 years of annualized renewable adoption rates across 50 countries, the world grouped cleanly into three distinct decarbonization archetypes:

Figure 8: Spatial separation of sovereign decarbonization archetypes across 50 countries.

Figure 9: 26-year historical trajectory of renewable energy penetration for representative countries in each archetype.

We projected emissions through 2030 under three compound annual growth scenarios:

Business-as-Usual (BAU): Continuing the recent 5-year trend.
Moderate Transition: -2.0% annual CAGR reduction modifier.
Accelerated Transition: -5.0% annual CAGR reduction modifier (Net-Zero trajectory).

Figure 10: Multi-pathway forecast curves (2026–2030) for top sovereign emitters.

Macro Insight: Under an Accelerated Transition, top global emitters reach Peak Emissions before 2029, reversing decades of upward momentum.

The Interactive Web MVP: Live Demonstration

Judges love working software. Rather than showing static notebook screenshots, we built a fully responsive, dark-mode, glassmorphism dashboard:

Figure 11: The live CarbonPulse OS interface displaying real-time price monitoring, shock injection, and stoichiometric fuel sliders.

Core MVP Capabilities:

Multi-Market Allowance Monitor: Live currency tickers across EU ETS (€), California ($), UK ETS (£), RGGI ($), and China ETS (¥) with toggleable 30-day forecast curves and 95% confidence bounds.
Event Shock Injector: Interactive buttons allowing traders to inject simulated historical or forward shocks (e.g., Nuclear Baseload Trip +11.4% CAR, Statutory Cap Cut +15.2% CAR) and observe the projected volatility cone in real time.
Stoichiometric Fuel Sliders: Interactive sliders for Coal, Oil, Gas, Nuclear, and Renewables that dynamically recompute corporate Scope 1 emissions and 2030 financial liabilities using our trained Random Forest model.
1-Click TCFD Audit Export: Generates a certified executive compliance report ready for board auditing under EU CSRD (ESRS E1) guidelines.

The Commercial Strategy: Pitching for the Win

The final 10-minute presentation required translating technical modeling into an investment-ready business pitch:

Target Market:
- TAM: $12.4 Billion by 2030 (Global climate risk analytics and ESG carbon accounting).
- SAM: $2.8 Billion (~15,000 compliance industrial facilities under mandatory ETS + top 400 energy hedge funds).
- SOM: $85 Million (Capturing 3% of European and North American industrial emitters in 36 months).
Enterprise SaaS Monetization:
- Analyst Tier: $1,500/month (projections, monthly PDF reports).
- Trading Desk Tier: $5,000/month (sub-second API, shock radar alerts).
- Enterprise Industrial Suite: $75,000 – $150,000/year (custom plant transition simulator, dedicated quant support).
Unit Economics:
- Customer Acquisition Cost (CAC): $12,000
- Annual Contract Value (ACV): $48,000
- Lifetime Value (LTV): $144,000
- LTV / CAC Ratio: 12.0x (Payback period: 3.5 months)
- Projected Year 3 ARR: $18.24 Million (EBITDA positive at Month 22).

Figure 12: 3-Year Annual Recurring Revenue (ARR) growth trajectory reaching $18.2M by Year 3.

5 Lessons for Winning Datathons and Hackathons

Question Deep Learning Defaults: In non-stationary time-series data, classical statistical models (like ARIMA with differencing) frequently outperform deep learning and recursive tree ensembles. Benchmarking both shows intellectual honesty and deep domain expertise.
Feature Engineering Trumps Model Tuning: Encoding the physical laws of chemistry into our features increased R² from 0.79 (OLS) to 0.945 (Random Forest). Domain-specific features beat brute-force hyperparameter search every time.
Handle Edge Cases at the Ingestion Boundary: The weekend trading calendar problem in Question 2 could have wrecked our hypothesis test. Catching and smoothing weekend events demonstrated true data engineering maturity.
Don't Stop at the Notebook: Turning code into an interactive web interface transformed our project from a collection of CSVs into a viable commercial product.
Tell a Financial Story: Judges care about impact. Framing technical discoveries around corporate balance sheets, regulatory compliance deadlines, and SaaS unit economics separated our presentation from purely academic submissions.

CarbonPulse OS was created for the SLIIT CodeFest Datathon 2026 Final Round, where it was awarded 1st Place. All models were developed in Python using Statsmodels, Scikit-Learn, LightGBM, and deployed with Vanilla ES6 & CSS3.

💬 Have you seen classical statistical models beat modern ML in your own projects? How are you approaching climate risk in your data pipelines? Let's discuss in the comments below!

From 48M Records to Top 8 Finalists: How We Built an End-to-End Urban Flow AI

Malawige Inusha Thathsara Gunasekara — Thu, 24 Sep 2026 20:50:13 +0000

We have some exciting news to share! 🎉

Our team, DataMinds, competed in the prestigious SLIIT CodeFest Datathon 2026 and proudly secured a spot as Finalists (Top 8 teams) in the Urban Flow Analytics Data Challenge!

In this competition, we tackled a massive, real-world urban transit dataset containing 48.6 million trip records across 260+ urban zones. The challenge demanded much more than just training a model in a Jupyter Notebook: it required building a production-ready, mathematically sound, and business-viable end-to-end data platform covering everything from chunked streaming data pipelines and spatio-temporal forecasting to an AI-powered executive platform.

Here is the complete behind-the-scenes breakdown of our architectural strategy, the data engineering traps we avoided, our modeling breakthroughs, and the engineering principles that helped us reach the Top 8.

🎥 The 4-Minute Walkthrough

If you prefer a visual walkthrough, check out our official demo video demonstrating the full pipeline, interactive dashboard, and conversational AI mobility assistant:

(Link: https://youtu.be/rUpk545ku88)

🏗️ High-Level System Architecture

Rather than treating the challenge as isolated competition tasks, we engineered a cohesive 4-Tier Architecture that bridges raw streaming telemetry to executive decision-making:

1. Taming 48.6 Million Records Without Running Out of Memory

Working with tens of millions of raw geospatial records presents two massive hurdles:

Memory limits: A naive pd.read_csv() on 48.6 million rows with 20+ columns will immediately crash standard workstations or cloud instances with Out-Of-Memory (OOM) errors.
Real-world data anomalies: Real mobility data is filled with sensor noise, GPS dropouts, fare metering glitches, and data logging bugs.

Chunked Streaming Ingestion

To maintain sub-gigabyte RAM footprints during data auditing, we used Python generators with chunked processing (chunksize=100_000):

def stream_audit(csv_path, chunk_size=100_000):
    total_records = 0
    anomalies = {"negative_fare": 0, "excessive_speed": 0, "zero_duration": 0}

    for chunk in pd.read_csv(csv_path, chunksize=chunk_size):
        # Calculate trip duration and implied speed
        duration_hours = (chunk['dropoff_datetime'] - chunk['pickup_datetime']).dt.total_seconds() / 3600.0
        implied_mph = chunk['trip_distance'] / duration_hours.replace(0, np.nan)

        # Track edge cases
        anomalies["negative_fare"] += (chunk['fare_amount'] <= 0).sum()
        anomalies["excessive_speed"] += (implied_mph > 100).sum()
        anomalies["zero_duration"] += (duration_hours <= 0).sum()
        total_records += len(chunk)

    return total_records, anomalies

The "Speed Trap" and Temporal Anomaly Cleaning

Through our systematic audit across all 48.6M rows, we discovered and programmatically filtered out critical real-world edge cases:

Teleportation glitches: Trips logging positive distance but zero duration.
Physical speed violations: Urban taxi trips logging implied velocities exceeding 100 mph (often GPS drift or corrupt timestamps).
Billing corrections & disputes: Trips with negative fares or negative tip amounts.
Zone boundary mismatches: Trips with missing or non-existent zone IDs.

2. Preventing Data Leakage (The Competition Trap)

A common mistake in ML hackathons is data leakage. If you leak post-trip information into an upfront prediction model, your leaderboard score looks amazing, but your model is completely useless in production.

Chronological Holdouts vs. Random Splits

Random train_test_split on time-series mobility data is fatal—it allows models to learn from the future to predict the past. We enforced strict chronological partitioning:

Training Period: 9 months of historical data
Validation Period: 2 months of subsequent data
Testing Holdout: Final future month (never seen during feature extraction or tuning)

Pre-Trip Only Features

For our Upfront Fare and Duration models, we restricted feature engineering strictly to information available before the passenger steps into the vehicle:

Cyclical Temporal Encodings: sin(2π * hour / 24) and cos(2π * hour / 24) to preserve diurnal continuity (midnight connects smoothly to 1 AM).
Historical Zone Congestion: Rolling 4-week historical pickup velocity per zone pair.
Surge Multipliers: Real-time demand-to-supply ratio proxy computed dynamically.

3. The Supervised Modeling Tournament

We benchmarked multiple architectures across our holdout test set to select the optimal production model:

Model Architecture	Fare R²	Fare RMSE ($)	Duration R²	Duration RMSE (min)	Inference Latency
Ordinary Least Squares (OLS)	0.812	$7.14	0.621	9.85 min	0.8 ms
Random Forest Regressor	0.941	$4.12	0.789	6.94 min	45.2 ms
LightGBM Regressor (Winner - Fare)	0.9657	$3.25	0.8142	6.55 min	2.1 ms
XGBoost Regressor (Winner - Duration)	0.9612	$3.41	0.8268	6.39 min	3.4 ms

Why Gradient Boosting Triumphed

Gradient boosting trees handled the non-linear relationship between Manhattan distance, toll zones, and peak-hour traffic multipliers effortlessly. LightGBM provided lightning-fast inference with sub-cent precision, while XGBoost effectively captured the heavy-tailed variance in urban traffic delays.

4. Spatio-Temporal Forecasting & Origin-Destination Corridors

Urban mobility is heavily spatial. Having accurate pricing is only half the battle; fleet operators must know where demand will surge 24, 48, and 72 hours in advance.

Autoregressive Lag-Based Forecasting

We aggregated zone-level trip demand into hourly buckets and engineered multi-scale temporal lag features:

Immediate Autoregressive Lags: t-1, t-2, t-3 hours.
Diurnal Seasonality Lags: t-24, t-48, t-72 hours (same hour over preceding days).
Weekly Seasonality Lags: t-168 hours (same day and hour of the previous week).

Our forecaster achieved a test RMSE of ~1.00 to 1.22 trips/hour across all major urban zones, allowing dispatchers to pre-position fleet vehicles before surges materialized.

4 Time-Slice OD Flow Clustering

By clustering pickup-to-dropoff vectors across Morning Rush (07:00–10:00), Midday (11:00–14:00), Evening Rush (16:00–19:00), and Late Night (22:00–02:00), we revealed major commercial arterial corridors and airport shuttle dynamics, illuminating severe deadheading (empty return) imbalances.

5. From Raw Code to Executive Decision-Making

Judges at modern hackathons don't just want .ipynb files; they want to see how engineering impacts business. We translated our models into an Executive Command Center built with Streamlit:

1. The Conversational AI Mobility Assistant

We integrated a natural language interface that allows city planners and dispatch managers to ask plain-English questions:

"What are the top 5 revenue-generating pickup zones during the Friday evening rush?"

The Innovation — Ambiguity Guardrails:
Real users often ask vague questions like "Show me the best zones". Rather than letting the AI hallucinate or make unsafe assumptions, our engine implements strict guardrails that detect ambiguity and clarify whether the user intends "highest volume", "highest fare margin", or "fastest turnaround time".

2. The $51.8M ROI Financial Model

We mapped model improvements directly to bottom-line business metrics:

Deadhead Reduction: Pre-dispatching idle vehicles based on our 24h forecaster reduces empty miles by 14.2%.
Airport Reverse-Trips: Pairing drop-offs at airport terminals with immediate outbound demand captures substantial hidden margins.
Estimated Annual Network Gain: Over $51.8 Million across the city transit ecosystem.

6. Four Lessons That Helped Us Secure the Top 8

If you are competing in data science competitions or datathons, here are four principles that made the difference for Team DataMinds:

Clean Data Beats Fancy Ensembles: Spending 40% of our time auditing anomalies across the 48.6M records yielded vastly higher accuracy gains than endless hyperparameter tuning on noisy data.
Respect the Temporal Dimension: Never use standard K-fold cross-validation or random splits on temporal data. A leak-free validation strategy ensures that your local score matches real-world performance.
Build Modular, Reusable Code: We moved all logic out of messy notebooks into modular Python packages (src/data_cleaner.py, src/supervised_models.py, src/demand_forecaster.py). This allowed our notebook, test scripts, and UI to share the exact same underlying logic.
Tell a Clear Story: A technical report or dashboard should not just be a collection of charts. Frame your findings as a business narrative: Problem → Solution → Measurable Economic Value.

🏁 Looking Forward to the Finals!

Reaching the Top 8 Finalist stage among brilliant teams across the country is an incredible milestone for Team DataMinds.

A huge thank you to the SLIIT CodeFest Datathon 2026 organizers and judges for organizing such an inspiring, high-impact data challenge.

Are you building with large-scale mobility data or competing in data challenges? Drop your thoughts or questions in the comments below!

I Tackled the Planet of Lana Language Challenge by Building an AI Translator & Voice Synthesizer

Malawige Inusha Thathsara Gunasekara — Wed, 09 Sep 2026 14:26:05 +0000

I tackled the challenge in a different way, and created this project as my answer.

When the indie studio Wishfully released the official Language Companion booklet (PoL_LanguageCompanion.pdf) for Planet of Lana II: Children of the Leaf, they ended it on page 13 with an irresistible invitation to the community:

"Congratulations, you’ve reached the end of this intensive crash course in Novo Terali! We hope you’ve enjoyed learning a bit more about Lana’s native tongue, and that your understanding of Novo as a whole has deepened in the process.

Now that you are completely fluent, we would love to hear from you in your best Novo Terali! Share a short (or long!) shoutout in your new favorite language on social media and tag us @planetoflana - we can’t wait to see it!"

Most players reading that would string together three words from the mini-glossary—like "Tiai Lana!" ("Hello Lana!")—tweet it with a screenshot, and call it a day.

I couldn't stop there.

The booklet provided around 80 canonical vocabulary words, basic commands, pronouns, numbers, and a handful of translated game scenes. But how can anyone truly be "fluent" when whole swathes of everyday vocabulary and grammar are still undiscovered?

Instead of just posting a one-line tweet, I asked myself:

What if anyone could translate anything into Novo Terali? What if we could reverse-engineer the linguistic rules from the booklet, marry them with an LLM extrapolation engine, back it with an acoustic voice synthesizer, and build a living, self-healing codex that speaks the language in real time?

That question led to NovoGen — an open-source, full-stack conlang translator, speech synthesizer, and dictionary manager for Planet of Lana.

Here is the story of how it was engineered, the technical hurdles encountered along the way, and what it takes to bring a fictional language to life with modern web and AI technologies.

1. Deconstructing Novo Terali: The Lore & Linguistics

In the Planet of Lana universe, Novo Terali (literally "New Speak") was created on Earth as an accessible auxiliary language designed to unite humanity during the multi-generational Fata te Cora ("Seed and Leaf") space mission. Centuries later, on the planet Novo, survivors preserved and evolved it into the melodic dialect spoken by Lana, her sister Elo, and the villagers of Tailo.

Before writing a single line of backend code, I extracted and analyzed every rule documented in the booklet:

                  ┌──────────────────────────────────────────────┐
                  │          NOVO TERALI PHONOTACTICS            │
                  ├──────────────────────────────────────────────┤
                  │  Vowels:      a [ah], e [eh], i [ee],        │
                  │               o [oh], u [oo] (pure Italian)  │
                  │  Diphthongs:  ai, ia, ea, oa, ui (unclipped) │
                  │  Consonants:  t/d aspirated, rolled 'r',     │
                  │               'h' voiced, no silent letters  │
                  │  Stress:      Light stress on first syllable │
                  │  Rhythm:      Calm, melodic, even pacing     │
                  └──────────────────────────────────────────────┘

Morphological Patterns Discovered:

Subject-Verb-Object (SVO) sentence structure ("Ona fatum tia" = "I believe you").
Negation: Direct marker dieh placed before verbs ("Ona dieh fatum" = "I do not believe").
Agglutinative Suffixes:
- -em: Plural/verbal inflection (olai → olaiem = "go" → "did you go?").
- -ari: Agent/actor noun suffix (djimo "make" → djimari "maker/creator"; capitari "director").
- oti-: Honorific or co-prefix (oti-capitari = "co-director").
Philosophical Roots:
- Fata: Predecessor, seed, origin, parent.
- Cora: Successor, leaf, progeny, child, future.

2. Architecture Overview: Local-First Meets Cloud-Native

One core design philosophy was that NovoGen must never depend exclusively on third-party cloud APIs. If a user runs it offline without an API key, it should function seamlessly using local compute. If deployed to production, it should scale on serverless infrastructure.

                     ┌───────────────────────────────┐
                     │       Next.js App Router      │
                     │    Tailwind / Vanilla CSS     │
                     └───────────────┬───────────────┘
                                     │
                        POST /api/translate
                                     │
                     ┌───────────────▼───────────────┐
                     │   In-Memory Rate Limiter      │
                     │  (Sliding-Window, 30 req/min) │
                     └───────────────┬───────────────┘
                                     │
                     ┌───────────────▼───────────────┐
                     │  Multi-Tier Translation Engine │
                     └───────────────┬───────────────┘
                                     │
         ┌───────────────────────────┼───────────────────────────┐
         │                           │                           │
 1. Exact SQLite Match      2. Rule Agglutination       3. LLM Extrapolation
    (Canonical Lore DB)        (Suffixes & Modifiers)       (Gemini 3.1 / Ollama)
         │                           │                           │
         └───────────────────────────┼───────────────────────────┘
                                     │
                     ┌───────────────▼───────────────┐
                     │  Phonotactic Quarantine Guard │
                     │ (Anti-Gibberish Verification) │
                     └───────────────┬───────────────┘
                                     │
                     ┌───────────────▼───────────────┐
                     │      ElevenLabs Voice API     │
                     │    (Gigi Voice Model Tuning)  │
                     └───────────────────────────────┘

3. Challenge #1: Hallucination Prevention in Conlang Extrapolation

Because the canonical dictionary has only ~80 terms, users translating sentences like "Look at the ancient machine in the forest" require new vocabulary.

If you give an LLM free rein, it will hallucinate English words with random accents or invent sounds that violate the fictional world's phonotactics.

To solve this, I designed a multi-tier fallback system:

Tier 1 (Canonical SQLite Lookup): If an exact phrase or word exists in novo_dictionary.db (seeded directly from the companion booklet), return it immediately with is_canonical = 1.
Tier 2 (Morphological Rules): Check if the word can be constructed via known prefixes and suffixes (e.g., compounding fata or appending -ari).
Tier 3 (Constrained Generative Extrapolation): Prompt Google Gemini 3.1 Flash (or a local Ollama model like llama3.2 or mistral) using an ironclad conlang system prompt:

// System instruction excerpt enforced during translation
const CONLANG_PROMPT = `
You are the official linguistic translator for Novo Terali from Planet of Lana.
Follow these inviolable phonotactic constraints:
1. Every vowel is strictly: a [ah], e [eh], i [ee], o [oh], u [oo].
2. No consonant clusters exceeding 2 consonants; never use 'x', 'q', or 'z'.
3. Extrapolated roots MUST use open syllables (CV or CVC patterns like 'talo', 'suni', 'kora').
4. Compound from known roots where possible (e.g., 'machine' -> 'meka-fata').
5. Canonical vocabulary is SACRED: Never overwrite 'Tiai' (Hello), 'Cora' (Child/Leaf), etc.
Return strictly structured JSON containing translation, IPA phonetics, and grammar breakdown.
`;

When an extrapolated word is generated, it is tagged as extrapolated and cached in SQLite so that subsequent translations remain 100% consistent across sessions.

4. Challenge #2: The Anti-Gibberish Quarantine Guard

Once the app went online, a new vulnerability emerged: cache pollution via keyboard mashing.

If someone types "leftofkfmv" or "asdfghjkl", the LLM would dutifully attempt to coin a poetic Novo Terali term for it, saving garbage into the shared SQLite dictionary.

To combat this without adding perceptible latency, I built a two-stage Linguistic Quarantine Layer (src/lib/validator.ts):

Heuristic Phonotactic Analysis (< 0.1ms):
- Rejects repetitive character streaks (/([a-z])\1{2,}/i).
- Rejects impossible English consonant clusters (/[bcdfghjklmnpqrstvwxz]{4,}/i, exempting valid sequences like spl, str, ngth).
- Rejects vowel-less tokens longer than 2 characters.
- Rejects extreme single-word lengths (> 24 chars).
Offline English Lemma Verification (< 0.2ms):
- Loaded a curated set of 45,000 common English words into a fast Set<string>.
- Words failing both checks are rejected from the translation pipeline and logged to data/quarantine_log.json.

export function validateQuery(query: string): ValidationResult {
  const tokens = query.trim().toLowerCase().split(/\s+/);
  for (const token of tokens) {
    if (isImpossibleCluster(token) || isRepetitiveMash(token)) {
      return { isValid: false, reason: "Phonotactic violation detected" };
    }
  }
  return { isValid: true };
}

To give developers and administrators complete control, I added a dedicated Quarantine Admin Panel directly in the UI. Administrators authenticate using an ADMIN_KEY header, inspect suspicious inputs, approve verified terms into the canonical codex, or flush fraudulent entries with one click.

5. Challenge #3: Giving Lana a Voice with Acoustic Tuning

A conlang only feels alive when you can hear it spoken.

Planet of Lana features evocative, emotional voice acting. The developer notes highlighted that Italian voice actors captured the cadence best because of the open vowels and tapped consonants.

To reproduce this, I integrated the ElevenLabs Text-to-Speech API, selecting the Gigi voice model (a youthful, melodic tone) and meticulously calibrating its acoustic profile:

const voiceSettings = {
  voice_id: "Qd7hDo3tdwmASCs5vLEB", // Gigi
  model_id: "eleven_multilingual_v2",
  voice_settings: {
    stability: 0.82,          // High stability keeps Italianate vowels consistent
    similarity_boost: 0.85,   // Accurately locks to the vocal timbre
    style: 0.0,               // Neutral expressive base prevents over-dramatization
    speed: 0.85               // 15% reduction matches the calm, unhurried Novo pace
  }
};

When users click the speaker button next to any phrase, the server streams high-fidelity 44.1kHz audio in under 400ms. If ElevenLabs is not configured, the app gracefully falls back to the browser's native Web Speech API with an Italian phonetic voice profile.

6. Deployment & Cloud Hardening

To make NovoGen accessible worldwide, I packaged it as a multi-stage Docker container and deployed it to Google Cloud Run:

Container Size: Reduced using Next.js standalone output mode (output: "standalone").
Dynamic Persistence: Cloud Run containers use a stateless root filesystem. I wrote an automated bootstrap script that copies novo_dictionary.db to /tmp upon startup, granting the SQLite engine full read-write capabilities during execution.
Rate Limiting: Implemented an in-memory sliding-window limiter (src/lib/rateLimit.ts) enforcing 30 translations/min and 10 voice syntheses/min per IP to protect downstream APIs from quota abuse.
Custom Domain: Mapped to https://novogen.inusha.me backed by Google-managed SSL certificates.

7. The Result: Taking the Challenge to the Stars

Here is what the translation engine can do.

Example 1: Canonical Dialogue Match

English: "We have to stop them, Lana."
Novo Terali: "Ite o imaiem, Lana."
Breakdown: Canonical sentence from Chapter 3 of the companion guide.

Example 2: Complex Extrapolated Expression

English: "Listen to the music of the stars, little child."
Novo Terali: "Teno lo sonari de eora stel, cora."
Breakdown:
- Teno (listen) — coined root adhering to CV phonology.
- sonari (music) — derived from son (sound) + -ari (nominalizer).
- cora — preserved canonical cultural root for child/leaf.

Try It Out!

🌐 Live Web Application: https://novogen.inusha.me

To the team at Wishfully (@planetoflana): You asked us for a shoutout in Novo Terali.

Instead, I built an entire engine so the whole world can speak it:

"Ite fatum tia, Wishfully. Tiai Novo Terali!"

(We believe in you, Wishfully. Long live Novo Terali!)

Multi-Agent Gift Recommendation Engine Powered by Google ADK & Gemini

Malawige Inusha Thathsara Gunasekara — Fri, 21 Aug 2026 15:27:55 +0000

This post is my submission for DEV Education Track: Build Multi-Agent Systems with ADK.

Finding the perfect, thoughtful gift shouldn't feel like a chore.

Whether it's for a birthday, anniversary, or holiday, we all experience gift-buying paralysis:

Generic suggestions: "Just buy them a mug or a generic gift card."
Budget anxiety: Falling in love with an idea only to find out it costs 3x what you planned to spend.
Missing the subtle nuances: Forgetting that someone dislikes clutter, lives in a tiny apartment, or prefers practical experiences over physical objects.

To solve this, I built GiftAdvisor. It is an intelligent, consumer-friendly gift recommendation system built with Google Agent Development Kit (ADK), Gemini (gemini-3.1-flash-lite), and deployed seamlessly to Google Cloud Run.

Live Demo & Links

Live Cloud Run App: https://gift-advisor-1008832068452.us-central1.run.app
GitHub Repository: https://github.com/inusha-thathsara/Multi-Agent-Gift-Idea-Generator-with-Google-ADK

What I Built

GiftAdvisor transforms unstructured descriptions of a person into tailored, ranked, and strictly budget-compliant gift recommendations.

Instead of dumping everything into a single monolithic prompt, GiftAdvisor splits the cognitive load across three specialized AI agents orchestrated via Google ADK:

Profile Analyzer Agent: Understands the human behind the prompt (lifestyle, hobbies, aesthetic preferences, and explicit anti-preferences).
Idea Finder Agent: Brainstorms creative, thoughtful candidate gifts across multiple categories with estimated market prices.
Budget Filter Agent: Audits estimated prices, filters out anything exceeding the user's hard budget limit, swaps in budget-friendly alternatives, and delivers a ranked curation.

Key Highlights & Features

Pure Multi-Agent Pipeline: Built using Google ADK's LlmAgent, SequentialAgent, and InMemorySessionService.
Zero-Overhead Scale-to-Zero: Deployed to Google Cloud Run with min-instances=0 (scales to zero when idle for $0.00 base cost).
Modern Glassmorphism UI: Intuitive dark-mode consumer interface with 1-click preset profiles, interactive budget slider, and live pipeline stage tracking.
Comprehensive Export System: Export recommendations with 1 click to Markdown (.md), JSON (.json), Clipboard, or Print / Save as PDF.

Cloud Run Embed

1. Profile Analyzer Agent (`ProfileAnalyzerAgent`)

Role: Empathy & Persona Architect.
What it does: Ingests raw user inputs (e.g., "My 29yo sister loves specialty pour-over coffee and houseplants, but lives in a small apartment"). It extracts core interests, lifestyle dimensions, emotional tone, and most importantly, anti-preferences (e.g., no large items, avoid generic mugs).
ADK Output Key: recipient_profile

profile_analyzer_agent = LlmAgent(
    name="ProfileAnalyzerAgent",
    model=model_name,
    instruction="""
    You are an expert gift persona analyzer.
    Analyze the recipient's description, occasion, and relationship.
    Extract key traits, hobbies, lifestyle context, and explicit anti-preferences (what to avoid).
    Save your structured analysis to session state key 'recipient_profile'.
    """,
    output_key="recipient_profile",
)

2. Idea Finder Agent (`IdeaFinderAgent`)

Role: Creative Ideation Specialist.
What it does: Reads {recipient_profile} from the session state and ideates 6–10 candidate ideas across diverse categories (e.g., Experiential, Practical Everyday, Consumable / Artisan, Sentimental). It attaches realistic estimated market prices to every item.
ADK Output Key: candidate_gift_ideas

idea_finder_agent = LlmAgent(
    name="IdeaFinderAgent",
    model=model_name,
    instruction="""
    You are a creative gift brainstormer.
    Given the recipient profile:
    {recipient_profile}

    Brainstorm 6 to 10 distinct, creative gift ideas across multiple categories.
    For each idea, provide a realistic estimated market price.
    Save your candidate ideas to session state key 'candidate_gift_ideas'.
    """,
    output_key="candidate_gift_ideas",
)

3. Budget Filter Agent (`BudgetFilterAgent`)

Role: Financial Auditor & Final Curator.
What it does: Reads {candidate_gift_ideas}, {budget_limit}, and {currency}. It validates each candidate against the budget ceiling. Any item that exceeds the budget is logged in an Elimination Audit and replaced with a budget-friendly alternative. The agent then organizes recommendations into budget tiers (Splurge, Sweet Spot, Budget Friendly) with specific buying advice.
ADK Output Key: final_gift_recommendations

budget_filter_agent = LlmAgent(
    name="BudgetFilterAgent",
    model=model_name,
    instruction="""
    You are a meticulous gift budget auditor and curator.
    Budget Limit: {budget_limit} {currency}
    Candidate Ideas:
    {candidate_gift_ideas}

    1. Audit each idea against the budget ceiling.
    2. Eliminate items that exceed the limit and suggest budget-friendly alternatives.
    3. Present the Top 3-5 Recommended Gifts formatted into budget tiers with rationale.
    Save the final report to session state key 'final_gift_recommendations'.
    """,
    output_key="final_gift_recommendations",
)

4. Orchestration with `SequentialAgent`

Google ADK makes chaining agents intuitive using SequentialAgent. State flows from one agent's output_key directly into the next agent's prompt template variables:

gift_advisor_pipeline = SequentialAgent(
    name="GiftAdvisorPipeline",
    sub_agents=[
        profile_analyzer_agent,
        idea_finder_agent,
        budget_filter_agent,
    ],
)

Implementation & Architecture

Backend Tech Stack

Framework: Python 3.12, FastAPI, Uvicorn
Agent Framework: google-adk (Agent Development Kit v2.7.0)
Model: gemini-3.1-flash-lite (via google-genai)
Deployment: Google Cloud Run (Containerized via Docker)

Cloud Run Production Optimization

To keep running costs near $0.00 while maintaining rapid startup times:

min-instances = 0: Cloud Run spins down to zero instances when no traffic is being served.
memory = 512MiB & cpu = 1 vCPU: Lightweight footprint optimized for async FastAPI and Google ADK orchestration.
gemini-3.1-flash-lite: Ultra-fast latency with minimal token consumption.

Key Learnings

Separation of Concerns Prevents Hallucination:
When asking a single LLM prompt to analyze personality, brainstorm 10 items, and filter by budget simultaneously, it often ignores budget limits or produces bland suggestions. By decoupling Analysis -> Ideation -> Budget Auditing into separate ADK agents, each agent performs its task with significantly higher precision.
Session State is the Superpower of ADK:
Using InMemorySessionService and prompt variable injection ({recipient_profile}, {candidate_gift_ideas}) made passing structured context between agents clean, traceable, and modular.
Cloud Run + Gemini is a Perfect Match:
Deploying containerized Python agent applications to Cloud Run gives you an instant HTTPS public API with scale-to-zero economics. No idle server bills, automatic TLS certificates, and global scaling out of the box.

Conclusion & What's Next

Building GiftAdvisor with Google ADK demonstrated how accessible and clean multi-agent orchestration has become in Python.

Future Ideas

Live Search Tool Integration: Connecting Google Search grounding or SerpAPI to pull real-time e-commerce links and stock availability.
Group Gift Mode: Splitting a high-ticket budget across multiple contributors with automated per-person share calculations.

AI-Powered Calming Audio & Voice Companion for Dogs Home Alone

Malawige Inusha Thathsara Gunasekara — Sat, 15 Aug 2026 20:19:59 +0000

This is a submission for Weekend Challenge: Dog Days Edition

What I Built

Over 70% of dogs suffer from some degree of separation anxiety when their owners leave for work, errands, or travel. Symptoms include frantic barking, whining, pacing, destructive chewing, and prolonged stress spikes. Standard pet playlists on streaming platforms are static, repetitive, and lack the familiar reassurance pets crave most: their human's voice.

Paws & Peace is an intelligent, multi-platform sensory comfort system designed to give pets a peaceful home-alone experience. Available as both a modern web app and a native Android application, it combines:

Personalized AI & Owner Voice Loops: Using ElevenLabs AI Voice Synthesis, pet parents can generate warm, soothing voice messages with their pet's name, customized reassurance phrases, and fine-tuned stability and clarity. Owners can also record their real voices directly in the built-in Voice Studio.
Layered Procedural Soundscapes: Real-time synthesized pink-noise rainfall (to mask sudden doorbell and traffic sounds), a rhythmic maternal heartbeat simulator (60–70 BPM), and 432Hz harmonic drone frequencies scientifically proven to lower canine heart rates.
Intelligent Departure & Interval Loops: Paced session scheduler with configurable departure delays (e.g., starts 5 minutes after leaving) and recurring voice reassurance (e.g., repeating loving phrases every 3 minutes).
Biofeedback Breathing Visualizer: Luminous multi-ring ripple visualizer paired with live equalizers to create a tranquil visual atmosphere.
One-Tap Smart Presets: Instant audio mixes tailored for Thunder Shield, Bedtime Lullaby, Leaving Home, and Quick Nap.

Demo

Live Web Application: https://weekend-challenge-dog-days-edition-phi.vercel.app
Android Native APK: Download v2.0.0 APK

Web & Mobile Experience:

Web App: Glassmorphic, dark-mode responsive dashboard with Web Audio API procedural sound synthesis and Web Speech API fallback.
Android App: Native Jetpack Compose UI with AndroidX Media3 background foreground service that keeps soothing pets uninterrupted even when the device screen is locked.

Code

GitHub Repository: https://github.com/inusha-thathsara/Weekend-Challenge-Dog-Days-Edition---Home-Alone-Playlist

How I Built It

Building a truly effective sensory companion for dogs required blending canine psychoacoustics with modern cross-platform engineering.

1. Deep Integration with ElevenLabs AI Voice Synthesis

Voice is the strongest comfort cue for a dog. We integrated ElevenLabs' cutting-edge Text-to-Speech API to craft lifelike, warm voice tracks:

Turbo v2.5 Engine (eleven_turbo_v2_5): Upgraded synthesis to the newest ultra-low latency model (<300ms response time) with high throughput and lower credit usage.
Curated Soothing Voice Models: Selected gentle, calming voices (Rachel, Bella, Antoni, Domi, Elli) with adjustable Voice Stability (0.3 – 1.0) and Similarity / Clarity Boost (0.3 – 1.0) to achieve a soft, motherly or gentle fatherly cadence.
Auto-Retry & Rate Limit Handling: Implemented exponential backoff retry logic that catches burst rate limits (HTTP 429), waits 1.5 seconds, and transparently completes generation without failing.
Instant Audio Preview Engine: Embedded MediaPlayer (Android) and AudioContext (Web) previewers that immediately play synthesized tracks so owners can audit tone and volume before leaving.
Compile-Time Build Bridge: On Android, Gradle automatically reads VITE_ELEVENLABS_API_KEY from .env and injects it into BuildConfig, enabling zero-config out-of-the-box synthesis while still allowing user overrides in the Settings dialog.

2. Procedural Audio Synthesis (No Internet / No MP3 Loops)

Instead of streaming heavy, looping MP3 audio files:

Web: Implemented dynamic Web Audio API nodes with continuous pink noise buffers, a low-pass bi-quad filter, and an LFO oscillator for the rhythmic heartbeat.
Android: Engineered a native AudioSynthesizer using AudioTrack and direct PCM byte synthesis. This ensures zero network usage, minimal memory footprint, and infinite non-repeating acoustic variation.
Canine Acoustic Science:
- Pink Noise: Has equal energy per octave ($1/f$ spectral density), which matches canine hearing frequency curves and masks sudden acoustic triggers (thunder, sirens).
- Maternal Heartbeat: Low-pass filtered dual-pulse (lub-dub) at 65 BPM simulating a mother dog's calming presence.
- 432Hz Sine Harmonic: Calibrated sinusoidal frequency associated with parasympathetic nervous system activation.

3. Native Android Architecture (Jetpack Compose & Media3)

UI & Design System: Built with 100% Jetpack Compose and Material 3, featuring glassmorphism, responsive 50/50 segmented tab controls, custom equalizers, and glowing gradient action buttons.
Background Foreground Service: Implemented PlaybackService powered by androidx.media3.exoplayer and MediaSessionService. This ensures that even when the owner locks the phone or puts it on the counter, the soothing playlist continues running indefinitely with interactive lock-screen media controls.
State Management: Built on unidirectional Data Flow with HomeViewModel, Kotlin Coroutines, StateFlow, and Jetpack Preferences DataStore for instant persistence of pet profiles and voice preferences.

Built for dogs everywhere who deserve peace and comfort while waiting for their best friends to come home.

Production AI Dog Breed Identifier & Care Guide

Malawige Inusha Thathsara Gunasekara — Sat, 15 Aug 2026 17:38:43 +0000

This is a submission for Weekend Challenge: Dog Days Edition

Have you ever looked at a dog at the park or in an adoption shelter and wondered: "What breed is that, and what kind of care does it need?"

Meet BreedSnap, a production-grade, full-stack canine intelligence web application powered by Google Gemini Multimodal Vision AI. With just a single photo, BreedSnap instantly identifies the dog breed, scores temperament and energy traits, generates a veterinary-grade care guide, and lets you download a verified PDF breeding report with one click.

What I Built

BreedSnap transforms any canine photo into an actionable, comprehensive genetic and breed profile.

Instead of returning a simple text label, BreedSnap delivers a complete companion intelligence profile:

Instant Canine Visual Recognition: Snap a live photo using your phone's camera, drag and drop files from desktop, or test instantly with one-click canine presets (Golden Retriever, Siberian Husky, Pembroke Welsh Corgi).
Deep Breed & Heritage Breakdown: Pinpoints official breed names, historical origins, and confidence ratings with ~99% match accuracy.
5-Factor Trait & Temperament Scoring: Visual 5-point rating bars for:
- Energy Level
- Trainability & Intelligence
- Family & Child Friendliness
- Grooming Demand
- Barking Tendency
Veterinary Care Guide & Health Watchlist: Provides tailored daily exercise routines, coat maintenance frequency, dietary guidelines, adult weight/size specs, life expectancy, and a genetic health watchlist (e.g., hip dysplasia, IVDD, cataracts).
Canine Trivia & Heritage: Uncovers historical folklore and behavioral facts.
Downloadable Official PDF Report: Compiles a print-ready, high-resolution PDF certificate containing the dog's photo, visual rating bars, care matrix, and verification seal.
Voice Pronunciation: Native audio synthesis of complex breed names using the Web Speech API.
Persistent Scan History: Local storage-backed scan drawer allowing users to browse, reload, and re-export past analyses offline.

Demo

Live Application: https://weekend-challenge-dog-days-edition-nine.vercel.app
Source Code Repository: https://github.com/inusha-thathsara/Weekend-Challenge-Dog-Days-Edition---Breed-Identifier

Code

The entire codebase is open-source and available on GitHub:

Repository Link: https://github.com/inusha-thathsara/Weekend-Challenge-Dog-Days-Edition---Breed-Identifier

How I Built It

1. Architecture & Tech Stack

BreedSnap was designed with speed, privacy, and visual excellence in mind:

Frontend: Lightweight Vanilla HTML5, modern CSS3 (custom glassmorphism design system, Outfit & Plus Jakarta Sans typography, smooth micro-animations), and modular ES6+ JavaScript.
Backend API: Node.js & Express with rate-limiting middleware (express-rate-limit) to prevent API abuse and securely isolate the Gemini API key from the browser.
Serverless Ready: Native Vercel Serverless Functions (/api/identify.js, /api/status.js) and vercel.json for 1-click zero-config cloud deployments.
AI Vision Engine: Google Generative Language API (Gemini 3.1 Flash / Gemini 3.7 Flash).
PDF Engine: Client-side document compilation with html2pdf.js and CSS print media stylesheets (@media print).

2. Prompt Engineering & Structured Gemini Vision

To ensure consistent veterinary outputs, Gemini is guided with structured system instructions and responseMimeType: "application/json":

const prompt = `You are a world-class veterinarian and canine genetics expert. Analyze this dog photo carefully.
Respond strictly with valid JSON only (no markdown fencing, no backticks, no explanatory comments).

If the image clearly contains a dog, return:
{
  "isDog": true,
  "breed": "Official breed name (e.g. Golden Retriever, French Bulldog)",
  "confidence": "High (98%) / Medium (85%) / Low (60%)",
  "origin": "Country / Region of origin",
  "summary": "Engaging 2-3 sentence overview of this breed's character and heritage.",
  "temperament": ["Trait 1", "Trait 2", "Trait 3", "Trait 4"],
  "size": "Size category and typical adult weight range (lbs & kg)",
  "lifespan": "Typical life expectancy in years",
  "ratings": {
    "energyLevel": 1-5,
    "groomingDemand": 1-5,
    "trainability": 1-5,
    "childFriendliness": 1-5,
    "barkingTendency": 1-5
  },
  "careGuide": {
    "exercise": "Recommended daily exercise schedule and activity types",
    "grooming": "Coat maintenance and grooming frequency",
    "nutrition": "Dietary requirements or sensitivities",
    "healthWatchlist": "Common genetic health conditions to monitor"
  },
  "funFacts": [
    "Fascinating historical or behavioral trivia item 1",
    "Fascinating historical or behavioral trivia item 2"
  ]
}

If the image does NOT contain a dog:
{
  "isDog": false,
  "message": "A friendly, witty description of what is actually visible in the image."
}`;

3. Resilient Multi-Model Fallback Cascade

To guard against high-demand traffic spikes and quota limits, the backend implements an automatic fallback cascade across Gemini models:

gemini-3.1-flash-lite (ultra-fast latency & high throughput)
gemini-3.7-flash (deep multimodal reasoning)
gemini-3.5-flash (high-capacity fallback)

If any model encounters high demand or temporary unavailability, the request seamlessly transitions to the next model without failing the user experience.

4. Official PDF Report Generation

Rather than a simple screenshot, clicking Download PDF Report dynamically constructs a high-resolution, branded certificate offscreen, formatting:

The analyzed dog's photo
Official breed title & match badge
Visual 5-star trait rating bars
3-column care guide matrix
Health watchlist alert box
Official diagnostic verification stamp

What's Next for BreedSnap?

Multi-Dog Detection: Identifying and segmenting multiple dogs in a single group photo.
Mixed Breed Percentage Estimator: Estimating heritage percentages for rescue and cross-breed dogs.
PWA Support: Full offline caching with installable mobile home-screen capabilities.

Thank you for reading! Feel free to check out the live demo and share your feedback in the comments.

Building an Adjarian Khachapuri in Pure CSS

Malawige Inusha Thathsara Gunasekara — Sat, 15 Aug 2026 15:44:58 +0000

This is a submission for Frontend Challenge - Comfort Food Edition, CSS Art.

Inspiration

My comfort-food inspiration for this project was Adjarian khachapuri, the iconic Georgian cheese bread with a golden crust and a molten egg yolk resting in the center. It feels like a warm, homemade hug: rich, cozy, and deeply comforting. I wanted to recreate not just the look of the dish, but the feeling of it being fresh from the oven.

I love how food can be a story in itself, and this challenge gave me a chance to turn a favorite comfort dish into a tiny scene built entirely with HTML and CSS. The goal was to capture the softness of the cheese, the warmth of the crust, and the playful glow of the yolk through gradients, shadows, and subtle motion.

Demo

This project is a pure CSS illustration of an Adjarian khachapuri, built with layered shapes and gradients rather than external images or assets.

Live demo: GitHub repository

If you want to view it locally, just open the project in a browser and interact with the yolk to trigger the jiggle animation.

Journey

This project started as a simple challenge: create a food illustration using only CSS. I quickly realized that the real magic was in the details. The crust needed warmth and depth, the cheese needed softness and texture, and the yolk needed to feel glossy and slightly luxurious without relying on any images.

I spent most of my time refining the gradients and shadows to give the khachapuri a more realistic, premium look. The crust is built with warm browns and highlights to mimic baked dough, while the cheese uses soft ivory tones and subtle highlight bubbles to create a melted, creamy effect. The yolk is the focal point, and I added a small jiggle animation so the composition feels alive and playful.

One thing I’m especially proud of is the way the illustration still feels simple and clean even with the detailed shading. It stays very CSS-first, but it has enough contrast and texture to feel like a polished food shot.

I also learned how much personality can come from small design choices: the steam, the shadow beneath the board, the wobble of the bread, and even the tiny highlights on the cheese. These details make the illustration feel warm and appetizing rather than rigid or flat.

This project reminded me that CSS art is not just about drawing shapes. It is about crafting emotion. A comfortable, believable composition can do a lot with color, depth, and motion alone.

I hope to keep exploring more food-themed CSS illustrations in the future, especially ones that focus on texture and storytelling. It has been a really fun way to combine design, illustration, and front-end development.

Thanks for reading, and if you love warm comfort food as much as I do, I hope this little khachapuri made you smile.

Building a 60fps Scroll-Driven Showcase with Vanilla HTML, CSS, and GSAP

Malawige Inusha Thathsara Gunasekara — Fri, 14 Aug 2026 09:02:05 +0000

This is a submission for Frontend Challenge - Comfort Food Edition, Perfect Landing

What I Built

For this challenge, I built A World of Warmth, an editorial, scroll-driven landing page and mythic codex celebrating comfort food as a universal language of love, nostalgia, and human connection. Rather than creating a standard restaurant site or commercial meal-delivery platform, I wanted to craft an immersive digital publication that treats comfort food not merely as sustenance, but as "history served hot." The experience begins with a full-viewport hero scene bathed in warm candlelight and ambient tones, setting an intimate, candlelit tone that invites visitors to embark on a culinary journey across six continents.

To capture this spirit, the landing page is structured into six full-bleed chapter stories featuring Japanese Tonkotsu Ramen, American Baked Mac & Cheese, Indian Dal Khichdi, French Pot-au-Feu, West African Party Jollof Rice, and Mexican Pork Tamales. Each chapter weaves together origin lore, flavor profiles, and rich imagery, paired with a word-by-word scroll manifesto and an interactive infographic breaking down the real neuroscience behind why comfort food makes us feel so safe and happy.

Demo

Click on above image for the Demo. 🔝

Source Code: Github

Journey

My journey building A World of Warmth began with a clear goal: to avoid creating a simple minimum viable product and instead engineer a complete, magazine-quality web experience that wows users visually while delivering rock-solid frontend fundamentals. Throughout the development process, I learned invaluable lessons about orchestrating complex scroll-driven animations and balancing hardware-accelerated motion with robust fallback systems. Integrating GSAP ScrollTrigger taught me how to fine-tune scroll scrubbing, word-by-word text color reveals, and multi-layered image parallax without triggering layout thrashing or dropping frames. What I am most proud of in this project is the seamless fusion of high-end visual polish with lighthearted, creative storytelling. Watching the project transform from a visual editorial landing page into an interactive Mythic Recipe Codex where clicking a card reveals absurd data like 4,000-year-old eclipse bones and 420-lightyear cook times brought an unexpected layer of joy and humor to the user experience.

Thank You!

Translating Culinary Comfort into Pure CSS Art

Malawige Inusha Thathsara Gunasekara — Fri, 14 Aug 2026 07:45:45 +0000

This is a submission for Frontend Challenge - Comfort Food Edition, CSS Art.

Inspiration

Ramen is the ultimate universal comfort food: rich, layered, and crafted with meticulous attention to detail. This project set out to translate that directly into front-end architecture. Inspired by the cozy ambience of traditional Japanese ramen counters, Midnight Ramen Bar channels complex CSS gradient math, 3D transform matrices, and keyframe turbulence into a living work of digital art. By replacing every pixel of traditional image assets with native CSS vectors, the artwork bridges the gap between technical precision and pure visual comfort.

Demo

inusha-thathsara.github.io

Journey

Building Midnight Ramen Bar started with a challenge: create a photorealistic artwork using zero raster images. I deconstructed a physical bowl of ramen into distinct optical layers: ceramic bowl geometry, broth depth, submerged noodles, oil beads, artisanal toppings, and rising steam clouds.

Every texture was constructed using pure CSS primitives. Finally, I added a lightweight JavaScript presentation layer for 3D mouse parallax tracking , dynamic room lighting switches, and a live CSS wireframe inspector.

I plan to expand this into a full CSS Comfort Food Collection (like a steaming stack of pancakes with melting butter or a hot slice of pie), explore CSS Houdini Paint Worklets for procedural textures, and build an interactive 3D culinary customizer.

Thank You!