DEV Community: Saurabh Kumar

EchoTrail: The Invisible Bird Guide — Offline On-Device Bird Song Classifier for the Trail

Saurabh Kumar — Fri, 09 Oct 2026 20:46:46 +0000

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

What I Built

I built EchoTrail: The Invisible Bird Guide—a completely offline-first, on-device AI bird sound identifier and observation companion designed specifically to get you off the screen and into the woods.

Birdwatching is one of the most rewarding ways to disconnect from daily digital noise and immerse oneself in nature. But for beginners standing on a wooded trail, hearing an unfamiliar call in the canopy often leads to frustration:

You hear it, but you don't know what it is or where to look.
Backcountry connectivity is nonexistent: Most commercial identification apps stream audio to cloud servers. The moment you step into a state park, dense forest, or mountain trail, they fail completely.
Screen fixation defeats the point of being outside: Many nature apps treat wildlife like a gaming checklist, keeping your face glued to the glass.

EchoTrail flips this paradigm with a 5-step nature discovery workflow:

flowchart LR
    A["🌲 Listen\n5–10s Trail Recording"] --> B["⚡ Identify\nOn-Device Local AI"]
    B --> C["🎧 Compare\nNative Reference Calls"]
    C --> D["👁️ Spot\nActionable Canopy Clues"]
    D --> E["📓 Discover\nPrivate Field Journal"]

Listen: One tap records 5–10 seconds of ambient birdsong directly on the trail.
Identify Locally: An on-device acoustic classifier analyzes spectral and harmonic profiles locally in under a second—completely offline with zero internet required.
Compare with Reference Calls: Listen to authentic audio reference calls for each candidate directly on-device to confirm subtle pitch and timbre differences with your own ears.
Actionable Spotting Clues: EchoTrail provides practical field observation guidance—where in the canopy the species perches, peak activity hours, and diagnostic behavioral habits.
Private Field Journal & Challenges: Save observations to a private local SQLite database with hearing vs. spotted confirmation, and complete outdoor challenges (First Song Identified, Canopy Explorer, Morning Chorus).

Demo

Direct Standalone APK Download: Download echoTrail.apk
EAS Build Dashboard & QR Code: Expo Build 4b6670a1

Code

The entire project is open-source under the MIT license:

Dev-Saurabh-K / echoTrail

Hacktoberfest dev challenge week 1

Welcome to your Expo app 👋

This is an Expo project created with create-expo-app.

Get started

Install dependencies
```
npm install
```
Start the app
```
npx expo start
```

In the output, you'll find options to open the app in a

development build
Android emulator
iOS simulator
Expo Go, a limited sandbox for trying out app development with Expo

You can start developing by editing the files inside the app directory. This project uses file-based routing.

Get a fresh project

When you're ready, run:

npm run reset-project

This command will move the starter code to the app-example directory and create a blank app directory where you can start developing.

Other setup steps

To set up ESLint for linting, run npx expo lint, or follow our guide on "Using ESLint and Prettier"
If you'd like to set up unit testing, follow our guide on "Unit Testing with Jest"
Learn more…

View on GitHub

GitHub Repository: https://github.com/Dev-Saurabh-K/echoTrail

How I Built It

EchoTrail is built with React Native, Expo SDK 57, TypeScript, and NativeWind:

graph TD
    subgraph UI ["User Interface (Expo Router & NativeWind)"]
        Record["Record Screen (AudioWaveform)"]
        Results["Results Screen (CandidateCard & ConfidenceBadge)"]
        Species["Species Detail (ReferenceAudioPlayer & Clues)"]
        Journal["Field Journal (ObservationCard)"]
        Challenges["Challenge Dashboard"]
    end

    subgraph Core ["Local Core Engine"]
        Audio["Audio Capture & Quality Validation (SNR/Duration)"]
        Classifier["On-Device Bird Classifier"]
        DB["Local Database (expo-sqlite)"]
        Engine["Idempotent Challenge Engine"]
    end

    Record --> Audio
    Audio --> Classifier
    Classifier --> Results
    Results --> Species
    Results --> DB
    DB --> Journal
    DB --> Engine
    Engine --> Challenges

1. Robust Acoustic Validation & Uncertainty Communication

Real outdoor environments are full of wind buffeting, rustling foliage, and ambient river sounds. EchoTrail incorporates strict input validation:

Duration Checks: Enforces a minimum 2.0s recording window to ensure sufficient acoustic evidence.
Silence & SNR Thresholding: Rejects inaudible or below-threshold (-50dB SNR) recordings with actionable guidance instead of hallucinating.
Transparent Uncertainty: When noise is high or scores are close, EchoTrail transparently labels predictions as "Uncertain" with explanatory notes rather than guessing.

2. Embedded Database & Privacy

Observations are stored in local SQLite tables (observations, challenges, species_metadata) using expo-sqlite. Users have complete control to review, export, or permanently erase all recorded audio and observation history directly from the settings tab.

3. Automated Verification Suite

We engineered an automated test suite (npm test) validating:

Species catalog integrity and attribution
Audio duration and silence rejection
Prediction ranking and candidate formatting
Uncertainty communication under adverse acoustic conditions
Idempotent challenge progression and duplicate award prevention

Why Does Open Innovation Matter?

For a project built for trails and backcountry exploration, open-source, on-device AI wasn't just an implementation choice—it was the only architecture that made sense:

True Backcountry Independence: Real trails don't have cell towers. Closed-source APIs that require streaming uncompressed audio to cloud servers break the moment you enter deep woods. By running inference locally on-device, EchoTrail works anywhere on Earth—from remote national parks to deep mountain canyons.
Strict Location & Audio Privacy: Nature observation logs can reveal sensitive habitats and personal movement patterns. With EchoTrail, no audio recordings, location coordinates, or device telemetry ever leave your device.
Screen Minimization: Commercial apps optimize for ad views and engagement time. Open innovation allowed us to build an app designed to do the exact opposite: make the phone the shortest part of the experience so your eyes stay on the canopy.
Zero Ongoing Infrastructure Costs: Because inference runs on the user's phone, the app costs zero dollars in ongoing API tokens or cloud GPU servers to operate.

My Agent Session

We leveraged Antigravity and DevRelay during our hacking session to architect the on-device acoustic pipeline, package the Android APK on EAS, and verify test suites:

Building & Packaging EchoTrail: Offline AI Bird Guide with EAS Android Build

You

build the apk for android and submit it to devrelay hacktoberfest week 1 dev challenge

Agent

Configuring Android EAS build, verifying test suite, initializing EAS cloud project, and preparing submission article for Hacktoberfest Week 1.

▸ eas_build npx eas-cli build -p android --profile preview

Input

npx eas-cli build -p android --profile preview

Output

Build finished successfully: https://expo.dev/artifacts/eas/VDI8UsbhoH4rqVw1aV301HPV9fOnDO5NQU74smfohTg.apk

Field Test Reflection

Taking EchoTrail outside into the morning air transformed a routine walk into an interactive field safari. Hearing a crisp, whistling series of notes in an oak tree, recording a 6-second sample, and having the on-device engine instantly rank the American Robin with reference audio confirmed the call without ever having to unlock cell data. Best of all, reading the spotting clues ("Listen for robin cheer-up, cheerily song; look at ground level in open lawns or mid-canopy perches") allowed us to look up, locate the bird with binoculars, and log a confirmed spotting into our journal.

That is the essence of Touch Grass—technology stepping out of the way so nature can take center stage.

FamilyVault: An Offline-First AI Document Safe Built for My Parents

Saurabh Kumar — Sun, 04 Oct 2026 17:54:17 +0000

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

What I Built

I built FamilyVault for my parents.

Like almost every household, my family has a chaotic physical drawer and a messy desktop folder filled with years of paperwork: health insurance cards, tax returns, hospital discharge summaries, birth certificates, and academic marksheets.

A few months ago, when my dad was dealing with an urgent insurance claim and a visa renewal around the same time, we hit two major headaches:

Finding the exact policy rider clause took hours of frantic digging through scanned PDFs.
A subtle typo in a date of birth between an old identity document and a newer certificate almost derailed an official application.

When I showed him cloud-based OCR tools and commercial AI assistants that could search through documents, his immediate reaction was: "I am not uploading our family's passports, tax files, and medical histories to some company's remote servers."

He was completely right. Organizing family documents shouldn't require surrendering your family's privacy.

Together with my teammate Rajnishant Kumar, I built FamilyVault—an offline-first, zero-cloud desktop digital safe for family documents. It runs multimodal AI and discrepancy detection directly on an ordinary laptop, ensuring not a single byte ever leaves the computer.

What it does for them:

Smart Drag-and-Drop Ingestion: When my parents drop in a scanned bill, ID, or PDF, local OCR and vision models automatically determine the document type, family member, issuing authority, and dates.
Cross-Document Contradiction Engine: It extracts atomic facts (legal names, dates of birth, policy numbers) across all files in the vault. If an Aadhaar card and a marksheet have conflicting date-of-birth spellings, FamilyVault flags it side-by-side with citations before an official government or visa application gets rejected.
Natural-Language Search with Exact Citations: My dad can ask questions like "What is the deductible on our ICICI health policy?" and get an answer backed by direct, clickable snippets from the original document.
Bank-Grade Local Security: Everything is locked on-disk with AES-256-GCM envelope encryption, Argon2id key derivation, and SQLCipher.

When I handed the build over to my dad and showed him the search and contradiction engine flagging a birthdate discrepancy entirely with the Wi-Fi turned off, his first words were: "Finally, something that actually respects where our data lives."

Demo

Live Download & Web Landing: https://hactober-fest-family-vault-download.vercel.app/

Code

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

Dev-Saurabh-K / family-vault

FamilyVault - AI powered local end to end encrypted vault which uses power of gemma4 e2b to power vault.

FamilyVault

FamilyVault is a Windows desktop application for keeping family documents in a password-protected, portable vault. It stores original documents as encrypted objects, preserves document history, and provides local extraction, search, expiry tracking, and document-grounded assistance.

The vault is designed to remain usable independently of the installed application. FamilyVault is intended to work offline; optional model provisioning requires an internet connection to download the local AI runtime and model.

What it does

Creates, opens, locks, and restores password-protected .vault folders.
Imports PDF and image documents and stores originals encrypted.
Keeps document versions and an audit history; importing a newer version does not overwrite the prior one.
Extracts document text locally, proposes metadata for review, and tracks expiry dates.
Searches document metadata and text, with a separate semantic search mode.
Answers questions from retrieved document content using local inference when the local model is available, with citations where available.
Builds and…

View on GitHub

GitHub Repository: https://github.com/Dev-Saurabh-K/family-vault

How I Built It

FamilyVault is built with Electron, JavaScript, SQLite / SQLCipher, and open-weight AI runtimes:

1. Local Open-Source AI Architecture

Gemma 4 (Open-Weights Inference): We used Google's open-weight Gemma 4 (Gemma-4-E2B quantized GGUF) running locally on-device. The model is supervised via a local llama-server process bound exclusively to 127.0.0.1.
Grounded Document Q&A: We engineered a deterministic retrieval pipeline. Retrieved document chunks pass through our local embedding search, and Gemma 4 generates responses strictly constrained to cite document line numbers, eliminating hallucinations.
Local OCR: Text extraction is handled by Tesseract.js in background worker threads, allowing offline scanning without needing cloud OCR APIs or large Python runtime dependencies.

2. Contradiction & Verification Pipeline

Rather than blindly trusting an LLM with critical legal numbers, we treat AI extractions as untrusted suggestions. Extracted entities pass through deterministic regex and schema validators before entering SQLite. A discrepancy detection module then runs cross-record diffs across family profiles to highlight conflicting facts.

3. Sandboxing & Zero-Network Guarantee

The Electron frontend runs under a strict Content Security Policy (CSP) with remote network requests disabled. All database operations and cryptographic operations (Argon2id + AES-256-GCM) execute in isolated preload processes.

Why Does Open Innovation Matter?

For a project like FamilyVault, open-source AI wasn't just a technical preference—it was the only viable path.

True Privacy Requires Open Weights: Closed APIs (like commercial cloud LLMs) require streaming sensitive personal identifiers, bank statements, and health records over the wire to third-party data centers. Open weights allowed us to download the intelligence once and run it indefinitely inside a local sandbox.
Offline Resilience: Emergency hospital visits or international travel often involve spotty or nonexistent internet. Because open models run on-device, FamilyVault works 100% offline.
No Subscription or Token Tolls: Managing family paperwork is a lifelong chore. Families shouldn't have to worry about monthly API subscription bills or rate limits just to look up an old vaccination record or tax form.
Transparency & Auditability: In security-critical personal software, open source means anyone can audit the code to verify that documents are never phoned home.

My Agent Session

We leveraged Antigravity and DevRelay during our hacking session to architect the cryptographic envelope, refine the local llama-server process lifecycle, and verify unit test suites.

Prize Categories

Featured Prize Category: Best Use of Gemma ($200)

FamilyVault uses Google Gemma 4 as the core intelligence engine for on-device document understanding and grounded natural-language querying. By bundling a quantized Gemma 4 model via local llama-server, we achieved sub-second inference on ordinary consumer laptops with zero data leaving the machine, proving that modern generative AI can be brought directly to private family data without cloud compromise.

Team Members

Saurabh Kumar (@dev-saurabh-k)
Rajnishant Kumar (Teammate)

Built GitOCX — an AI-powered GitHub repository analysis platform.

Saurabh Kumar — Thu, 01 Oct 2026 06:17:02 +0000

What I Built

I built GitOCX, an AI-powered developer tool that analyzes GitHub repositories to help developers understand how a project evolves and how development knowledge is distributed across a codebase.

GitOCX analyzes repository commit history and uses AI to group related commits into meaningful features. It then provides insights into contributor activity and the areas of the project different contributors have worked on.

The idea came from a simple problem: a GitHub repository can contain hundreds or thousands of commits, but the commit history alone doesn't always provide a clear picture of how the project evolved.

We wanted to transform that raw history into something more meaningful — showing what features were developed, who contributed to them, and where development knowledge is concentrated within the project.

One of our biggest challenges was the cost of AI processing. Analyzing large repositories can require significant token usage, and repeatedly sending the same repository data to an AI service is both expensive and inefficient.

To address this, we implemented caching for analyzed repository data, allowing us to reuse previous results instead of unnecessarily processing the same information again.

Building GitOCX gave me practical experience with GitHub APIs, AI-powered analysis, backend architecture, caching, data processing, and building developer-focused tools.

🔗 GitOCX: https://explorers-wheat.vercel.app/

💻 Source Code: https://github.com/Dev-Saurabh-K/Explorers

Demo

Explore the deployed version of GitOCX:

🔗 https://explorers-wheat.vercel.app/

Partner Technologies

GitOCX uses AI as a core part of its repository-analysis workflow.

We use AI to analyze commit information and categorize related commits into meaningful features. This allows GitOCX to move beyond simply displaying a repository's commit history and instead extract higher-level information from it.

One of the main engineering challenges was controlling AI usage and keeping the system efficient. Since processing repository data can require many tokens, we introduced caching to avoid repeatedly sending the same information for analysis.

This gave us hands-on experience designing an application where AI is integrated into a larger backend system rather than being treated as a standalone feature.

Hackathon Experience

The hackathon was an opportunity to take an idea from a rough concept to a working product within a limited amount of time.

One of my biggest takeaways was the importance of planning before implementation. GitOCX required multiple pieces to work together — GitHub APIs, backend services, AI processing, caching, and the frontend. Thinking through the architecture and workflow before implementation helped us avoid unnecessary rework later.

We also faced the realities of building under a deadline: debugging unexpected issues, changing our approach when something didn't work, and working late to get the project into a usable state.

Beyond the technical experience, the project taught me a lot about team management, dividing work effectively, communicating ideas, and turning a complex idea into something that can actually be built.

The most valuable part was seeing a real GitHub repository go through our system and come out as structured, understandable information instead of just a long list of commits.

GitOCX started as an idea about understanding repository history, but building it gave us a much deeper understanding of AI engineering, backend systems, caching, collaboration, and product development under constraints.

GitOcx

Saurabh Kumar — Wed, 30 Sep 2026 09:42:37 +0000

GitOcx

AI-powered GitHub documentation and knowledge analysis for development teams.

Inspiration

As our projects grow, we often face a problem: one developer builds a feature, but other developers need to spend a lot of time understanding how it works before they can use or extend it.

This becomes even harder when a developer leaves the team.

We wanted to build a tool that could automatically understand a codebase and make its knowledge easier to share.

What it does

GitOcx connects to a GitHub repository and analyzes its commit history.

It uses AI to:

Group related commits into individual features
Generate documentation for each feature
Explain how features work and how they can be integrated
Identify features where knowledge is highly concentrated around one developer
Highlight features that may be at risk if a key developer becomes unavailable

For example, GitOcx can turn multiple commits into a "Payment Integration" feature, then generate documentation that helps another developer understand and use it.

How we built it

We built GitOcx with React.js and FastAPI.

PyGithub is used to retrieve GitHub repository data. LangChain and Gemini power the AI analysis.

We use SQLite for storing project data and deployed the application using a VM and Vultr.

Because AI analysis can be expensive and difficult to scale, we also added repository caching to reduce repeated AI processing.

Challenges

One of our biggest challenges was the cost of repeated AI calls.

Large repositories can contain a lot of commits and information, so sending the same data to an AI model again and again is expensive.

We solved part of this problem by caching analyzed repository data.

What we learned

We learned that understanding a large codebase is not only about reading code. A project also contains knowledge about how its features work and how those features connect.

We also learned the importance of planning before execution, proper research, documentation, and teamwork during a 36-hour hackathon.

What's next

We want to improve the quality of the generated documentation and explore job sequencing to help identify suitable developers who could take over a feature when a core team member is unavailable.

Built With

React.js, FastAPI, SQLite, PyGithub, LangChain, Gemini, VM, Vultr

Links

Demo: https://explorers-wheat.vercel.app/

GitHub: https://github.com/Dev-Saurabh-K/Explorers