AIdeas: VIGIA, The RoadIntelligence IDE
Discover how VIGIA uses Edge AI, AWS Step Functions, and Amazon Bedrock to transform everyday smartphones into an efficient road intelligence network.
VIGIA, The RoadIntelligence IDE
App Category: Commercial Solutions
Secondary relevance: #social-impact
Secondary relevance: #social-impact
Live Platform : https://main.d2nkopgztcw9g1.amplifyapp.com/
Github Repo: https://github.com/BlueWaves-afk/vigia-amazon
My Vision
A brief overview of our working system.
Every day in India, over six people leave for work and never make it home, not because of reckless driving, but because of a road hazard.
Between 2020 and 2024, infrastructure failures claimed nearly 9,500 lives across the country . The tragedy isn't just the staggering loss of life or the billions in vehicle damage; it's the fact that these hazards; potholes, flooding, and surface degradation often remain completely undetected or ignored until an accident occurs.
Most cities still rely on slow, periodic inspection cycles or wait for citizens to complain. This creates a deadly latency between a hazard forming and the city fixing it. This is especially dangerous when we are dealing with high-speed, heavy machines on the road.
The VIGIA system is built to eliminate that latency.
VIGIA is an infrastructure intelligence service that turns everyday smartphones or dashcam devices mounted on municipal waste trucks, delivery vans, or public transport, into privacy-preserving edge AI nodes. Instead of relying on expensive private ADAS systems, VIGIA democratizes road surveillance, at an affordable rate, to government entities.
By focusing purely on pragmatic, scalable technology, hazards are:
- Detected locally using on-device AI (YOLO26), ensuring raw video never leaves the phone.
- Structured as lightweight, anonymous telemetry events.
- Validated instantly through an AWS serverless orchestration layer (Amazon Bedrock and Lambda).
- Mapped for city planners using geospatial intelligence (Amazon Geofences and Live Location).
This article introduces the admin side of the system: the monitoring, planning, and analysis of road infrastructure. We introduce the VIGIA IDE, a human-in-the-loop portal where road analysis and surveillance are efficiently presented to relevant entities who can immediately take the necessary action.
Hence, VIGIA introduces a new concept: Infrastructure Observability.
Our Road Intelligence IDE, presents data and analytics in an efficient manner; designed for speed.
Why This Matters
Infrastructure quality directly affects public safety, economic mobility, and community resilience. Globally, over 1.3 million people die each year in road-related incidents, and poor road conditions cause billions of dollars in vehicle damage annually. Crucially, infrastructure repairs in underserved regions often experience the longest delays.
The challenge we face today is not a lack of AI intelligence; it is a lack of visibility, latency control, and accessible data sharing.
The Status Quo is Failing
Currently, municipal governments operate on a reactive or highly latent model. They either rely on citizen complaints (which are subjective, unstructured, and usually happen after damage is done) or they commission specialized road-survey vehicles that cost hundreds of thousands of dollars, meaning a road might only be inspected once a year.
Currently, municipal governments operate on a reactive or highly latent model. They either rely on citizen complaints (which are subjective, unstructured, and usually happen after damage is done) or they commission specialized road-survey vehicles that cost hundreds of thousands of dollars, meaning a road might only be inspected once a year.
On the commercial side, enterprise fleet management companies like Samsara have built powerful AI dashcam networks. However, these solutions require expensive, proprietary hardware, and the telemetry they gather is used strictly by the private fleet operator. They optimize the fleet, but they do not help the city fix the pothole.
The VIGIA Advantage
VIGIA bridges this gap by democratizing road surveillance. It introduces a distributed, serverless monitoring model that transforms standard smartphones and generic dashcams into a unified intelligence network.
VIGIA bridges this gap by democratizing road surveillance. It introduces a distributed, serverless monitoring model that transforms standard smartphones and generic dashcams into a unified intelligence network.
VIGIA addresses these systemic challenges by:
- Reducing detection latency from annual inspection cycles to near real-time.
- Removing the reliance on centralized, expensive surveillance hardware or proprietary enterprise contracts.
- Enabling severity-weighted geospatial prioritization, so cities know exactly which hazards to fix first based on traffic and risk.
- Preserving privacy by strictly transmitting structured metadata (bounding boxes and coordinates) rather than raw video media.
- Introducing verifiable reporting workflows that treat infrastructure health with the same rigor as software health.
While the platform directly supports social impact through improved road safety, it creates immense value for a shared commercial ecosystem. Municipal governments, insurance providers, fleet operators, and smart city initiatives all benefit from a continuously observable road network.
The goal is simple: Introduce structured, affordable, and actionable AI decision-making into public infrastructure management.
System Architecture
The diagram illustrates the end-to-end architecture of the VIGIA platform.
Hazard detection occurs at the edge using a browser based YOLO model, with detections cryptographically signed and transmitted through Amazon API Gateway.
A Lambda verification service validates the payload before storing events in Amazon DynamoDB, which streams filtered hazard events through EventBridge Pipes to the orchestration layer.
An Amazon Bedrock agent coordinates Lambda services and AWS Step Functions workflows, while Amazon Location Service provides geospatial intelligence for visualization in the RoadIntelligence IDE.
The system architecture follows serverless design principles to maximize reliability, horizontal scalability, and cost efficiency while minimizing operational overhead. By combining stateless compute services, event‑driven orchestration, and append‑only infrastructure telemetry, VIGIA maintains strong fault tolerance and auditability across the entire hazard detection lifecycle.
Infrastructure Planning Workflow
This workflow shows how the Bedrock agent coordinates a Step Functions planning pipeline.
When a planning request is triggered, the workflow executes parallel computations including road geometry modeling, cost analysis, and zone evaluation.
The results are aggregated and returned to the RoadIntelligence IDE as structured geospatial data.
How I Built This
Developed in collaboration with my teammate @tommathew, VIGIA is a working prototype that fuses browser-based edge inference with AWS serverless infrastructure.
Building a system of this scale in a compressed timeframe required more than just writing application code; it required rigorous, reproducible infrastructure management. We heavily leveraged AWS Kiro for strict Spec-Driven Development (SDD). By defining our exact requirements before writing code, we eliminated architectural drift. (You can view the evolution of our architecture through the detailed spec sheets preserved in the
docs/ and archive/ folders of our GitHub repository).We used Kiro as an agentic DevOps partner to systematically scaffold our backend within the
infrastructure/ folder using the AWS Cloud Development Kit (CDK). Kiro rapidly generated the TypeScript CDK stacks required to deploy our DynamoDB ledgers, EventBridge Pipes, and API Gateways. However, to ensure absolute least-privilege security and proper cross-service execution, we manually engineered and configured the complex IAM roles required to securely bind our Bedrock Agents to our Step Functions. This hybrid approach—using AI for heavy-lifting IaC scaffolding and manual engineering for strict security policies—allowed us to deploy massive serverless pipelines reliably, while utilizing GitHub Copilot (Claude 3.5 Sonnet & GPT-4o) for the final frontend React polish.The overarching system architecture is anchored by four guiding principles:
- Edge Intelligence: Powered by a state-of-the-art YOLO26 model running directly on devices via WASM.
- Agentic Orchestration: Structured as a Hybrid Multi-Agent System (HMAS) managed by Amazon Bedrock.
- Verifiable Trust: Designed around device-signed telemetry to guarantee data authenticity.
- Decentralized Participation: Inspired by a DePIN economic model to incentivize community road scanning.
Each pillar is essential for making infrastructure monitoring scalable, trustworthy, and economically viable. However, VIGIA is designed to be a vast, city-scale ecosystem. For the purpose of this demo, we intentionally focused our engineering efforts entirely on the administrative and orchestration layers: specifically, the RoadIntelligence IDE.
IMPORTANT NOTE: To deliver a robust, highly functional prototype of the core AI and geospatial workflows within the hackathon timeframe, certain end-to-end elements were scoped down. The DePIN reward system is currently simulated (without actual on-chain payouts), and the cryptographic verifiable trust layer operates as a mocked design pattern rather than a fully implemented protocol. This transparent scoping allowed us to perfect the critical serverless ingestion, Bedrock AI validation, and Amazon Location Service mapping that prove the platform's immediate, real-world viability.
RoadIntelligence IDE
The RoadIntelligence IDE treats public infrastructure monitoring similarly to version-controlled software systems, enabling city planners to observe road conditions with developer-level tooling.
Key capabilities include:
- Cities as Repositories: Geographic regions behave like version-controlled repositories where planners can "check out" specific sectors to inspect infrastructure states.
- Infrastructure Diff View: Road conditions can be compared across time intervals, highlighting degradation patterns (like a pothole expanding over a month) similar to reviewing code changes.
- Agent Trace Console: A terminal-style interface streams reasoning traces directly from the Bedrock orchestration agent, providing total transparency into how hazard validation decisions are made.
- Road Infrastructure Copilot: An embedded AI assistant that queries databases, calls endpoints, calculates repair routes, and ranks hazard priorities, massively increasing administrative efficiency.
This IDE model takes large-scale, chaotic infrastructure systems and makes them entirely observable and inspectable.
Edge AI Detection
Hazard detection occurs directly on user devices using a browser-based YOLO26 object detection model. It runs seamlessly using ONNX Runtime Web and WASM SIMD acceleration inside Web Workers.
Design decisions:
- Real-time inference executed strictly locally in the browser.
- No raw video is ever transmitted to the cloud, guaranteeing driver and public privacy.
- Only structured bounding-box metadata and GPS coordinates are transmitted.
Benefits include: ultra-low latency detection, near-zero cloud processing costs, strong privacy guarantees, and massive horizontal scalability.
City Orchestrator & Spatial Intelligence
Infrastructure validation and maintenance planning are coordinated through an advanced orchestration layer powered by Amazon Bedrock (Nova Lite).
The orchestration agent operates with four distinct Action Groups, each connected to AWS Lambda services responsible for:
- DynamoDB infrastructure queries.
- Maintenance prioritization logic.
- Geospatial intelligence analysis using Amazon Location Service (managing geofence collections and zone-aware hazard prioritization).
- AWS Step Functions planning workflows.
This design allows our AI agents to coordinate complex infrastructure intelligence while maintaining deterministic, auditable, and highly reliable workflows. All telemetry securely enters this system through a serverless ingestion pipeline utilizing Amazon API Gateway and AWS Secrets Manager.
ReAct (Reasoning and Acting) loop
Data Integrity & Future Roadmap
While VIGIA is designed to eventually support a fully decentralized network, we focused this prototype on core AI and orchestration capabilities. Infrastructure events are currently stored in Amazon DynamoDB using an append-only, structured data model.
In a full deployment scenario, VIGIA's architecture is prepared to support:
- Cryptographic Trust: Edge nodes (smartphones/dashcams) will cryptographically sign hazard telemetry using device-bound key pairs to verify the authenticity of reports.
- DePIN-Inspired Participation: A decentralized participation ledger featuring contributor reliability scoring and accuracy-weighted validation to sustainably incentivize community monitoring without centralized trust assumptions.
Cost Discipline & FinOps
A major flaw of existing municipal solutions is their exorbitant cost. VIGIA was intentionally architected with strict FinOps guardrails to remain viable within the AWS Free Tier during development, while ensuring linear, predictable scaling for enterprise deployment.
By leveraging Step Functions Express, DynamoDB (On-Demand), Lambda, and Amazon Bedrock:
- Current Prototype (7-Day Voting Phase): Estimated at just $1.39 total. We enforced strict architectural guardrails; utilizing Bedrock Nova Lite (50x cheaper than Sonnet) and avoiding heavy minimum-cost services (like Kinesis or QLDB) to maximize AWS Free Tier efficiency.
- City-Wide Scale (10,000 Nodes / 300,000 hazards/day): Projected at ~$230.80/month.
- Unit Economics: Because the architecture is 100% serverless, it maintains a constant infrastructure cost of just $0.023 per node/month regardless of scale.
This mathematically demonstrates that an enterprise-grade, cyber-physical intelligence system can operate with an incredibly low marginal cost, making it accessible even to severely budget-constrained municipalities.
Key Development Milestones
- Real-time browser inference using WASM SIMD.
- Serverless ingestion and validation pipeline deployment.
- Bedrock agent implementation with four distinct Action Groups.
- Step Functions planning workflow defined in Amazon States Language.
- Geofence-aware spatial intelligence integration.
- Multi-table DynamoDB ledger design for append-only data integrity.
Demo
Live Platform : https://main.d2nkopgztcw9g1.amplifyapp.com/
Demo : https://youtu.be/4FTbZPKuSgk
This interface demonstrates the edge detection pipeline where road hazard video input is processed locally using a browser based ONNX inference engine.
Detections are converted into structured telemetry events containing bounding boxes, GPS coordinates, and confidence scores before being transmitted to the cloud verification pipeline.
This design ensures hazard detection occurs directly on the device, minimizing latency and preserving user privacy.
AI Verification Pipeline and Agent Trace Console
After a hazard telemetry event passes the initial EventBridge ingestion filters, it enters the verification pipeline where our Amazon Bedrock "City Orchestrator" agent evaluates the report.
Instead of a simple rules engine, the Bedrock agent uses specialized Action Groups to perform complex, multi-modal reasoning:
- DynamoDB Cross-Referencing: Queries the global
HazardsTableledger to verify if the anomaly is a net-new event or an escalating, previously known issue. - Maintenance Logistics & Costing: Automatically calculates estimated repair costs and re-orders the infrastructure maintenance queue based on the hazard's severity score.
- Geospatial Zone Evaluation: Integrates with Amazon Location Service to check if the hazard intersects with highly-restricted geofences (e.g., school or hospital zones) to instantly elevate its priority.
- Bypass Orchestration: Triggers the parallel AWS Step Functions state machine to calculate financial ROI and generate mathematically safe, Bezier-based alternative routes for traffic.
The Agent Trace Console inside the IDE exposes this entire ReAct (Reasoning and Acting) loop. Instead of an AI "black box," city planners get a transparent, real-time terminal log. They can literally watch the agent's thought process (e.g., "Thought: High repair cost detected in protected zone. Action: Delegate to UrbanPlannerStateMachine") showing exactly why it made an infrastructure decision and which AWS tools it invoked to do so.
Live Infrastructure Intelligence Map
Verified hazard events are visualized on the live infrastructure map inside the RoadIntelligence IDE.
The system provides:
- Real time hazard clustering
- Geospatial inspection of affected corridors
- Severity visualization
- Historical snapshot comparison
Urban planners can inspect infrastructure health across geographic regions similarly to how developers inspect system state.
Network Surveillance and Coverage Intelligence
The Network Intelligence module analyzes node coverage across geographic regions.
Using geospatial indexing, the system evaluates:
- Detection node distribution
- Infrastructure coverage density
- Data reliability metrics
- Potential monitoring blind spots
The orchestration agent can automatically identify areas requiring additional sensing coverage.
Infrastructure Maintenance Planning Workflow
Once hazards are verified, they enter the infrastructure maintenance queue.
This interface allows operators to:
- Review verified hazards
- Inspect severity scores
- Assign repair actions
- Track infrastructure maintenance status
The workflow demonstrates how hazard intelligence transitions from detection → verification → actionable infrastructure repair planning.
What I Learned
Spec-driven development enables complex systems
Structured architecture planning prevented drift across multiple AWS services.
Edge AI redefines cost and privacy
Running inference directly on user devices reduces cloud dependency while preserving privacy.
Serverless orchestration enables deterministic AI
Step Functions workflows defined in Amazon States Language provide reliable planning pipelines.
Trust must be engineered
Cryptographic validation and append-only ledgers transform AI outputs into verifiable infrastructure events.
Incentives must follow verification
Distributed systems must reward validated truth rather than amplify unverified reports.
Closing
Road safety should never depend on delayed inspection cycles or reactive citizen complaints.
VIGIA demonstrates that the world already possesses the sensing hardware needed to monitor infrastructure continuously. By transforming everyday smartphones and fleet cameras into a distributed sensing network powered by AWS serverless architecture, VIGIA creates a real-time observability layer for public infrastructure.
Instead of roads being inspected occasionally, they become continuously monitored systems, where hazards are detected, validated, and prioritized in real time.
In the same way cloud observability transformed software reliability, VIGIA introduces infrastructure observability for cities.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article