Inspiration
Losing something important is stressful, and getting it back is mostly luck. Airports, hotels, malls and campuses all run their own lost property desks, and none of them talk to each other. If you lose a laptop on the way to your gate, you have to guess which desk has it, call or email each one, and describe it again every time. Meanwhile staff sort through shelves of unclaimed items with no easy way to find the owner.
We wanted one report to reach every participating location, and we wanted the handover to be safe. The person who gets the item back should be the person who actually lost it.
What it does
Reclaim is a lost and found network. You report something lost (or found) once, with where and when, an optional photo, and private details only the real owner would know, like a serial number or what was inside.
- Matching: AI compares descriptions, photos, places and times across participating locations and suggests possible matches with an "AI relevance" score. Every match is clearly labelled as a candidate, not proof of ownership.
- Private claims: When a match looks right, you answer private verification questions and can add evidence. Only you and authorised reviewers at the organisation holding the item can see your answers. Public listings never show serial numbers, distinctive marks or where an item is stored.
- Human review: Staff review each claim in a dashboard. AI summarises how the answers line up and flags gaps, but a person approves, rejects or escalates every claim, and the reason goes into an audit log.
- Recovery: Once a claim is approved, you either collect the item with a one-time pickup code or pay for delivery through PayPal. The delivery fee covers delivery only. It's never a reward for the finder.
- For organisations: Staff get an operations table with filters, a claim review queue, recovery tracking and Zapier events that plug into their own tools.
How we built it
We were a team of two: one of us built the backend and the other built the frontend.
- Frontend: Next.js with the App Router and TypeScript, Tailwind CSS with our own design tokens, TanStack Query for data, and AG Grid Community for the operations table.
- Backend: A FastAPI modular monolith on PostgreSQL, with a separate worker that processes AI extraction, matching and notifications from a persistent outbox, so nothing critical lives in memory.
- AI: A provider-agnostic interface for attribute extraction and match ranking, with a deterministic keyword fallback, so the app still works if the model is unavailable.
- Payments: PayPal REST APIs in Sandbox. The server creates and captures orders, checks the amount and status with PayPal, verifies webhook signatures, and uses idempotency keys so a double click can't create a second charge.
- Automation: Zapier receives signed events from our outbox. One Zap emails staff about high-priority matches, and another logs new claims to Google Sheets. Zapier can't change any claim or payment.
- Testing: A Playwright suite of 78 end-to-end tests covers permissions, claim state changes, payments, privacy and the full demo flow.
Challenges we ran into
- Keeping AI advisory: It's tempting to let a high score decide things. We designed every screen so AI suggests and people decide, and wrote that rule into the API so the frontend can't override it.
- Privacy by design: Every report had to be split into what possible matches can see and what stays private. Getting that right across listings, claims, notifications and the staff dashboard took more care than we expected.
- Trustworthy payments: A redirect back from PayPal proves nothing, so payment status only changes after the server confirms the capture or receives a verified webhook.
- Webhooks on a laptop: PayPal needs a public URL to send webhooks. Our first tunnelling tool fell through, so we switched to Tailscale Funnel to expose the API with a fixed address.
- Testing next to a live demo: Our tests reset the database, so we built a strict routine for switching between the test API and the demo API without ever exposing the reset route publicly.
- Polish under pressure: On the last day we gave the app its own visual identity, fixed dropdowns that opened on top of their own fields, and made reporting comfortable on a phone, while keeping the whole test suite green.
Accomplishments that we're proud of
- A complete flow that works from end to end: report, AI match, private claim, human approval, then collection with a one-time code or paid delivery with tracking.
- A real PayPal Sandbox payment captured and confirmed through verified webhooks, plus two live Zapier automations.
- Privacy and honesty built into the interface. Sandbox payments, the simulated courier and seeded demo data are always labelled.
- 78 end-to-end tests, all passing.
What we learned
- Trust is a product feature. Clear labels like "not proof of ownership" and "a person decides" matter as much as the matching itself.
- Building the backend as the single source of truth made the frontend simpler. The API tells each screen which actions are allowed, so permission rules live in one place.
- A transactional outbox makes integrations safe. If Zapier or email fails, the core workflow carries on and the event can be retried.
- Good end-to-end tests let us make big visual changes on the last day with confidence.
What's next for ReClaim
- Connect real courier APIs to replace the simulated tracking.
- Validate and tune match scores on real lost property data.
- Add QR codes for pickup, email and SMS notifications, and notification preferences.
- Build organisation onboarding, team and location management, and a network-wide view for administrators.
- Run pilots with an airport, a hotel and a campus to see how staff use it day to day.
Built With
- ag-grid
- alembic
- docker
- fastapi
- lucide
- nextjs
- node.js
- paypal
- postgresql
- pydantic
- python
- radix-ui
- react
- shadcn-ui
- sqlalchemy
- tailscale
- tailwindcss
- tanstack-query
- typescript
- uvicorn
- zapier