Written By: Ben Schmirler
In a modern factory, machines do not fail loudly anymore. They whisper quietly.
A slight increase in vibration on a spindle.
A temperature curve that drifts just enough to matter.
Pressure fluctuations that only show up at full load during third shift.
For industrial manufacturers with digital manufacturing ambitions, these whispers are priceless —if you can hear the whispers and act on them in real time.
The predictive maintenance use case provides measurable business value and is directly tied to financial and operational outcomes:
- Reduced unplanned downtime – fewer unexpected failures that disrupt production and revenue
- Lower maintenance costs – service assets only when needed, avoiding unnecessary preventive work
- Higher asset availability and throughput – more reliable equipment increases production capacity
- Extended asset life – early intervention prevents catastrophic damage
- Reduced spare-parts inventory – parts are stocked based on predicted need, not worst-case scenarios
- Improved safety and compliance – fewer emergency repairs and hazardous failures
In summary, predictive maintenance protects revenue, lowers operating costs, and improves reliability—turning maintenance from a cost center into a competitive advantage. For industrial manufacturers looking to impact the balance sheet, here’s where you can start and now with the Databricks Intelligence Platform, you can do it easier, faster, and cheaper than before.
Traditionally, capturing the signals needed for predictive maintenance required complex streaming stacks: PLC → gateway → Kafka → stream processor → data lake. Each hop introduced latency, cost, and operational risk.
Databricks ZeroBus Ingest changes that equation.
In this post, we’ll walk through how ZeroBus enables a simpler, faster, factory-ready architecture for predictive maintenance—one where machines stream telemetry directly into Delta Lake, and analytics and ML respond in seconds, not hours.
The Manufacturing Reality: Why Latency Matters
Predictive maintenance isn’t about dashboards—it’s about making real-time intelligent decisions and intervening before downtime.
In industrial environments:
- A failed bearing can halt a $50k/hour production line
- Maintenance windows are tight and scheduled weeks in advance
- Teams distrust pipelines that “usually work”
This means data ingestion must be meet criteria:
- Low-latency
- Operationally boring
- Reliable at scale
ZeroBus was designed exactly for this class of problem.
What Is ZeroBus ?
Think of ZeroBus as a direct injection port into your Lakehouse.
Instead of buffering telemetry in Kafka or Kinesis, edge applications stream events straight into Delta tables using a managed Databricks ingestion service.
No brokers.
No partitions.
No offsets to manage.
Just:
Machine → ZeroBus → Delta Lake
Why manufacturers care:
- Fewer moving parts in regulated, change-averse environments
- Near real-time visibility into asset health
- Native integration with analytics, ML, and governance
Below we will cover a step-by-step tutorial on how to implement a predictive maintenance solution using the Databricks Intelligence Platform, specifically the ZeroBus capability.
Step 1: Define the Language of the Machines (Delta Schema)
Before machines talk, you define how you listen.
CREATE TABLE IF NOT EXISTS manufacturing.telemetry_bronze (
asset_id STRING,
event_ts TIMESTAMP,
temperature DOUBLE,
vibration_rms DOUBLE,
motor_current DOUBLE,
line_speed DOUBLE
)
USING DELTA;
This table represents raw machine truth—no assumptions, no aggregations.
Step 2: Streaming Telemetry from the Factory Floor (ZeroBus Client)
Imagine a small agent running on an industrial PC near the line—collecting sensor data from OPC-UA or MQTT and streaming it upstream.
Simulated ZeroBus Python Client
import time
import random
from zerobus.client import ZeroBusClient
from telemetry_pb2 import TelemetryEvent
client = ZeroBusClient(
endpoint=”your-zerobus-endpoint.databricks.net”,
auth=(“CLIENT_ID”, “CLIENT_SECRET”)
)
stream = client.open_stream(
table=”manufacturing.telemetry_bronze”
)
def read_machine():
return TelemetryEvent(
asset_id=”PRESS_17″,
event_ts=int(time.time() * 1000),
temperature=65 + random.random() * 10,
vibration_rms=0.8 + random.random() * 0.6,
motor_current=22 + random.random() * 4,
line_speed=1200
)
while True:
event = read_machine()
stream.send(event.SerializeToString())
time.sleep(0.25) # 4 events/sec
This stream:
- Runs continuously
- Writes directly to Delta
- Requires no consumer group or broker coordination
From a plant perspective, this is substantially simpler.
Step 3: Turning Noise into Signal (Streaming Analytics)
Raw telemetry is useful—but insight requires context.
We now layer Structured Streaming on top of the bronze table.
from pyspark.sql.functions import col, avg, window
bronze = (
spark.readStream
.table(“manufacturing.telemetry_bronze”)
)
features = (
bronze
.withWatermark(“event_ts”, “2 minutes”)
.groupBy(
col(“asset_id”),
window(col(“event_ts”), “1 minute”)
)
.agg(
avg(“temperature”).alias(“avg_temp”),
avg(“vibration_rms”).alias(“avg_vibration”),
avg(“motor_current”).alias(“avg_current”)
)
)
features.writeStream \
.format(“delta”) \
.outputMode(“append”) \
.option(“checkpointLocation”, “/mnt/checkpoints/features”) \
.table(“manufacturing.telemetry_features”)
Now you have rolling health indicators per asset, refreshed every minute.
Step 4: Predictive Maintenance in Motion (Model Scoring)
With features streaming, ML becomes operational.
import mlflow.pyfunc
model = mlflow.pyfunc.load_model(
“models:/maintenance_failure_model/Production”
)
scored = features.withColumn(
“failure_risk”,
model.predict(
features.select(“avg_temp”, “avg_vibration”, “avg_current”)
)
)
alerts = scored.filter(“failure_risk > 0.85”)
alerts.writeStream \
.format(“delta”) \
.outputMode(“append”) \
.table(“manufacturing.maintenance_alerts”)
These alerts can:
- Trigger a CMMS work order
- Notify a reliability engineer
- Be visualized live in a control room
Why ZeroBus Changes the Game for Manufacturers
Traditional Streaming Stack
- Kafka clusters
- Schema registries
- Consumer lag tuning
- Cross-team ownership battles
ZeroBus Model
- Serverless ingestion
- Delta as the system of record
- Unified governance
- Fewer failure modes
For manufacturers modernizing from batch-driven MES exports, ZeroBus is often the first streaming architecture that actually fits their operational constraints.
When ZeroBus Is (and Isn’t) the Right Tool
✅ Great fit
- Machine telemetry
- Predictive maintenance
- Plant-to-cloud ingestion
- Single analytics platform (Databricks)
⚠️ Less ideal
- Multi-consumer pub/sub fan-out
- Long-term message replay requirements
- Event routing across many downstream systems
ZeroBus, in a manufacturing setting, often replaces complexity where it matters most, in the plant floor and within a work cell. I hope you enjoyed the ZeroBus tutorial and will apply the concepts in your own Databricks workspace. If you are looking to try this yourself, I recommend using the public Databrick’s documentation below.
- https://docs.databricks.com/aws/en/ingestion/lakeflow-connect/zerobus-ingest
- https://github.com/databricks/zerobus-sdk-py
- https://github.com/databricks/zerobus-sdk-java
- https://github.com/databricks/zerobus-sdk-rs
- https://github.com/databricks/zerobus-sdk-ts
- https://github.com/databricks/zerobus-sdk-go
Final Thoughts
Here at Xorbix Technologies we make the complex simple and having a platform like Databricks that understands and aligns to that same notion by making their product simple and easy to use makes a big difference in the field for our customers.
