Project Info

MealPing - Local Food Rescue Network

Inspiration

MealPing started with one simple question: what happens when usable food is left after service, but a nearby NGO does not know it exists? Food waste is often treated as only a food problem. While working on this idea, I kept coming back to the coordination problem behind it. A restaurant may have food ready now. An NGO may have the capacity to collect it. But they may not have a clear, trusted way to find each other in time. I wanted to build a product that focuses on that one local handoff.

What it does

MealPing connects food businesses with nearby verified NGOs so surplus food can be collected before it becomes waste. Food partners can create a post with food type, quantity, pickup window, and pickup location. Suitable verified NGOs can view available food based on location, pickup radius, capacity, food preference, and availability. An NGO can accept a post and coordinate the next step. MealPing also includes an admin workflow for reviewing and verifying food partners and NGOs. This keeps the network more accountable than a public listing board. Location access is optional. When it is available, it supports more accurate matching. When it is not available, MealPing falls back to the local pickup area and pincode details entered by the organization. AI in the product MealPing includes an optional AI helper that turns rough food notes into a clearer donation draft and handoff summary. The AI does not decide who can receive food, verify an organization, or replace the manual workflow. People still make the important decisions. If the AI helper is busy or unavailable, users can continue with the regular form.

How we built it

I am primarily a UI developer with Angular experience. I led the product idea, user journeys, responsive frontend, visual design, and testing. I built the frontend with Angular, TypeScript, SCSS, PrimeNG, and GSAP. Supabase provides authentication, PostgreSQL data storage, role-based access rules, and Edge Functions. PostGIS supports the location-based matching logic. For areas where I had less experience, including backend logic, database structure, security rules, and deployment, I used GPT-5.6 as a development collaborator. It helped me understand unfamiliar areas, compare approaches, and turn an idea I had been thinking about for a long time into a working product. I tested the key workflows myself and made the final product and UX decisions.

Challenges we ran into

The hardest part was building a product that works beyond attractive screens. First, trust matters. Food partners and NGOs need clear verification and visible status before they coordinate a pickup. I added a manual admin review flow instead of treating every new account as trusted. Second, location is not always perfect. Users may decline location permission or enter incomplete details. MealPing handles this by using precise location when it is available and a pincode and local-area fallback when it is not. Third, AI reliability matters. Free-tier AI limits and temporary API errors can happen. I designed the AI helper as an optional assistant, with a manual form that always remains available.

Accomplishments we're proud of

Built MealPing, an end-to-end platform connecting food donors with verified NGOs through a structured, trust-based system. Developed both frontend and backend features, including location matching, role-based access, and verification mechanisms. Expanded beyond UI into backend and deployment, using AI as support while maintaining full control over design and functionality.

What we learned

I learned that a useful product is not only about its interface. It also needs clear roles, fallbacks, safe defaults, and practical next actions. I also learned that AI is most useful when it removes small friction without becoming a single point of failure. In MealPing, AI helps prepare information, while people and verified organizations remain responsible for the actual handoff.

What's next

The next step is to pilot MealPing in one local area with a small group of verified food partners and NGOs. The goal is to learn from real handoffs, improve verification and pickup coordination, and prove a repeatable local rescue loop before expanding to more areas.

MealPing

Ping surplus. Rescue meals.

MealPing is an AI-assisted food-rescue network for Food Partners, NGOs and network operators. A restaurant can photograph or type a surplus-food description; AI structures it; a person confirms it; AI can prepare a human-reviewable pickup handoff brief; deterministic rules rank eligible nearby NGOs; and both organizations track pickup and delivery.

This repository is an Angular 21 + PrimeNG 21 hackathon MVP. It starts in demo mode with synthetic Mumbai–Thane data and no paid services.

Run locally

npm install
npm start

Open http://localhost:4200. Useful demo routes:

/partner/dashboard — Food Partner workspace
/partner/donations/new — typed description → AI extraction → confirmation → publish
/ngo/dashboard — ranked rescue opportunities
/ngo/opportunities/MP-24071 — acceptance flow
/ngo/rescues/MP-24071 — pickup OTP and delivery flow
/admin/dashboard — live network operations

Every workspace route is login-protected. Use the role-specific login tabs with:

Workspace	Email	Password
Food Partner	`partner@mealping.demo`	`mealping123`
NGO	`ngo@mealping.demo`	`mealping123`
Admin	`admin@mealping.demo`	`mealping123`

Each account can open only its own workspace. The registration form also creates a reusable local account in demo mode. When Supabase is configured and demoMode is disabled, login and registration use Supabase Auth instead.

Hackathon judge accounts

The hosted Supabase demo includes three intentionally fake, ready-to-test accounts. They are for product review only — do not use them with real people, food, or personal information.

Workspace	Email	Password	What a reviewer can check
Food Partner	`partner.demo@mealping.test`	`Demo@MealPing26`	Verified restaurant workspace and surplus-food posting
NGO	`ngo.demo@mealping.test`	`Demo@MealPing26`	Verified NGO workspace, opportunities and rescue workflow
Network Admin	`admin.demo@mealping.test`	`Demo@MealPing26`	Organization review and network operations

The partner and NGO profiles use fictional Thane data and are already verified so reviewers can reach the main product flows immediately. The seed steps are retained in supabase/hackathon-demo-accounts.sql for a fresh Supabase project.

What is implemented

Premium responsive public site, authentication and registration screens
Role-specific desktop sidebar and mobile bottom navigation
Login guards, role authorization, persisted sessions and logout
Partner dashboards, multi-step donation flow, details, history, outlets and profile
NGO opportunities, transparent matching reasons, acceptance, pickup and delivery
Admin network health, organizations, donations, matches, exceptions and rule settings
PWA manifest/service-worker configuration
Supabase schema with Row Level Security policies
Secure Supabase Edge Function for Gemini extraction and NGO-ready handoff briefs
Demo services that make the full product story usable before backend setup

Connect Supabase and Gemini

In the Supabase SQL editor, run supabase/schema.sql, then run supabase/launch-readiness-migration.sql, then run supabase/organization-resubmission-migration.sql. These add recorded admin reviews, read-state for notifications, missed-pickup handling, organization profile editing, and suspended-account resubmission.
The included environment files already point to the MealPing Supabase project. For a different project, change only the URL and anon key in both src/environments/environment.ts and src/environments/environment.prod.ts. Production builds automatically use environment.prod.ts.
Keep the Gemini key server-side and deploy the AI function:
```
supabase secrets set GEMINI_API_KEY=your_gemini_key GEMINI_MODEL=gemini-3.5-flash
supabase functions deploy extract-donation
```
AI is an assistive shortcut, never a requirement: people can continue with the manual form whenever Gemini is busy or unavailable. The handoff brief summarizes confirmed pickup facts, flags missing operational information, and drafts a coordination message. It never certifies food safety, approves an organization, or chooses the receiving NGO.

The extract-donation deployment must be refreshed after pulling code changes; it handles both form extraction and the AI handoff brief. The product labels this helper as a pilot and keeps the manual workflow available at every point.
Schedule deadline housekeeping so expired posts are closed even when nobody has the website open. No Edge Function deployment is needed for this option:
- In Supabase, open Integrations → Cron (or Cron → Jobs).
- Choose Create job, name it expire-donations-every-5-minutes, and set the schedule to */5 * * * *.
- Choose Database function, then select refresh_expired_donations and save.
The included expire-donations Edge Function is only an optional alternative for an external scheduler; you can ignore it for now.
GPS pins are optional. When a user allows location access, MealPing stores only the coordinates for distance matching; the user still enters and confirms their address, city, state and pincode.

The Supabase anon key is intended for browser use when Row Level Security is enabled. Never put the Supabase service-role key or Gemini key in Angular environment files.

Matching boundary

AI only extracts fields and identifies missing details. It never declares food safe and does not choose the receiving NGO. Matching should remain deterministic and auditable:

Filter by verified status, service radius, food policy, capacity and pickup window.
Rank eligible NGOs by configurable distance, timing, reliability and fairness weights.
Alert in ranked waves and record every outcome.

Before a real pilot, complete legal review, food-safety policy, organization verification, consent and incident-response procedures.

Analysis

Compare with all teams

View

Metric

Jitu
1

Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.

Technology

Found in codeClaimed only

AngularIn code
HTMLIn code
SQLIn code
SupabaseIn code
TypeScriptIn code
Google GeminiClaimed
PostgreSQLClaimed

5 of 7 appear in the indexed code. 2 claimed on Devpost could not be matched to code, which may simply mean the tool leaves no trace in the repository.

AI coding agents

No AI coding agent signals were found in this repository.

Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.

Codebase size

Source size

262 KB

Source files

Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.