Predictive maintenance, powered by AI
Predict failures.
Prevent downtime.
In our capstone project, we built a predictive-maintenance system that catches machine failures before they happen. Running on simulated CNC sensor data, it shows how manufacturing teams could maximize uptime and efficiency.
Live Factory.
Real Predictions.
The system can watch CNC milling machines around the clock. The moment tool wear, or process temperature starts to shift, it catches the change — often hours before that could cause a failure.
The AI + MLOps loop behind continuous reliability
One system. One loop. Always learning.
-
1. Collect Sensors on the machines send real-time readings — temperature, vibration, pressure — every few seconds. Nothing else in this loop works without this: it’s the raw material every prediction is built on. Think of it as the system’s eyes and ears on the factory floor.
Stream sensor data from the machines in real time.
-
2. Predict AI models look at those incoming readings and continuously estimate how likely each machine is to fail soon. Instead of waiting for a scheduled inspection, you get an early, ongoing read on machine health. This is what turns raw sensor data into a warning you can actually act on.
AI models assess failure probability continuously.
-
3. Detect The system watches for two kinds of change: early warning signs of failure, and a shift in the incoming data itself (called "drift") that could make predictions less reliable. Catching drift automatically means problems get flagged before predictions quietly get worse. This step is what keeps the whole loop trustworthy.
Anomalies and drift are caught early and automatically.
-
4. Retrain When drift or new patterns are detected, the model is automatically retrained on the freshest data — no engineer has to notice a problem and kick it off by hand. This keeps predictions accurate as machines age or conditions change. It’s what makes this a living system instead of a one-time model that slowly goes stale.
Models retrain on fresh data through the pipeline.
-
5. Improve With an up-to-date model back in place, predictions get sharper instead of drifting downward over time. That means fewer surprise breakdowns and less time and money spent on unnecessary maintenance. This is where the loop pays off — every trip around Collect → Predict → Detect → Retrain leaves the system a little better than before.
Predictions get better over time — cutting downtime and cost.
-
Business Impact All of the above adds up to fewer unplanned stoppages, lower maintenance costs, and equipment that lasts longer before it needs replacing. This is the reason the whole loop exists — every technical step earns its place by producing this outcome. The results then feed back into Collect, so the improvement never stops.
Increase uptime. Lower costs. Extend asset life.
feeds back into Collect — always learning
What the system can help with
Fewer surprises. Lower costs. Longer-lasting machines.
Reduce Downtime
Prevent unexpected failures and unplanned stops.
Extend Asset Life
Catch issues early and reduce wear and tear.
Lower Maintenance Costs
Replace parts based on actual condition, not guesswork.
Increase Operational Efficiency
More uptime. Smoother operations. Happier teams.
While the dayshift sleep…
The system is able to monitor the machines all night.
Illustrative example-
02:16 AM
Drift Detected
Tool-wear shift spotted on CNC-01 by Evidently AI.
-
02:17 AM
Pipeline Triggered
The GitHub Actions pipeline kicks off automatically.
-
02:28 AM
Model Retrained
A fresh model trains on the latest factory data.
-
02:45 AM
Model Promoted
The new version beats the old one and goes live automatically.
-
06:47 AM
System Healthy
The maintenance lead opens the dashboard. No calls. No incidents.
Overnight Impact
Illustrative example- 1 potential failure prevented
- ~8 hours of downtime avoided
- €24,300 saved
- Production stayed on track
A walkthrough of one night — not aggregated customer data.
Try your own numbers in the calculator below ↓.
One system. Always learning. Always protecting.
Scenario: You are in charge of a factory
What could this save you?
Drag the slider to roughly what unplanned downtime costs you each month.
You may have seen bigger downtime numbers elsewhere — here’s where four widely-cited figures actually sit.
If nothing changes
€15,000
With predictive maintenance
€2,700
Estimated savings
€12,300 / month
Trees saved (equivalent) A rough, illustrative comparison, not a carbon calculation — this project’s model predicts failures, not emissions. Unplanned downtime commonly wastes energy (idle machines, restart surges, scrapped material); we compare the scale of that avoided waste to a mature tree’s yearly CO2 absorption (~21kg), using €1,500 saved per year ≈ one tree. Meant to give a feel for the scale, not a precise figure.
98 / year
live · updated hourly · This model currently catches 82% of failures before they happen. We use the model’s real recall rate — how many of the real failures it catches in advance. For example, since it currently catches 82% of failures, we assume 82% of your downtime cost is avoided too. It’s one real, live number, not a marketing multiplier — but it’s still an estimate. Your actual savings depend on your own failure costs, response times, and operations. See the live number →
For the technical reader
The MLOps System Behind the Predictions
The same loop from How it works — now with the tools that run it.
Built with
- The programming language the whole system is written in — one of the most common languages for data science and machine learning.
Python
Data processing & modeling
- A Python library for loading, cleaning, and reshaping tabular data — think of it as a scriptable, programmable spreadsheet.
Pandas
Data analysis
- A Python library of ready-made machine learning algorithms. This is what the failure-prediction model itself is built and trained with.
Scikit-learn
ML modeling
- The fast, low-level number-crunching library that Pandas and Scikit-learn are both built on top of — rarely used directly, but doing most of the heavy lifting underneath.
NumPy
Numerical computing
1. Sensor Data This is the same “Collect” step from How It Works, shown here as the actual system piece that receives it: an ingestion point that takes in live sensor readings (or simulated ones, for the demo) and hands them to the prediction model.
2. Predict API A small web service with one job: take in a sensor reading and return a failure-probability score, in real time. “API” just means “a way for one piece of software to ask another for something” — here, asking for a prediction.
3. Drift Check Evidently is an open-source tool that statistically compares today’s incoming sensor data against the data the model was originally trained on. If the two have drifted too far apart, that’s an early sign the model needs retraining before its predictions quietly get worse.
4. CI/CD GitHub’s built-in automation runner. When drift is flagged, this is what actually kicks off the retraining job in the background — no engineer has to notice the alert and start it by hand.
5. DVC DVC ("Data Version Control") works like Git, but for datasets and models instead of code. It keeps a versioned record of exactly which data produced which model, so every retraining run is traceable and repeatable.
6. MLflow MLflow logs every training run’s results side by side, so a new model can be compared against the one currently live. Only a model that’s actually better gets "promoted" to production.
Powered by
- The open-source library that watches for drift — comparing live production data against the training data on an ongoing basis, not just once at launch.
Evidently AI
Data & model drift monitoring
- A free automation service built into GitHub. It’s the engine that runs the retraining pipeline on a trigger or schedule — no separate server to babysit.
GitHub Actions
Automated CI/CD for ML
- Short for "Data Version Control" — same tool as in the diagram above. It’s what makes "which data trained this exact model" an answerable question instead of a guess.
DVC
Data version control
- Experiment tracking and model registry, in one tool. Every training run gets logged and compared, and whichever model is currently "promoted" is the one serving live predictions.
MLflow
Experiment tracking & model registry
Automated
No manual retraining
Reproducible
DVC-versioned data & pipeline
Monitored
Evidently drift checks
Open-source stack
Runs on your own machine