Dwelligence - Smart Real Estate Search Powered by Geospatial Intelligence

Inspiration

Have you ever fallen in love with an apartment listing, only to realize the commute to your workplace would be a nightmare? I've been there. Juggling multiple browser tabs between Zillow and Google Maps just to figure out if a property actually fits my lifestyle.

The problem became crystal clear: Finding the right home shouldn't require becoming a data analyst. You're not just picking a property, you're choosing where you'll spend hours commuting each week, where you'll grab coffee before work, where you'll decompress at nearby parks. Current real estate platforms completely miss this context.

Dwelligence was born from this frustration. I set out to build the property search platform I wish existed, one that understands your lifestyle and helps you find homes that actually work for how you live.

What it does

Dwelligence reimagines real estate search by putting commute intelligence and lifestyle context at the center.

Core Experience

Set Your Workplace - Tell Dwelligence where you work, and it shows you what matters: how long it takes to get there
Choose Your Transport Mode - Drive, bike, transit, or walk - see commute times instantly update across all listings
Explore the Map - Properties display real commute times, not just addresses. Routes visualize on the map as you explore
See Nearby Amenities - Properties are joined with open-source POI data to give users an understanding of nearby amenities to a listing.
AI-powered results- Ask Gemini for any specifics on nearby amenities, and for specific queries tailored to your home-seeking criteria.

AI-Powered Discovery

Ask in plain English: "Show me 2BR apartments near parks under $2500"

The Gemini AI integration:

Parses your natural language query into structured filters
Understands lifestyle preferences (amenities, commute priorities)
Ranks properties intelligently based on your specific needs
Clarifies ambiguous requests ("nearby" by car or on foot?)

Neighborhood Intelligence

Click any property to explore what's actually nearby:

Amenity Visualization - See parks, cafes, grocery stores, transit stops plotted on the map
Transport-Aware Proximity - Results adjust based on whether you're walking, biking, or driving
Ask AI About Neighborhoods - "Are there any coffee shops nearby?" returns top-rated places with photos, hours, and map markers

Features

Route Alternatives - See up to 3 different routes with real-time traffic
Favorites System - Save and compare properties across sessions
Rent vs. Buy Toggle - Seamlessly switch between rental and purchase searches
Rich Filtering - Price, bedrooms, bathrooms, property type (apartments + house rentals)

How I built it

Tech Stack

Frontend:

React 19 with Vite for lightning-fast development
@vis.gl/react-google-maps for interactive mapping
Tailwind CSS for responsive, modern UI
React Context API for state management with localStorage persistence

Backend:

Node.js + Express serving a RESTful API
PostgreSQL on Supabase for reliable, scalable data storage
Google Maps APIs - Distance Matrix, Directions, Geocoding, and Places
Gemini API for natural language understanding and intelligent ranking
H3 Geospatial Indexing (Uber's hexagonal system) for millisecond-speed proximity queries
node-cache for aggressive API response caching

Architecture Highlights

1. Simple but Powerful Database Design

Uses simple lat/lng columns with BETWEEN queries for viewport filtering
Pre-calculated H3 indexes at 3 resolutions (r5, r6, r7) for different transport modes
String-based H3 matching enables O(1) amenity lookups vs. O(n) distance calculations

2. Intelligent Caching Strategy

Commute calculations cached for 24 hours per property-workplace-mode combination
Geocoding results persisted to minimize API calls
In-memory cache reduces Google Maps API costs by ~90%

3. Batch Optimization

Single Distance Matrix API call calculates commutes for up to 25 properties simultaneously
Debounced map updates (500ms) prevent excessive API calls during pan/zoom
Lazy loading for detailed property views reduces initial page load

4. H3 Hexagonal Spatial Index Rather than calculating distances for every amenity query, I pre-indexed everything:

Resolution 7 (~1.22km edge): Walking distance
Resolution 6 (~3.23km edge): Biking distance
Resolution 5 (~8.54km edge): Driving distance

This allows queries like "properties near parks" to execute in milliseconds using simple SQL:

SELECT * FROM properties p
JOIN amenities a ON p.h3_index_r7 = a.h3_index_r7
WHERE a.type = 'park'

5. AI Integration Architecture

Gemini parses natural language → structured filters
Backend queries database with H3-optimized proximity joins
Gemini ranks filtered results based on user intent
Frontend displays ranked properties with AI explanations

Data Pipeline

Property Data: 252 hand-crafted Bay Area listings with realistic prices and locations
Geocoding: All addresses converted to lat/lng via Google Geocoding API
H3 Indexing: Properties and amenities indexed at 3 resolutions using h3-js library
Amenity Data: 8 categories fetched from OpenStreetMap Overpass API (parks, grocery, cafes, restaurants, transit, gyms, pharmacies, community centers)

Challenges I ran into

1. Slow Proximity Queries at Scale

Problem: Calculating distances between every property and every amenity (O(n²) complexity) was painfully slow.

Solution: Implemented Uber's H3 hexagonal spatial index. Pre-indexing amenities at 3 resolutions reduced query time from ~500ms to ~5ms - a 100x speedup! No PostGIS required.

2. Ambiguous Natural Language Queries

Problem: User asks for "properties near cafes" - but near by what mode of transport? Walking distance is very different from driving distance.

Solution: Enhanced Gemini prompts to detect ambiguity and ask clarifying questions. Default to walking distance but show UI indicator that lets users refine. Built a needsTransportModeClarity flag into the AI response schema.

3. Real-Time Map Performance

Problem: Rendering 100+ property markers with commute calculations while panning/zooming caused janky UI. A slower internet connection also prevented the vector-based map from rendering across many occasions.

Solution: Debounced viewport change events (500ms), limited to 100 properties max per viewport, used React Context to prevent unnecessary re-renders, and implemented a raster basemap fallback (which is more performant) in the case of a slower internet connection.

4. Commute Calculation Edge Cases

Problem: What if the user searches by amenities but hasn't set a workplace? What if Google Maps returns an error for a specific route?

Solution:

Allow amenity-only searches without workplace (commute fields show "Set workplace to see commute")
Graceful degradation - if a single property's commute fails, show "Commute unavailable" but still display the property
Persist workplace in localStorage so returning users don't lose context

5. Data Quality & Coverage

Problem: OpenStreetMap data has gaps for certain amenity types in some neighborhoods.

Solution: Supplemented OSM with Google Places API for critical amenities like grocery stores. Added visual indicators when amenity data is limited for an area.

Accomplishments I'm proud of

Technical Achievements

I built a production-ready full-stack app in 36 hours with features that rival established platforms:

✅ Full CRUD backend API with intelligent caching
✅ Interactive map with real-time commute visualization
✅ AI-powered search using Gemini API
✅ Geospatial indexing system (H3) for lightning-fast queries
✅ 252-property dataset with realistic Bay Area data
✅ Multi-modal routing (4 transport modes)
✅ Persistent favorites and filter preferences
✅ Responsive design that works on desktop and mobile

UX Innovations

Commute-First Design: Unlike Zillow or Redfin, commute time isn't buried 3 clicks deep - it's front and center on every listing.

Transport-Mode Awareness: The entire app adapts when you switch from "walking" to "biking" - amenities re-filter, rankings update, and hex boundaries resize. This level of context-awareness is unique in real estate search.

Natural Language Search: Ask like a human - "2BR near parks under $2500" - and get intelligent results. The AI understands lifestyle priorities, not just database filters.

Neighborhood Chat: Click "Ask AI" on any property and query its surroundings conversationally: "Are there any coffee shops nearby?" Returns real places with photos and map markers. This turns passive browsing into interactive discovery.

Scale & Performance

Sub-50ms queries for complex proximity searches across 252 properties and 1000+ amenities thanks to H3 indexing.

90% API cost reduction through intelligent caching strategies.

Zero database migrations during development - schema was well-designed from day one.

Problem-Solving

I solved the "20 browser tabs" problem. One interface now combines:

Zillow (property listings)
Google Maps (routes and commutes)
Yelp (nearby amenities)

What I learned

Technical Learnings

1. Geospatial indexing is a game-changer Before H3, my amenity queries took 500ms. After H3, they took 5ms. Hexagonal grids are elegant, uniform, and blazingly fast for proximity queries. I learned that sometimes the right data structure matters more than raw optimization.

2. API design matters as much as implementation I initially built individual endpoints for each feature. Consolidating to a /map-bounds endpoint that returns properties + filters + commute data in one call reduced round trips by 70%.

3. Caching strategy defines your scalability With no caching, I'd hit Google Maps API limits in 2 hours of testing. With aggressive caching (24h for commutes, localStorage for preferences), the app can serve hundreds of users for days on the free tier.

4. AI prompt engineering is an art My first Gemini prompts returned inconsistent JSON. I learned to:

Explicitly define output schema
Use one-shot examples
Add "return ONLY valid JSON" instructions
Build fallback parsing with regex
Add ambiguity detection flags

Product & Design Learnings

1. Progressive disclosure prevents overwhelm I display compact property cards by default, then expand to show route alternatives, nearby amenities, and AI chat only when users click. This keeps the interface clean while offering power-user depth.

2. Edge cases make or break UX Empty search results, missing commute data, ambiguous queries - these "unhappy paths" took 30% of my development time but define whether users trust the product.

Process Learnings

1. Design docs save time I spent 7 hours writing a detailed design doc before coding. This prevented scope creep, aligned architecture decisions, and gave me a clear MVP → stretch goal progression.

2. Cache-first, optimize later Every API call was wrapped in caching from day one. I didn't prematurely optimize code, but I did prevent redundant external API calls. This saved both time and money.

What's next for Dwelligence

Short-Term Enhancements

Preferred Commute Time - Set a preferred commute time for commute visualization.
Crime & Walkability Scores - Integrate Walk Score API and local crime data
Add your listing - Allow hosts/realtors to add property listings through a POST endpoint, which would trigger h3 checks (with amenity aggregations into any new h3 produced from this)

Medium-Term Features

Cost Comparison Dashboard - Total cost of living (rent + transport + parking)
Virtual Tours Integration - Embed 360° tours and video walkthroughs
Schedule Showings - Direct integration with landlords/agents

Long-Term Vision

Real MLS Integration - Partner with Zillow/Redfin APIs for live listings
Expansion to More Cities - Start with NYC, LA, Boston, Seattle
Mobile App - React Native version for iOS/Android
Browser Extension - Add Dwelligence data to Zillow/Craigslist listings

Business Model Ideas

Freemium SaaS - Free for basic search, premium for unlimited favorites/alerts
Agent Partnerships - Revenue share with real estate agents who get leads
API Licensing - Sell the commute intelligence API to other platforms
Corporate Partnerships - Help companies attract talent by showcasing commute-friendly housing near their offices

Try it Out

GitHub Repository: https://github.com/yourusername/dwelligence

Quick Start (Local)

# Clone the repo
git clone https://github.com/yourusername/dwelligence.git
cd dwelligence

# Backend setup
cd backend
npm install
# Add .env with DATABASE_URL, GOOGLE_MAPS_API_KEY, GEMINI_API_KEY
npm run seed
npm run dev

# Frontend setup (new terminal)
cd ../frontend
npm install
# Add .env with VITE_GOOGLE_MAPS_API_KEY, VITE_API_URL
npm run dev

# Visit http://localhost:5173

Requirements:

Node.js 18+
PostgreSQL database (Supabase free tier works!)
Google Maps API key (Distance Matrix, Directions, Geocoding, Places APIs enabled)
Gemini API key (free tier available)