# I Built an AI Architectural Blueprint & Civil Feasibility Engine with $0 Paid APIs (Here's How)

> Source: <https://dev.to/rolan_r_n_r/i-built-an-ai-architectural-blueprint-civil-feasibility-engine-with-0-paid-apis-heres-how-2gal>
> Published: 2026-10-18 09:38:21+00:00

*"Hey ChatGPT, design me a house."*

**ChatGPT:** *"Sure! Here is a lovely 3-bedroom house where the only toilet is inside the oven, the front door opens into an elevator void, and the staircase ascends directly into the ceiling slab."* 🫠

If you’ve ever tried using modern GenAI to generate architectural plans or evaluate a piece of real estate, you know the pain. Large Language Models are brilliant poets and witty coders, but when it comes to **spatial geometry**, **civil building codes**, and **structural physics**, they hallucinate like a sleep-deprived toddler playing with Minecraft blocks.

Meanwhile, the traditional workflow of buying a plot of land and getting it vetted is practically medieval:

I decided to solve this. **Alone. In code.**

Meet **BuildWise AI** — an open-source, sovereign platform where you drop a single pin on an interactive 3D globe and receive an enterprise-grade civil engineering dossier, structural risk analysis, CPWD cost estimate, and a generative, constraint-checked architectural blueprint in **under 3 seconds**.

Oh, and the entire geospatial pipeline costs exactly **$0.00 in paid API fees**. No Google Maps billing, no Mapbox metered charges, no commercial satellite subscriptions.

Here is the deep dive into how it works under the hood — from the math of **Spatial Constraint Satisfaction Problems (CSP)** to **5-Factor MCDA Land Suitability**, and how ancient Indian **Vastu Shastra** turned out to be an exquisite bioclimatic optimization matrix.

Here is what happens the instant a user clicks a coordinate on the map:

```
[ User Drops Pin on Map ]
         │
         ├───► 1. Sliding-Window Rate Limiter (30 req/min)
         │
         ├───► 2. Parallel Telemetry Ingestion (All Free / Open-Access!)
         │        ├── Digital Elevation Model (USGS / Copernicus GLO-30 DEM)
         │        ├── Microclimate & Wind Vectors (Open-Meteo Forecast)
         │        ├── Seismic History (USGS FDSN Earthquake Catalog)
         │        └── Hydrological Flow (Copernicus GloFAS River Discharge)
         │
         ├───► 3. Deterministic Civil Calculation Core
         │        ├── 5-Factor Weighted MCDA Land Suitability Matrix
         │        ├── IS 1893:2016 Zone & Peak Ground Acceleration (PGA)
         │        ├── NBC 2016 Automated Setbacks & Plinth Envelopes
         │        ├── CPWD Delhi Schedule of Rates (DSR) Cost Estimator
         │        └── Vastu Purusha Mandala 9-Zone Bioclimatic Vector
         │
         ├───► 4. Generative Blueprint Engine (CF-HSA Slicing Tree)
         │        ├── Vertical Cores & Wet Plumbing Shafts Locked (G to G+3)
         │        ├── Topological Invariants Enforced (Leaf Rule, Central Box)
         │        └── L1–L14 Deterministic Validation Gate
         │
         └───► 5. Synthesis & Vector Delivery
                  ├── Ultra-Crisp Interactive SVG Blueprint (Pan/Zoom/Layers)
                  └── Print-Ready 174mm Vector PDF Dossier (ReportLab)
```

Total round-trip time: **~2.4 to 3.1 seconds**. 🚀

Let’s look at the UI in action:

```
┌─────────────────────────────────────────────────────────────────────────────┐
│ 🗺️ BuildWise AI                                      [ 🛰️ Satellite ] [ 📐 3D ]│
├──────────────────────────────────────┬──────────────────────────────────────┤
│                                      │  📋 SITE FEASIBILITY DOSSIER         │
│               [ PIN ]                │  ──────────────────────────────────  │
│        12.9716° N, 77.5946° E        │  🎯 Overall Suitability: 84/100      │
│                                      │  🌊 Flood Inundation Risk: LOW (0.12)│
│                                      │  ⚡ Seismic Zone: II (Z = 0.10)       │
│                                      │  💰 Est. Plinth Cost: ₹ 2,450 / sq.ft│
│                                      │  ──────────────────────────────────  │
│                                      │  [ 📐 GENERATE BLUEPRINT (G+1) ]     │
├──────────────────────────────────────┴──────────────────────────────────────┤
│  ✨ Architectural Blueprint (Level G):                                       │
│  ┌─────────────────────────┬──────────────────────────┬──────────────────┐  │
│  │   POOJA ROOM (NE)       │    LIVING & FOYER (N)    │  KITCHEN (SE)    │  │
│  │   4.2 m² [LEAF NODE]    │    24.5 m² [HUB NODE]    │  11.2 m² [VENT]  │  │
│  ├─────────────────────────┼──────────────────────────┼──────────────────┤
│  │   STAIRCASE CORE        │   CENTRAL SPINE          │  DINING ROOM     │  │
│  │   (Vertical Anchor)     │   (Brahmasthan Open)     │  14.0 m²         │  │
│  ├─────────────────────────┼──────────────────────────┼──────────────────┤
│  │   MASTER BEDROOM (SW)   │   ATTACHED BATH (W)      │  COMMON BATH     │  │
│  │   18.5 m² [PRIVATE]     │   4.8 m² [EXTERIOR WALL] │  3.6 m² [LEAF]   │  │
│  └─────────────────────────┴──────────────────────────┴──────────────────┘  │
└─────────────────────────────────────────────────────────────────────────────┘
```

Most SaaS apps slap the Google Maps JavaScript API on their frontend and call it a day — until their monthly bill arrives with 4 zeroes at the end.

For BuildWise AI, I made a strict rule: **Zero Paid APIs**. Every geospatial query, satellite tile, elevation reading, and climate metric must run on open-data infrastructure.

Here is the exact provider matrix:

| Feature | The Expensive Commercial Way | The BuildWise Zero-Cost Way | Open Source / Data License | 
|---|---|---|---|
| **Base Vector Tiles** | Mapbox GL ($$$) | **OpenFreeMap (Liberty & Dark styles)** | OpenMapTiles / ODbL | 
| **Satellite Imagery** | Google Satellite ($$$) | **Esri World Imagery (Maxar/USGS)** | Free for Public Web Apps | 
| **3D Topographic Relief** | Mapbox Terrain-RGB | **OpenTopoMap + AWS Terrarium DEM** | CC-BY-SA 3.0 / AWS Open Data | 
| **Digital Elevation & Slope** | Google Elevation API | **Open-Meteo (Copernicus DEM 30m GLO-30)** | Public Domain / CC0 | 
| **Historical Earthquakes** | Proprietary Catastrophe APIs | **USGS FDSN Earthquake Catalog** | US Public Domain | 
| **River Floods & Discharge** | Commercial Hydrology Data | **Copernicus GloFAS via Open-Meteo** | Copernicus Open Access | 
| **Multispectral Satellite** | Sentinel Hub Paid Tiers | **Copernicus Sentinel-2 L2A API** | European Space Agency (ESA) | 

How do you calculate whether a plot is buildable or prone to landslides without sending a surveyor with a theodolite?

We query 5 points: the site centroid $(x, y)$ plus four cardinal offsets 33 meters out $(x \pm 33\text{m}, y \pm 33\text{m})$. We fetch their elevations using the **Copernicus 30m Global DEM** and compute the maximum slope gradient:

``` python
# app/services/external_data_service.py
def calculate_topographic_slope(elevations: List[float], offset_meters: float = 33.0) -> float:
    """
    Computes the true ground gradient across cardinal samples:
    Slope (%) = (Δh_max / horizontal_distance) * 100
    """
    center_elev = elevations[0]
    deltas = [abs(e - center_elev) for e in elevations[1:]]
    max_delta_h = max(deltas)

    slope_pct = (max_delta_h / offset_meters) * 100.0
    return round(slope_pct, 2)
```

If the slope exceeds 15%, the system immediately triggers foundation excavation multipliers and flags slope-stabilization retaining wall requirements under **IS 14458**.

If you ask an LLM to generate a JSON blueprint, it will happily invent coordinates where:

Architectural layout is **not** a language completion problem. It is a **Spatial Constraint Satisfaction Problem (CSP)** with strict topological graph invariants.

In BuildWise AI, we built the **Core-First Hierarchical Allocation (CF-HSA)** engine (`app/services/floorplan/multi_floor_solver.py`):

```
graph TD
    subgraph MultiStoreySolver ["Core-First Hierarchical Allocation (CF-HSA)"]
        Req[User Specs & Plot Dimensions] --> Setbacks[NBC 2016 Setback Subtraction]
        Setbacks --> CoreLock[1. Anchor Phase: Lock Vertical Stair/Lift Cores at x,y]
        CoreLock --> ShaftLock[2. Lock Continuous Plumbing Wet Stacks]
        ShaftLock --> PlateSlice[3. Slicing-Tree Space Partitioner]
        PlateSlice --> TopoFilter[4. Topological Invariant Filters]
        TopoFilter --> ValGate[5. Deterministic Validation Gate L1-L14]
        ValGate --> Success[Mathematical Validity Certificate Issued ✅]
    end
```

Every single blueprint must satisfy these 5 mathematical invariants, or the plate is rejected:

In our circulation door graph, sensitive rooms (bathrooms, toilets, walk-in closets, pooja rooms) must be **leaf nodes**. They can only have an edge incident to a hallway or their parent room. Through-traffic is mathematically banned:

$$\text{degree}(v) = 1 \quad \forall v \in {\text{bath}, \text{wc}, \text{pooja}}$$

Every bathroom and kitchen must touch the building's exterior perimeter boundary:

$$\text{edge}(v) \cap \partial(\text{Envelope}) \neq \emptyset$$

No exterior wall = no natural ventilation shaft = instant code violation.

Under ancient Vastu canon, the central 40% of a home (*the Brahmasthan*) must remain open for light, ventilation, and circulation. We codified this as a geometric bounding box:

$$C_{\text{box}} = [x_{\text{min}} + 0.30W, x_{\text{min}} + 0.70W] \times [y_{\text{min}} + 0.30D, y_{\text{min}} + 0.70D]$$

No service room centroid (bathroom, WC, kitchen) is permitted to lie within this box.

The main entrance must open strictly into the **Living Room / Foyer**. An entrance door that opens into a private bedroom or toilet fails the solver.

Bathrooms and sacred spaces cannot share a wall segment. We compute polygon boundary intersections:

$$\text{Wall}(\text{bath}) \cap \text{Wall}(\text{pooja}) = \emptyset$$

Building a multi-storey house isn't just generating 3 random floorplans and stacking them. If your staircase moves 2 meters to the left on the 2nd floor, your stairs lead straight into thin air!

Our multi-floor solver locks the vertical anatomy first:

```
Level G+2  ┌────────────────┬───────────────┬────────────────┐
           │ Master Bedroom │ STAIRCASE (Z) │ Balcony        │
           │ [Wet Stack ▼]  │ [LOCKED x, y] │                │
Level G+1  ├────────────────┼───────────────┼────────────────┤
           │ Bedroom 2      │ STAIRCASE (Z) │ Study Room     │
           │ [Wet Stack ▼]  │ [LOCKED x, y] │                │
Level G    ├────────────────┼───────────────┼────────────────┤
           │ Kitchen/Bath   │ STAIRCASE (Z) │ Living Foyer   │
           │ [Wet Stack █]  │ [LOCKED x, y] │ Main Entrance  │
           └────────────────┴───────────────┴────────────────┘
             ▲                                ▲
        Plumbing Shafts                  Core Stays Frozen
      aligned within 0.05m               across all floors!
```

In South Asian construction, up to 90% of residential clients demand compliance with **Vastu Shastra** (an ancient architectural canon). Many modern engineers dismiss it as superstition.

When you analyze Vastu through the lens of **passive solar bioclimatic architecture**, however, the brilliance emerges:

```
               NORTH (Kubera - Wealth / Diffuse Daylight)
          ┌─────────────────┬─────────────────┬─────────────────┐
          │   POOJA ROOM    │  LIVING / ENTR  │  WATER STORAGE  │
          │  NE (Ishanya)   │      NORTH      │   NW (Vayu)     │
          │ Morning Sunlight│ Indirect Light  │ Cross Wind      │
          ├─────────────────┼─────────────────┼─────────────────┤
WEST      │  BEDROOM / STUDY│   BRAHMASTHAN   │   DINING ROOM   │  EAST
(Varuna)  │      WEST       │  (Open Center)  │      EAST       │ (Indra)
          │ Evening Breeze  │  Zero Load      │ Sunrise Light   │
          ├─────────────────┼─────────────────┼─────────────────┤
          │ MASTER BEDROOM  │  SERVICE / ELEV │     KITCHEN     │
          │  SW (Nairutya)  │      SOUTH      │   SE (Agneya)   │
          │ Heavy Thermal   │  Blocks Heat    │ Morning Heat/   │
          │ Mass (No Sun)   │                 │ Kitchen Exhaust │
          └─────────────────┴─────────────────┴─────────────────┘
                                   SOUTH
```

In BuildWise AI, we codified this into a **9-Zone Purusha Mandala Matrix** (`app/services/vastu_service.py`) that computes the exact cosine vector between the road access angle, sun azimuth, and the room placement score!

We wanted the interface to look like an Apple design award winner, not a dusty 1998 AutoCAD utility:

`backdrop-blur-md`, subtle borders, iOS-style spring animations).` BlueprintViewer.tsx`)` window.print()` hacks that break CSS grids.
A civil engineering tool cannot afford "silent fails". If a floorplan generator silently drops a bedroom or generates an overlapping room, contractors waste real concrete.

We built a bulletproof testing pipeline:

```
# Frontend: Oxlint + TypeScript + 9-Viewport Puppeteer DOM audit
cd frontend
npm run lint          # Ultra-fast static analysis via Oxlint
npm run build         # Strict tsc type verification + Vite bundle
npm run audit:ui      # Puppeteer audits DOM integrity across 9 viewports

# Backend: 236 Pytest suites covering geometry, codes, and PDF rendering
cd ../backend
python -m pytest tests/
```

`validation_gate.py`) before being marked with a `MathematicalValidityCertificate`.
Building **BuildWise AI** proved three crucial engineering principles:

BuildWise AI is 100% open-source under the **MIT License**.

```
  git clone https://github.com/Mrtracker-new/BuildWise_AI.git
  cd BuildWise_AI
  ./run_project.bat   # Or spin up backend & frontend via standard CLI
```

Got questions about spatial CSP, MapLibre GL styling, or Copernicus satellite queries? Drop them in the comments below — I’ll be hanging out and answering every single one! 👇