TrustKey

TrustKey is an AI-powered real estate marketplace that instantly screens tenants using credit, criminal, eviction, fraud checks, and FBI data via APIs, then auto-scores applicants 0-100 for landlords.

Comment

TrustKey — My Hackathon Journey

Inspiration

I met the CRS (Stitch Credit) team at SF Hacks 2026, and they introduced me to their comprehensive tenant screening API. What struck me most was the realization that rental fraud and bad tenant matches cost landlords thousands of dollars annually, yet most property managers still rely on outdated, manual screening processes.

The team shared real statistics showing that:

  • $$\approx 30\%$$ of rental applications contain fraudulent information
  • $$\approx 2-3\%$$ of tenants default on rent payments annually
  • Traditional screening takes $$3-5$$ business days

I thought: What if we could automate this entire process in real-time? That's when the idea for TrustKey was born — a marketplace where sellers get instant, AI-powered tenant screening, and buyers get a seamless rental experience.

What it does

TrustKey is an AI-powered real estate marketplace with comprehensive tenant screening. Here's what happens when a buyer applies:

  1. Instant Background Check — Runs applicants through 6 screening products:

    • Fraud Finder (email, phone, IP fraud detection)
    • FlexID (identity verification)
    • TransUnion Credit (credit score, bankruptcies)
    • Criminal Background (conviction records)
    • Eviction History (prior evictions)
    • FBI Most Wanted (real-time security check)

  2. Automated Scoring — Calculates a match score out of 100: $$\text{Score} = \text{Credit} + \text{Evictions} + \text{Bankruptcy} + \text{Criminal} + \text{Fraud}$$

    • Green (80-100%) — Strong applicant
    • Yellow (60-79%) — Moderate risk
    • Red (0-59%) — High risk / FBI match = instant 0/100 hard fail

  3. Property Marketplace — Sellers list properties, buyers browse and apply, dashboards show ranked applicants with animated score meters.

  4. AI Chat Assistant — Buyers can ask questions about properties powered by Google Gemini + ElevenLabs text-to-speech.

How I built it

Architecture Overview

Frontend (React + TypeScript)
         ↓
    Vercel Hosting
         ↓
Backend (Express + Node.js)
         ↓
    Vercel Serverless
         ↓
MongoDB Atlas (Database) + External APIs

Tech Stack Decisions

Frontend:

  • React 19 + TypeScript — Type-safe component development
  • Vite 7 — Lightning-fast HMR for rapid iteration
  • Tailwind CSS — Rapid UI styling without context switching
  • React Router 7 — Seamless navigation between listing, dashboard, and application pages
  • TanStack React Query — Efficient server state management with caching
  • Tambo AI — Context-aware conversational UI that adapts based on the page and listing

Backend:

  • Express + Node.js — Lightweight, fast REST API
  • MongoDB + Mongoose — Flexible schema for storing screening results
  • Firebase Admin SDK — Secure JWT verification for authenticated endpoints

Integrations:

  • CRS Sandbox API — 5 concurrent screening products with request tracking
  • FBI Most Wanted API — Real-time public safety checks
  • Google Gemini 2.0 Flash — AI chatbot for property Q&A
  • ElevenLabs — Text-to-speech for accessible audio responses
  • Vultr Object Storage — Presigned URLs for direct-to-cloud image uploads

Key Features I Built

  1. Smart CRS Data Reuse — When the same buyer applies to multiple listings:

    • Check MongoDB for existing CRS data (avoids redundant API calls)
    • Only recalculate match score per listing's criteria
    • Result: $$\approx 60\%$$ reduction in API costs

  2. Deterministic Test Data — Used name-based hashing to select consistent test identities from CRS sandbox for repeatable demos.

  3. Optimistic UI Updates — Dashboard approves/rejects applications instantly before backend confirms (better UX).

  4. Firebase + Backend Sync — Frontend Firebase tokens verified on every API request via custom middleware.

Challenges I ran into

1. CRS API Integration Complexity

Problem: CRS API requires multiple sequential calls (Fraud Finder → FlexID → Credit → Criminal → Eviction). Each call takes 2-5 seconds.

Solution: Built pullComprehensiveReport() service that parallelizes requests using $$Promise.all()$$, reducing total time from $$\approx 15\text{ seconds} \rightarrow 3\text{ seconds}$$.

const results = await Promise.all([
  fraudFinder(),
  flexID(),
  transunion(),
  criminal(),
  eviction(),
  fbiCheck()
]);

2. FBI Most Wanted API Rate Limiting

Problem: FBI API has strict rate limits ($$\approx 100$$ requests/minute). During demos with multiple applicants, we hit limits.

Solution: Implemented Redis caching (planned for v2) + added exponential backoff retry logic with jitter.

3. Vercel Serverless Cold Starts

Problem: MongoDB connection initialization on cold starts added $$2-3$$ seconds to first request.

Solution: Implemented connection pooling and kept MongoDB connection alive between requests using a global singleton pattern.

4. Image Upload Performance

Problem: Direct file uploads to Vercel were slow and ate into serverless function time limits.

Solution: Switched to Vultr presigned URLs — frontend uploads directly to S3-compatible storage, backend only stores metadata.

5. TypeScript Type Safety with CRS Response

Problem: CRS API returns deeply nested, inconsistently structured responses.

Solution: Created comprehensive TypeScript interfaces for each CRS product and built validation middleware to catch schema mismatches early.

6. Tambo AI Context Awareness

Problem: Getting Tambo chat widget to "know" which listing the user was viewing.

Solution: Built custom thread hooks that inject current listing context into Tambo's system prompt dynamically.

Accomplishments that I'm proud of

✅ Real-time Tenant Screening — Integrated 6 screening products from multiple APIs (CRS + FBI) into a single cohesive flow.

✅ Smart Data Reuse Algorithm — Reduced API costs by $$\approx 60\%$$ through intelligent MongoDB caching.

✅ Full-Stack Type Safety — 100% TypeScript coverage on frontend, backend schemas match database models.

✅ AI-Powered Conversational UI — Tambo AI integration makes rental search feel like talking to a knowledgeable assistant.

✅ Production-Ready Deployment — Deployed on Vercel with serverless backend, MongoDB Atlas, and Vultr CDN.

✅ Comprehensive Testing — Jest unit tests + end-to-end CRS API tests covering FBI checks, score variety, and data reuse.

✅ Deterministic Demo — Built repeatable demo using famous FBI wanted persons (Cindy Singh, Byshere Smith) that consistently trigger hard fails.

✅ Team Collaboration — Built with 3 amazing teammates in 48 hours; shipped a production-ready MVP.

What I learned

  1. API Integration is an Art — Every external API has quirks. Building robust error handling, retry logic, and caching is critical.

  2. Serverless Optimization Matters — Cold starts, connection pooling, and function time limits become real constraints at scale.

  3. Type Safety Scales — TypeScript caught dozens of schema mismatches that would've been runtime errors in production.

  4. Caching is Everything — The smart data reuse feature wasn't in the original spec, but it became a key differentiator for cost efficiency.

  5. Demo Data > Documentation — Using famous FBI wanted persons made the demo 10x more memorable than explaining the scoring algorithm.

  6. Accessibility Matters — ElevenLabs TTS wasn't a "nice-to-have"; it made the product genuinely more accessible.

  7. Parallel Processing — Using $$Promise.all()$$ instead of sequential API calls reduced CRS response time from 15s to 3s — a $$5\times$$ improvement.

What's next for TrustKey

Short-term (Next 30 days)

  • ✨ Add Redis caching layer for FBI API results
  • ✨ Build admin dashboard for API monitoring and quota management
  • ✨ Implement email notifications (application approved/rejected)
  • ✨ Add more test identities for CRS sandbox demos

Mid-term (3-6 months)

  • 🚀 White-label API for property management companies
  • 🚀 Mobile app (React Native) for on-the-go screening
  • 🚀 Predictive analytics: which applicants are likely to default?
  • 🚀 Integration with Zillow, Apartments.com for broader market reach

Long-term (6-12 months)

  • 🌟 Machine learning model to refine scoring based on historical outcomes
  • 🌟 International expansion (UK, Canada tenant screening)
  • 🌟 Landlord insurance partnerships based on risk profiles
  • 🌟 Blockchain-backed screening records for portability

Built with ❤️ by Abhishek Rangani, Ayush Rangrej, Tiea Hapani, and Princy Ramani at SF Hacks 2026.

🔗 Live Demo | 📂 GitHub

Built With

  • axios
  • crs-sandbox-api
  • elevenlabs
  • express.js
  • fbi-most-wanted-api
  • firebase-admin-sdk
  • firebase-sdk
  • framer-motion
  • google-gemini-2.0-flash
  • mongodb
  • mongodb-atlas
  • mongoose
  • node.js
  • react-19
  • react-router-7
  • shadcn/ui
  • tailwind-css-4
  • tambo-ai
  • tanstack-react-query
  • typescript
  • vercel
  • vite-7
  • vultr-object-storage
Share this project:

Updates