SNTRY

AI-powered predictive maintenance and autonomous load-balancing for the EV grid.

Comment

Inspiration

The shift to electric vehicles (EVs) is the most critical infrastructure pivot of our generation, but it has a massive vulnerability: hardware reliability. At any given time, nearly a third of all public EV chargers are broken. When a charger goes down, network providers bleed revenue, and drivers are left stranded.

Current networks are entirely reactive; companies wait for a charger to physically break or for an angry driver to call support before dispatching a fix. We built Sntry to completely flip this. What if a network could predict a crash before it happens, and actually self-heal the grid using economics?

Sntry Admin Dashboard

What it does

Sntry is an autonomous AI operating system designed for EV infrastructure. It acts as an intelligence layer on top of existing chargers, functioning across three main pillars:

  1. Predictive Analytics: Sntry actively ingests live data (temperature, utilization, wait times, local traffic) and uses a Random Forest Machine Learning model to predict an impending hardware crash before the unit goes offline.
  2. Autonomous Load Balancing: If a charger is overheating due to excessive load, Sntry executes Surge Pricing. It artificially spikes the price to drop local utilization (cooling the charger down), while simultaneously discounting the nearest healthy charger to safely reroute drivers.
  3. AI Fault Dispatching: An unsupervised K-Means model calculates the mathematical root cause of the anomaly. Sntry pipes this directly into Google Gemini 2.0 Flash to generate a highly technical repair brief, commanding the technician on exactly what replacement parts to bring while routing them to the broken charger via MapLibre.

Sntry Client Map

How we built it

The Brain (Machine Learning): We trained a Random Forest model on a massive 339MB historical dataset containing 1.3 million real-world telemetry logs. Because hardware failures are statistically rare, we trained the model using balanced class weights so it wouldn't miss subtle failure patterns. The model dynamically proved to us that Estimated Wait Times (62% feature importance) and Temperature (4%) are the ultimate statistical warning signs of a crash.

The Live Ecosystem: Since we cannot hook into live EV grids yet, we built a continuous, real-time data simulation engine in our FastAPI backend. Every 10 seconds, the React frontend polls the server, which fetches the historical average of our 1.3M dataset based on the exact current month and hour. To make the live telemetry organically volatile, we injected Gaussian Distribution Noise directly into the utilization and temperature metrics.

# Simulating real-world hardware volatility
new_util = max(0.0, min(1.0, base_util + np.random.normal(0, 0.2)))
new_temp = base_temp + np.random.normal(0, 2)

The Economics: When Sntry needs to cool down a stressed charger, it calculates the Euclidean distance to find the nearest healthy neighbor. It lowers that neighbor's price by 30%, while hiking the stressed unit's price by 75%. This precisely balances the grid load without losing the customer's revenue. 

# Calculating Euclidean distance to the nearest healthy station
healthy_stations['dist'] = np.sqrt(
    (healthy_stations['latitude'] - stressed_lat)**2 + 
    (healthy_stations['longitude'] - stressed_lon)**2
)

Challenges we ran into

Our primary bottleneck was server memory limitations. Our trained Random Forest .pkl model and our massive dataset ballooned to over 800MB combined. During deployment, loading the full array into Pandas entirely exhausted our Render server's 512MB RAM cap, resulting in endless "MemoryError" crash loops.

We solved this through aggressive architecture optimization. Instead of loading the massive Machine Learning brain directly into RAM, we utilized joblib memory-mapping:

# Zero-RAM Machine Learning Initialization
model = joblib.load('predictive_maintenance_model.pkl', mmap_mode='r')

This allowed the FastAPI server to access the frozen machine learning weights directly from the persistent disk. This single change dropped our active RAM initialization from 600MB down to literally zero, keeping the server infinitely scalable.

What's next for Sntry

Sntry proved that predictive maintenance and dynamic load balancing are fully implementable software solutions that can be layered onto outdated hardware grids today.

Our next phase involves integrating Sntry directly with IoT hardware via standard MQTT protocols, allowing the AI to read true wattage limits directly from the physical cabling rather than relying purely on external telemetry projections.

Share this project:

Updates