Inspiration
What it does
How we built it
Challenges we ran into
Accomplishments that we're proud of
What we learned
What's next for GridMind
GridMind — Infrastructure Coordination Intelligence 🚧 The Problem
Modern cities depend on many different infrastructure systems — water, roads, electricity, sewage, telecommunications, and transportation.
The problem is that these infrastructure projects are often planned by different organizations and at different times.
For example:
A water utility plans a water-main replacement. A transportation department plans road resurfacing. An electrical utility plans underground cable work.
Individually, each project may look completely reasonable.
But what happens when two projects are planned on the same road corridor and their construction schedules overlap?
The result can be:
Repeated road excavation Construction delays Traffic disruption Increased costs Repeated restoration work Poor coordination between utilities Difficulty understanding which projects are actually affected
The information needed to detect these conflicts is also fragmented across PDFs, websites, GIS datasets, project records, and public infrastructure sources.
We asked ourselves:
What if infrastructure teams could discover these conflicts before construction begins and understand what action they should take?
That idea became GridMind.
💡 Our Idea
GridMind is an infrastructure coordination intelligence platform that detects potential conflicts between utility construction projects based on location and time, explains the impact using AI, and helps teams coordinate their next actions.
Our core principle is:
Deterministic systems calculate facts. AI explains those facts and proposes actions.
This distinction is extremely important.
We don't ask an AI model to guess whether two construction projects overlap.
Instead:
Geographic algorithms calculate the spatial relationship. Temporal logic calculates schedule overlap. Evidence is attached to the analysis. AI explains the verified results. AI can generate a structured coordination plan.
This makes GridMind more traceable, explainable, and reliable than a simple chatbot.
🧠 What Inspired GridMind?
The inspiration came from a simple observation:
Infrastructure projects don't exist independently.
A road project affects water utilities.
A water project affects roads.
Road closures affect transportation.
Construction schedules affect other projects.
However, traditional project information systems often focus on individual projects rather than the relationships between projects.
We wanted to build a system that looks at infrastructure as a connected system.
Instead of asking:
"What is this project?"
GridMind asks:
"What other projects could this project conflict with, where is the conflict, when does it happen, and what can the teams do about it?"
🗺️ How GridMind Works
The GridMind workflow can be summarized as:
Public Data Sources ↓ Project Extraction ↓ Project Normalization ↓ Geospatial + Temporal Analysis ↓ Conflict Detection ↓ Evidence ↓ AI Explanation ↓ Coordination Plan
- Add Utilities
GridMind starts by organizing infrastructure organizations.
A utility can have:
Utility name Utility type Service region Service area Projects Public data sources
For example:
Satna Nagar Nigam │ ├── Service Area ├── Water Projects ├── Road Projects └── Public Sources
This creates a structured relationship between organizations and their infrastructure projects.
📄 2. Connect Public Infrastructure Data
Infrastructure information is often available in different formats.
GridMind is designed to work with sources such as:
PDF documents Websites GIS datasets Structured project records Public infrastructure databases
Instead of manually entering every project, GridMind can extract important information such as:
Project Name Project Type Location Start Date End Date Status Utility Source Source URL
For example:
Project: Water Main Replacement
Location: Civil Lines Road
Start: 10 October 2026
End: 5 December 2026
Source: Public Infrastructure Document
The important part is that GridMind maintains a connection between the extracted project and its original source.
This allows users to verify where the information came from.
📍 3. Geospatial Conflict Detection
This is one of the core capabilities of GridMind.
Suppose we have two projects:
Project A Water Main Replacement Civil Lines Road Project B Road Resurfacing Civil Lines Road
Both projects may affect the same corridor.
GridMind uses geospatial processing to determine their actual geographic relationship.
Operations can include:
Intersection Overlap Distance Buffer analysis Geometry comparison
We don't simply compare text such as "Civil Lines Road".
We analyze the actual geographic geometry.
For example:
Water Project ───────────────██████████████
⚠
CONFLICT
Road Project ────────────████████████████
This provides a much stronger basis for conflict detection.
📅 4. Temporal Conflict Detection
Location alone is not enough.
Two projects could use the same road but happen six months apart.
In that case, they may not have a direct construction-time conflict.
Therefore, GridMind also analyzes project schedules.
For two projects:
$$ A = [start_A, end_A] $$ $$ B = [start_B, end_B] $$
Their overlapping period is calculated as:
$$ overlap_{start} = \max(start_A,start_B) $$ $$ overlap_{end} = \min(end_A,end_B) $$
A temporal overlap exists when:
$$ overlap_{start} \leq overlap_{end} $$
This gives GridMind a deterministic answer rather than asking an LLM to interpret dates.
⚠️ 5. Detecting the Actual Conflict
GridMind combines the spatial and temporal analysis.
For example:
Water Main Replacement 10 Oct 2026 → 5 Dec 2026
+
Road Resurfacing 1 Nov 2026 → 15 Jan 2027
The projects:
Affect nearby/same geographic infrastructure Have overlapping construction periods
GridMind can therefore create a potential construction conflict.
The conflict page can show:
⚠ Construction Conflict
Water Main Replacement ↕ Road Resurfacing
Spatial Relationship: Detected Temporal Overlap: Detected Evidence: Available
Potential Impact: Shared construction corridor 🔍 6. Evidence-Based Analysis
A major design decision was to make GridMind evidence-driven.
The system doesn't simply show:
"AI says these projects conflict."
Instead, users can inspect:
Original project Source document Source URL Project dates Project geometry Analysis result Supporting evidence
The goal is to make the result traceable.
This is especially important for infrastructure planning because users may need to understand why a conflict was detected.
🤖 7. AI-Powered Explanation
Once the deterministic engine establishes the facts, AI becomes useful.
The AI layer can explain:
Why the projects may conflict What infrastructure may be affected Why schedule coordination could matter What teams should review Possible coordination options
For example:
Two projects affect the same corridor during overlapping construction periods. Coordinating schedules may reduce repeated access restrictions and construction disruption.
The AI is not responsible for calculating the underlying geographic or temporal facts.
Instead:
Deterministic Engine ↓ Verified Facts ↓ AI ↓ Explanation + Coordination Options
This separation was one of the most important architectural decisions in GridMind.
🧩 8. AI Control Center — Assurant
We also wanted to address another problem:
What happens when an application uses AI but users don't know what data is being sent, which model is being used, or how much the AI costs?
GridMind introduces an AI Control Center.
Users can see information such as:
AI provider Model Purpose Privacy mode Data being sent Redacted information Token usage Estimated cost
Example:
AI Control Center
Provider: Google Model: Selected AI Model
Purpose: Conflict Explanation
Privacy: STRICT
Data Sent: Project metadata Conflict facts Evidence excerpts
Sensitive Data: Redacted
Estimated Cost: Visible
This concept connects directly with the Assurant challenge around transparency, privacy, and AI usage control.
🚗 9. Transportation Impact — Waymo
Infrastructure conflicts don't only affect utilities.
They can also affect people moving through the city.
If construction happens on an important road corridor, it can influence:
Traffic movement Road accessibility Construction routing Transportation operations
GridMind therefore includes a transportation-impact layer aligned with the Waymo challenge.
The idea is to move from:
"These two projects conflict."
toward:
"These projects conflict here, during this period, and this corridor may have transportation implications."
This gives infrastructure planners a broader view of the problem.
⚙️ 10. Actionable AI Workflow — Microsoft
We didn't want GridMind to become just another AI chatbot.
Instead of asking users to open a chat and manually explain the situation, GridMind provides an actual workflow.
For example:
Create Coordination Plan
The system can generate a structured plan containing:
Conflict Summary ↓ Affected Projects ↓ Evidence ↓ Potential Impact ↓ Coordination Options ↓ Responsible Teams ↓ Next Steps
Possible coordination actions can include:
Reviewing construction schedules Coordinating access requirements Reviewing the shared corridor Contacting responsible teams Planning a coordination meeting
This connects the project with the Microsoft challenge by using AI as part of an actionable workflow rather than making the entire product a chatbot.
🏗️ How We Built GridMind
GridMind uses a multi-service architecture.
React Frontend
│
▼
Express.js Backend
│
┌────────────┴────────────┐
│ │
▼ ▼
MongoDB FastAPI
System of Record Analysis Engine
│
┌─────────────┼─────────────┐
▼ ▼ ▼
Geo Analysis Time Analysis Evidence
│ │ │
└─────────────┼─────────────┘
▼
LangGraph
│
▼
AI Explanation
│
▼
Coordination Plan
Frontend
We use React to provide:
Interactive infrastructure maps Utility management Project management Source management Conflict visualization AI Control Center Analysis workflows Backend
Express.js acts as the main application backend.
It handles:
Authentication APIs Project management Utility management Source management Persistence Analysis orchestration Usage tracking Database
MongoDB acts as the system of record.
Important entities include:
Users Utilities Projects Data Sources Analysis Runs Conflicts Evidence Recommendations AI Requests Audit Events Analysis Service
FastAPI + GeoPandas + Shapely + PyProj handles the analytical layer.
This allows us to perform actual geospatial operations instead of relying on an LLM for geographic calculations.
AI Layer
LangGraph manages the AI workflow.
Conceptually:
Validate Evidence ↓ Classify Conflict ↓ Explain Conflict ↓ Generate Coordination Options ↓ Check Unsupported Claims ↓ Final Output 🧠 One Important Engineering Lesson
During development, we realized that AI should not be responsible for everything.
It is tempting to send two projects to an LLM and ask:
"Do these projects conflict?"
But that creates several problems.
The answer could change between model calls.
The model could misunderstand coordinates.
It could misinterpret dates.
It could even invent information.
So we designed GridMind around a different philosophy:
Computers calculate. AI explains.
For example:
Coordinates ↓ Geospatial Engine ↓ Distance / Intersection ↓ Verified Fact
Dates ↓ Temporal Engine ↓ Overlap Period ↓ Verified Fact
Verified Facts ↓ AI ↓ Human-readable Explanation
This architecture makes the system much easier to audit.
🧪 Challenges We Faced
- Working With Different Data Formats
Infrastructure information doesn't always arrive in a clean database.
We needed to think about:
PDFs Websites GIS data Different date formats Different project naming conventions Missing fields Different geometry formats
We therefore designed a normalization layer so that different sources can eventually be converted into a common project structure.
- Geospatial Data Is More Complicated Than It Looks
Coordinates aren't simply numbers that can always be compared directly.
We had to account for:
GeoJSON structure Longitude/latitude ordering Coordinate reference systems Distance calculations Polygon validity Line intersections
For example, GeoJSON coordinates follow:
[longitude, latitude]
rather than:
[latitude, longitude]
We also learned that geographic coordinates should not simply be treated as meters when calculating real-world distances.
- Missing Information
Public project data may not contain every required field.
For example:
Project A: Start Date ✓ End Date ✓
Project B: Start Date ✓ End Date ✗
We decided that GridMind should not invent missing information.
Instead, the system can mark the temporal analysis as unavailable or uncertain.
That is much safer than allowing an AI model to guess a date.
- Making AI Trustworthy
Another challenge was deciding how much authority the AI should have.
We deliberately designed guardrails so AI should not invent:
Construction dates Distances Project budgets Regulations Approvals Project scope Evidence
The AI should work from verified information supplied by the system.
📚 What We Learned
Building GridMind taught us several important lessons.
- AI doesn't have to replace deterministic software.
The strongest system can combine both.
Deterministic computation + Evidence +
AI reasoning/explanation
More useful workflow
- Data provenance matters.
When a system makes an important decision, users should be able to ask:
"Where did this information come from?"
That's why GridMind keeps projects connected to their sources.
- Spatial data requires specialized processing.
Maps aren't just visual components.
Behind every line and polygon are:
Coordinates Coordinate systems Geometry Distances Intersections Spatial relationships
- AI transparency should be part of the product.
Instead of hiding AI usage, GridMind exposes:
Model Provider Privacy Data Usage Cost
- The final goal isn't the analysis — it's the action.
Detecting a conflict is useful.
But helping the teams understand what to do next is even more useful.
That's why GridMind moves from:
Detect ↓ Explain ↓ Coordinate 🏆 Sponsor Integration
GridMind was designed so sponsor technologies correspond to actual product capabilities rather than simply appearing as logos.
Sponsor GridMind Integration Sperry Tech Core utility construction conflict detection using spatial and temporal relationships Assurant AI Control Center for privacy, model visibility, data controls, and AI cost transparency Waymo Transportation context and potential impact of construction conflicts Microsoft AI-powered coordination workflow that converts analysis into an actionable plan
The sponsor integrations are connected to the central GridMind workflow rather than being isolated features.
🎯 What GridMind Ultimately Provides
Imagine a city planner opens GridMind.
They see:
Water Project + Road Project ↓ Same Corridor + Overlapping Schedule ↓ ⚠ Potential Conflict ↓ Evidence ↓ AI Explanation ↓ Transportation Context ↓ Coordination Plan
Instead of discovering the problem after construction has already started, the team can identify the relationship earlier and review possible coordination actions.
🚀 Our Vision
GridMind started with one simple idea:
Infrastructure should be coordinated before it becomes a disruption.
We envision GridMind evolving into a broader infrastructure intelligence layer where cities and utilities can connect public project information, understand relationships between projects, evaluate potential impacts, and turn analysis into coordinated action.
The long-term vision is not to replace infrastructure professionals.
It is to give them better information before important decisions have to be made.
Built With
- api
- css3
- docker
- express.js
- fastapi
- gemini
- geojson
- html5
- javascript
- jwt
- langchain
- langgraph
- leaflet.js
- mongodb
- mongoose
- node.js
- numpy
- pandas
- python
- rest
- shapely
Log in or sign up for Devpost to join the conversation.