Picture this: a plant with thousands of electric motors, pumps, and compressors. One sudden failure — and the conveyor stops for 4 hours. Losses up to 2 million rubles per stoppage. Most enterprises follow a replacement schedule of "every 1000 operating hours" while the actual condition of the units remains a mystery until the last moment. We build an AI predictive maintenance (PdM) system that removes uncertainty.
We use data from vibration, current, and temperature sensors. We train models to detect incipient defects 2-6 weeks before failure. We connect to CMMS so that work orders are created automatically. The customer receives a Health Index for each asset, maintenance timing recommendations, and transparent ROI. Our experience: 5+ years in industrial AI, dozens of deployed systems. PdM reduces unplanned downtime 3-5 times compared to scheduled maintenance.
What Problems Does the AI Predictive Maintenance System Solve?
- Unexpected downtime: traditional maintenance is schedule-based or after failure. We predict remaining useful life (RUL) and set precise maintenance dates.
- Suboptimal maintenance frequency: too often — waste; too rare — risk. We optimize based on FMEA and an economic model.
- False alarms: standard threshold methods give 30-60% false positives. Our ML ensemble reduces FP to 5%.
How We Build the System: Platform Architecture
The system covers all levels from sensors to business KPIs:
Level 0: Edge (on equipment)
Modules: vibration sensor, temperature sensor, current meter
Protocol: Modbus RTU / OPC-UA
Edge gateway: Raspberry Pi / Industrial PC
Level 1: Fog (workshop level)
OPC-UA Server → MQTT broker → Edge computing node
Local storage and initial processing
Level 2: Cloud (enterprise level)
Kafka → TimescaleDB / InfluxDB
ML Training Pipeline (Airflow + MLflow)
Inference Service (FastAPI)
Level 3: Business
CMMS / ERP integration
KPI Dashboard (Grafana / Tableau)
Mobile app for technicians
For each asset we create a record in the Asset Registry:
@dataclass
class Asset:
asset_id: str
name: str
type: AssetType # motor, pump, compressor, conveyor, gearbox
manufacturer: str
model: str
install_date: datetime
rated_power_kw: float
location: dict # plant, line, cell
criticality: int # 1-5 (5 = most critical)
sensors: list[SensorConfig]
maintenance_history: list[WorkOrder]
failure_modes: list[FailureMode] # from FMEA document
FMEA-Driven Failure Analysis: The Prediction Foundation
Instead of a black box, we use FMEA — we document each expected failure, its indicators, and typical development time. Example for an electric motor:
failure_modes_motor = [
FailureMode(
name='bearing_outer_race_defect',
detection_method='vibration_envelope_bpfo',
leading_indicators=['kurtosis > 3', 'bpfo_amplitude_rise'],
typical_development_days=30,
severity=4
),
FailureMode(
name='stator_winding_degradation',
detection_method='motor_current_signature_mcsa',
leading_indicators=['current_imbalance > 5%', 'sideband_frequencies'],
typical_development_days=60,
severity=5
),
FailureMode(
name='misalignment',
detection_method='vibration_1x_2x',
leading_indicators=['high_1x_radial', '2x_axial_component'],
typical_development_days=14,
severity=3
)
]
Hierarchical Health Index: From Sensor to Plant
Health Index — from 0 (failure) to 1 (perfect). Calculated at each level: sensor → asset → line → workshop. Each failure mode has its own ML model, results aggregated with severity weight:
class AssetHealthEnsemble:
def __init__(self, failure_modes, weights=None):
self.failure_modes = failure_modes
self.models = {fm.name: load_model(fm) for fm in failure_modes}
self.weights = weights or {fm.name: fm.severity for fm in failure_modes}
def compute_health(self, sensor_data):
fm_scores = {}
for fm_name, model in self.models.items():
features = extract_features_for_fm(sensor_data, fm_name)
failure_prob = model.predict_proba([features])[0][1]
fm_scores[fm_name] = 1.0 - failure_prob
weighted_health = sum(score * self.weights[name] for name, score in fm_scores.items()) / sum(self.weights.values())
min_score = min(fm_scores.values())
if min_score < 0.3:
weighted_health = min(weighted_health, min_score * 1.5)
return weighted_health, fm_scores
Plant health is a criticality-weighted average of asset health. A critical defect on one unit lowers the overall index.
Optimizing Maintenance Timing: Balancing Cost and Risk
We balance maintenance cost against failure risk. The model uses the remaining useful life (RUL) distribution and solves for expected cost minimization:
from scipy.optimize import minimize_scalar
def optimal_maintenance_time(rul_distribution, maintenance_cost, failure_cost, holding_cost_per_day):
def expected_cost(t_maintenance):
p_failure_before_maintenance = rul_distribution.cdf(t_maintenance)
cost_if_maintain = maintenance_cost + t_maintenance * holding_cost_per_day
cost_if_fail = failure_cost * p_failure_before_maintenance
return cost_if_maintain * (1 - p_failure_before_maintenance) + cost_if_fail
result = minimize_scalar(expected_cost, bounds=(1, 180), method='bounded')
return result.x # optimal days until maintenance
Result: a Work Order with specific due date and priority. At one cement plant, this algorithm predicted a mill bearing failure 18 days in advance, allowing replacement during scheduled downtime and avoiding an emergency stop. System ROI was 400% in the first year.
Maintenance Approach Comparison
| Characteristic | Reactive | Scheduled | Predictive (PdM) |
|---|---|---|---|
| Maintenance cost | Low before failure, high after | Average, often excessive | Optimized |
| Downtime | Maximum | Planned, but may be excessive | Minimal, only when needed |
| Prediction accuracy | None | None | 85-95% for 2 weeks ahead |
| CMMS integration | None | Yes | Automatic WO generation |
| ROI | Negative | Zero or weak | 200-500% per year |
What Does Predictive Maintenance Deliver in Practice?
Typical results 6 months after deployment: 70-80% reduction in unplanned downtime, 30% increase in mean time between interventions, 20% reduction in maintenance costs. The system automatically generates Work Orders in CMMS (SAP, 1C) based on predictions, with no human intervention.
What's Included in the Work
- Equipment audit and data collection (SCADA archives, logs, schematics)
- IoT network architecture design and edge devices
- Asset Registry creation and FMEA model
- ML model development (vibration, current, temperature) and ensemble
- Model deployment on edge/cloud with inference service
- CMMS integration (SAP, 1C, custom)
- Health Index dashboard and KPIs (Grafana / Tableau)
- Technician training on the system
- 6 months of post-launch support
What Guarantees Do We Offer?
Our team: 5+ years in industrial AI and IoT. 10+ deployments in plants across Russia and CIS. We guarantee quality: if the system does not prove its effectiveness within 3 months, we refine it free of charge.
Example Economic Efficiency Calculation
For a plant with 50 critical assets and average downtime loss of 1 million rubles per hour, the system pays for itself in 4-6 months. Detailed calculation provided during the audit phase.Timeline and Cost
Basic solution (up to 10 assets): 8-10 weeks. Full-scale system (100+ assets): 5-8 months. Cost is calculated individually. Contact us for a project assessment — get an engineer consultation.
Get a calculation for your plant. Order a preliminary audit.