Volta

Volta turns every electric vehicle into a backup battery for the city. When a substation fails, the cars on the street keep the lights on — in under 2 seconds.

Comment

⚡ Volta

The city, in sync. Real-time power-traffic co-simulation with vehicle-to-grid energy trading.

Python · PyPSA · SUMO · Flask

🎯 The Pitch

Every EV on the road is also a battery for the city. Volta is a real-time digital twin of Manhattan's power grid and traffic system — coupling PyPSA power-flow analysis with a full Eclipse SUMO traffic microsimulation to make vehicle-to-grid energy trading real at city scale.

When a substation crosses its 90% loading threshold, Volta prices the energy, finds nearby high-SOC vehicles, and dispatches their stored power back into the grid — in under 2 seconds.

💡 Inspiration

Cities didn't break overnight, but they're breaking on schedule. Our substations are aging. EV adoption is outpacing the grid's ability to charge the cars that own it. Renewables promise clean power but need flexible storage to stay stable — and blackouts keep costing billions.

The people responsible for all of it sit in silos. Grid planners have their power-flow models. Traffic engineers have their road networks. They never share a screen — until a hot summer afternoon decides otherwise.

V2G has been proven in theory for years. Every EV has a battery when it's parked. But almost no one simulates it at city scale — on a real grid, with real streets, with real traffic moving through them.

We built Volta to answer one question: what if every EV on the street was also a battery for the city?

⚡ What It Does

One continuous system — not a collection of demos.

Capability What it does
⚡ Live power flow PyPSA DC power-flow on 8 Manhattan substations
🚗 Traffic microsimulation Eclipse SUMO with configurable EV %
🔋 Vehicle-to-grid dispatch EVs push power back when substations overload
🆘 Emergency response Auto-dispatch when a substation crosses 90% load
💰 Dynamic pricing $0.15/kWh market pricing with revenue optimization
🎮 Real-time dashboard Mapbox live map, glassmorphic UI
🧠 AI analytics Conversational operator chat over live grid state
📡 REST + WebSocket API Full operator control surface

Traffic moves through Manhattan's street network. Each EV carries a battery that drains, charges, and can discharge. Every substation runs real power-flow physics. When the grid is stressed, Volta sees it, prices it, and responds — all while the operator watches the whole city on a single live map.

  • ⚡ 8 live substations — real DC power-flow, not mock data
  • 🔋 Bidirectional V2G — every EV is dispatchable storage
  • 🧠 AI in the loop — an operator chat over live grid state

🏗️ How We Built It

A continuous loop between traffic, batteries, and the grid.

      ┌─────────────┐     ┌─────────────┐     ┌─────────────┐
      │    SUMO     │ ──▶ │    PyPSA    │ ──▶ │  V2G Manager│
      │  Traffic    │     │   Grid      │     │   Dispatch  │
      └─────────────┘     └─────────────┘     └─────────────┘
             ▲                                      │
             │                                      ▼
      ┌─────────────┐     ┌─────────────┐     ┌─────────────┐
      │   Flask     │ ◀── │  WebSocket  │ ◀── │   Operator  │
      │  Backend    │     │   Stream    │     │   Control   │
      └─────────────┘     └─────────────┘     └─────────────┘

The loop is continuous: traffic → EV battery state → grid load → V2G dispatch → visualization. SUMO moves every vehicle through Manhattan and tracks each EV's battery; that state feeds the PyPSA grid model, where real power-flow equations compute load on every bus; the V2G manager prices and dispatches energy when a substation crosses its threshold; and the Flask backend streams the whole picture over WebSocket.

1️⃣ Traffic simulation moves vehicles through real Manhattan streets 2️⃣ Battery state feeds each EV into the grid model 3️⃣ Power flow calculates load on all 8 substations 4️⃣ V2G dispatches stored energy when a substation overloads 5️⃣ Operators see everything live — and can intervene with one click

┌──────────────────────────────────────────────────────────────────┐
│                     Web Frontend                                 │
│   Mapbox visualization • Real-time controls • Live dashboards     │
└───────────────────────────────┬──────────────────────────────────┘
                                │  REST + WebSocket
┌───────────────────────────────▼──────────────────────────────────┐
│                      Flask Backend                               │
│   REST API • WebSocket broadcast • Data processing • Orchestration│
└───────────────┬───────────────────────────────┬──────────────────┘
                │                               │
┌───────────────▼──────────┐   ┌────────────────▼──────────────────┐
│      SUMO Simulator      │   │          PyPSA Grid               │
│  Vehicles • Routing      │   │  Power flow • Load • Stability    │
│  Traffic microsimulation │   │  8 substations • 13.8kV/480V      │
└───────────────┬──────────┘   └────────────────┬──────────────────┘
                │                               │
                └───────────────┬───────────────┘
                                │
                ┌───────────────▼───────────────┐
                │         V2G Manager           │
                │  Energy trading • Dynamic      │
                │  pricing • Emergency dispatch  │
                └────────────────────────────────┘
Component Role
🎨 Web Frontend Mapbox live map, glassmorphic UI, one-click operator controls
🐍 Flask Backend REST API, WebSocket broadcast, orchestration of every subsystem
🚗 SUMO Simulator Vehicles, routing, battery-aware traffic microsimulation
⚡ PyPSA Grid Real DC power flow, load balancing, stability tracking
🔋 V2G Manager Energy trading, dynamic pricing, sub-2-second emergency dispatch
🧠 AI Analytics Anomaly detection, demand insight, conversational operator chat

🔬 Architecture Deep Dive

Four subsystems, one synchronized city.

⚡ PyPSA Grid

Property Value
Substations 8 (Manhattan distribution model)
Voltage levels 13.8 kV primary / 480 V secondary
Analysis type DC power flow, real-time
State tracked Bus load, line flow, stability margin

🚗 SUMO Traffic

Property Value
Simulator Eclipse SUMO
Fleet size Up to 1,000 concurrent vehicles
EV penetration Configurable 0–100%
Battery model SOC-aware routing and charging

🔋 V2G Manager

Property Value
Flow direction Bidirectional (charge + discharge)
Dispatch trigger 90% substation loading threshold
Response time < 2 seconds
Power per vehicle Up to 250 kW
Market price $0.15/kWh

🧠 AI Analytics

Property Value
Interface Conversational operator chat
Backend ML engine over live grid state
Capabilities Anomaly detection, demand insight, stability analysis

The city, in sync. — every byte of grid state and every EV on the road, on one live map.

🧗 Challenges We Ran Into

Real problems from coupling two hard simulators into one loop.

Challenge How we solved it
Coupling SUMO and PyPSA at 100 ms resolution Shared event loop with timestamped state sync
EV battery behavior at scale (1,000 vehicles) Per-vehicle SOC model with charging/discharging logic
Emergency dispatch under 2 seconds Pre-indexed vehicle lookup by location + SOC
Dynamic pricing without market volatility Fixed $0.15/kWh baseline with revenue optimization layer
Real-time WebSocket streaming Event-driven Flask backend pushing state at 100 ms
Grid stability under failure scenarios Scenario controller with reproducible failure injections

❌ What others do vs ✅ What Volta does

❌ Others ✅ Volta
Dashboard on static, pre-computed data Live co-simulation of two real engines
EVs as passive loads EVs as dispatchable, bidirectional storage
Slow polling state updates WebSocket streams at 100 ms cadence
One-off scripts, unverifiable Reproducible scenarios, CI-tested
90% loading treated as a warning 90% loading triggers automatic V2G dispatch

🏆 Accomplishments We're Proud Of

Moments that made the whole city click.

  • City-scale co-simulation — power and traffic coupled in one continuous loop, so what happens on the street shows up on the grid.
  • Sub-2-second V2G — emergency dispatch fast enough to matter when a substation is about to fail
  • Real grid topology — 8 Manhattan substations, real voltage levels, 13.8 kV and 480 V distribution.
  • Full operator dashboard — Mapbox live map, glassmorphic UI, live telemetry, one-click fail/restore/V2G controls.
  • Open, self-hostable — MIT licensed, Docker/Kubernetes ready.

Fast enough to matter. Real power-flow physics, real traffic microsimulation, real V2G economics — one system, under 2 seconds.

📊 Key performance numbers — measured against the reference Manhattan deployment:

Metric Value
Concurrent vehicles Up to 1,000 simulated simultaneously
Update cadence 100 ms real-time grid resolution
V2G emergency response < 2 s from threshold breach to dispatch
API latency < 50 ms average response time
Scalability Horizontally scalable via Docker / Kubernetes

📚 What We Learned

Seven hard-won engineering lessons.

  • ⚡ Power-flow simulation with PyPSA — real DC power flow, not canned curves.
  • 🚗 Traffic microsimulation with SUMO — vehicles that actually route, congest, and charge.
  • 📡 Real-time WebSocket architecture at city scale — state that flows, not snapshots that lag.
  • 💰 V2G dispatch economics and emergency response design — pricing that's transparent, dispatch that's decisive.
  • 🔗 Coupling two hard simulators into one continuous loop — the integration is the hard part, and it works.
  • 🎮 Building operator dashboards that don't drown in data — one screen, the whole city.
  • 🔧 Deploying research-grade systems with CI and reproducibility — lint, security scanning, unit tests, integration tests, and containerized builds on every push.

🚀 What's Next for Volta

The city is only the first mile.

  • 🌤️ Weather-aware dispatch — let a heatwave or cold snap tune demand prediction before the grid feels it.
  • 🔮 ML demand forecasting — push the analytics layer to predict load shifts before they're emergencies.
  • 🌍 Multi-city rollout — the pipeline is city-agnostic; Manhattan is only the first mile.
  • ☀️ Renewables (solar/wind) integration — intermittent generation, met by dispatchable EV storage.
  • 📱 Mobile operator companion — the operations center in your pocket, alerts before the lights go out.

🥇 Why Volta — Judging Criteria at a Glance

Scored the way a judge thinks.

Criterion How Volta answers it
Originality Live power-traffic co-simulation with V2G dispatch — not a dashboard on mock data
Adherence to Track Earth Forward: renewable-ready grid, EV-as-storage, climate-resilient cities
Completion Working simulators, live dashboard, REST + WebSocket API, CI, docs
Learning Coupled two hard simulators, real V2G logic, sub-2s emergency dispatch
Design Glassmorphic operations center, live map, one-click operator controls
Technology PyPSA + SUMO + Flask + WebSocket + AI analytics

🧰 Built With

python pypsa eclipse-sumo flask websocket mapbox pandas numpy scikit-learn docker kubernetes pytest github-actions

🔗 Links

🌱 Footer

Built for NextStep Hacks 2026 — Earth Forward 🌱

Built With

Share this project:

Updates

Submission history