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

What I Built

GroundSignal started with one question: can the motion already happening in your pocket become useful evidence without becoming surveillance?

I built it from scratch during the Week 1 challenge window. It turns a short walk, wheelchair journey, or stroller trip into a private, inspectable surface report. The AI core is TabPFN, which is well suited to the small, personal calibration sets this problem creates—and gives me probability evidence instead of a mystery label.

A sidewalk already communicates through motion. Smooth pavement, rough patches, unstable sections, and transitions all feel different, but they also change with the person, mobility mode, device, phone placement, pace, and conditions. So GroundSignal does not pretend that one universal threshold can describe every path. It learns from surfaces the user already knows.

That is the Touch Grass idea at the center of the project: the useful data is collected while someone is actually moving through the world. Screen time is reserved for setup, review, and export.

The deployed starting screen: no account, no map, and no location collection.

The workflow is deliberately designed to keep the screen as the shortest part of the experience:

1. Choose a mobility mode and phone placement.
2. Record examples of at least two known surface types.
3. Start an audit and put the phone in a pocket, bag, or mount.
4. Move naturally while GroundSignal records motion locally.
5. Finish the audit and inspect the resulting surface signals.
6. Confirm, correct, or discard uncertain predictions.
7. Export the evidence as CSV or JSON.

During recording, Pocket Mode becomes intentionally quiet and minimal. The product should encourage the user to experience the outside world instead of staring at another dashboard.

GroundSignal is intended for walkers, wheelchair users, mobility-scooter users, parents using strollers, and anyone interested in documenting how a path physically feels.

GroundSignal is a field-observation tool—not a route-safety guarantee, navigation product, or universal accessibility rating.

Demo

Live application

Open the GroundSignal live demo

This self-playing walkthrough was captured from the deployed application. The demo motion is synthetic and visibly labeled; it is not presented as field evidence.

The application includes a Run transparent demo walk option. It creates clearly labeled synthetic motion data, allowing judges to evaluate the complete workflow without granting sensor permission or physically carrying a phone.

The transparent demo covers:

• Personal calibration data
• Overlapping motion-window analysis
• Surface predictions
• Complete probability distributions
• Confidence and abstention
• Evidence-quality warnings
• Human review and correction
• Calibration improvement using reviewed signals
• Local report persistence
• CSV and JSON evidence exports

The report keeps the model name, confidence, evidence-quality warning, route signature, and human-review controls visible together.

The production API health endpoint is also public:

GroundSignal API health

The API response identifies the active model provider as tabpfn.

Because the API currently uses Render's free compute plan, the first request after an idle period may need a short cold start. The installed PWA still has a deterministic local fallback when the hosted model cannot be reached.

Three-minute judge path

1. Open the application and notice the local ledger and privacy boundary.
2. Select Run transparent demo walk.
3. Inspect the predicted route segments, probabilities, confidence, and review queue.
4. Confirm or relabel one uncertain segment.
5. Promote the reviewed signal into the next local calibration.
6. Export the report as CSV or JSON.
7. Reload the application and confirm that the report remains in the local ledger.

Code

The complete project is open source under the MIT License:

Repository: github.com/abhijeetnardele24-hash/groundsignal

The repository contains:

• React 19 and TypeScript PWA
• FastAPI analysis service
• TabPFN model provider
• Deterministic offline baseline
• Motion-feature extraction
• IndexedDB persistence
• CSV and JSON export
• Automated frontend and backend tests
• GitHub Actions continuous integration
• Render Blueprint deployment
• Architecture, security, field-testing, and contribution documentation

How I Built It

GroundSignal is separated by a strict privacy boundary: raw motion belongs to the browser.

Raw motion stays on the device. Only bounded derived features and personal calibration labels cross the explicit analysis boundary; probabilities return for local human review.

Motion becomes bounded tabular evidence

GroundSignal listens to browser DeviceMotionEvent readings after an explicit user action. It records acceleration and rotation locally, then divides the recording into overlapping three-second windows.

Each window becomes a bounded feature vector containing interpretable measurements such as acceleration RMS and standard deviation, peak-to-peak acceleration, jerk RMS, gyroscope RMS, dominant frequency, spectral entropy, vertical and horizontal energy, and sample coverage.

Raw sensor samples are never included in an analysis request. GroundSignal also does not request or collect GPS coordinates, precise location, identity, accounts, camera data, or microphone data.

Personal calibration with TabPFN

A surface signal depends heavily on the user's device, mobility mode, phone placement, and pace. That makes this a small, session-specific tabular learning problem.

Before analysis, GroundSignal requires at least eight usable calibration windows covering at least two known surface classes.

The production backend sends only derived features and user-provided calibration labels to the TabPFN provider. The model returns predictions for:

• smooth
• rough
• unstable
• transition

Each prediction contains the complete probability distribution, not only the winning label. A prediction below the documented 0.58 confidence threshold is marked as abstained and placed into human review. GroundSignal does not silently turn uncertainty into truth.

Human judgment remains part of the model loop

A user can confirm a prediction, correct its surface label, discard an unusable window, or promote reviewed evidence into later local calibration. The correction remains visible in the exported evidence, making model output inspectable instead of presenting it as unquestionable truth.

Local-first and offline-capable

Reports, derived features, calibration evidence, and reviews are stored in IndexedDB. The local ledger has bounded retention and allows recent audits to be reopened.

The PWA includes a manifest and service worker. If the hosted API is unavailable, the frontend switches to an explicitly named offline-transparent-baseline.

The fallback is a deterministic nearest-centroid classifier. It is not disguised as TabPFN, and every exported report identifies which provider produced it.

A bounded public API

The FastAPI service applies strict schemas that reject unknown fields, request-size limits, rate limiting, model concurrency limits, an inference timeout, restricted CORS origins, and defensive browser headers.

The production service has no user accounts, file uploads, location storage, or database. The frontend and API are deployed together using a Render Blueprint, while the TabPFN token remains a private Render environment variable.

Verification

I tested the project locally and on its deployed Render environment.

Current automated verification:

• 9/9 frontend tests passed
• 12/12 backend tests passed
• Production PWA build passed
• Python dependency check passed
• Production npm audit reported 0 vulnerabilities
• GitHub Actions passed
• Render Blueprint parsed and deployed successfully

The deployed flow was also tested through the browser:

• Production API health and model card
• TabPFN analysis
• Confidence and abstention
• Human review
• Calibration promotion
• IndexedDB persistence across reload
• CSV and JSON export
• Service-worker registration
• Offline reload and transparent fallback
• CORS, request limits, validation, and security headers
• No browser-console errors during the complete demo

I kept the synthetic demo visibly labeled as simulation. I do not present generated motion as real field evidence, and GroundSignal documents physical phone testing as a separate validation step.

Why Does Open Innovation Matter?

GroundSignal handles motion that may indirectly reflect a person's mobility and environment. That made an inspectable, replaceable, and privacy-conscious architecture more important than hiding everything behind one opaque prediction endpoint.

Open innovation made four important design decisions possible:

1. The model is replaceable. The backend uses a provider interface instead of coupling the product permanently to one model. TabPFN powers the competition deployment, while the transparent local baseline preserves the workflow during poor connectivity.
2. The input boundary is visible. The repository documents every feature that may leave the device. Raw acceleration, rotation, location, and identity are excluded.
3. Uncertainty is a product feature. Access to prediction probabilities lets GroundSignal expose uncertainty directly. When the model is unsure, the interface says review.
4. Offline behavior remains useful. GroundSignal keeps its reports and calibration locally, and its fallback behavior is deterministic, labeled, and inspectable.

The project is available under the MIT License so others can audit its privacy assumptions, test alternative models, improve the feature pipeline, or adapt the instrument for different mobility experiences.

Two community perspectives reinforced these choices:

• Offline-first without a backend: building a local-first PWA you can actually trust emphasizes explicit trust boundaries, authoritative local storage, predictable service workers, and deliberate exports.
• What I Learned After Reviewing Many AI and Developer Projects as a Hackathon Judge argues that completion, evidence, documentation, privacy, and deployment readiness turn an interesting idea into a trustworthy project.

My Agent Session

I used an AI coding agent as a pair programmer during implementation, testing, security review, documentation, and Render deployment.

AI assistance helped with reviewing architecture decisions, refining implementation code, expanding automated tests, diagnosing deployment and CORS issues, testing the local and deployed applications, and improving documentation.

I reviewed the resulting work, kept the repository history visible, ran the complete test suites, and manually verified the deployed user journey.

The project does not include API keys or secrets in the repository. Any agent-session transcript will be reviewed for sensitive setup information before being made public.

Prize Categories

Best Use of TabPFN

GroundSignal uses TabPFN for a small, personal, tabular classification problem.

Each session begins with a limited calibration set representing the current user, device, placement, mobility mode, and conditions. TabPFN converts those calibration examples and derived motion features into a probability distribution across four surface-signal classes.

The project makes the result inspectable through probabilities, confidence, abstention, evidence-quality reporting, and human correction.

Best Use of Render

Render hosts the complete public application:

• A static React and TypeScript PWA
• A Python FastAPI inference service
• Automated deployment after successful checks
• Health monitoring
• Private environment-variable management for the TabPFN token
• Explicit CORS and security-header configuration

Both services are defined in a single render.yaml Blueprint, making deployment reproducible directly from the public repository.

GroundSignal uses Render as more than a place to host a landing page: Render runs the bounded inference API connecting personal calibration evidence to TabPFN.

---

GroundSignal asks people to look at the path, not the screen.

The phone becomes a small field instrument. The model stays uncertain when it should. And the sidewalk gets a chance to tell its own story.