AWS Builder Center
Building PulseTrust_: The Definitive Guide to Trust-Based Industrial IoT Monitoring

Building PulseTrust_: The Definitive Guide to Trust-Based Industrial IoT Monitoring

How PulseTrust_ combines ESP32 telemetry, Isolation Forest, and a deterministic trust engine — deployed on Amazon ECS and AWS Amplify — to score sensor trust before acting on a reading.

PulseTrust_  |  Trust Before Action
Machines can produce a constant stream of sensor readings, but an abnormal measurement does not automatically mean the sensor is failing. You've probably already watched a monitoring dashboard flash red over a single strange number, only to find out later that nothing was actually wrong with the equipment. In this guide, we'll walk through how we built PulseTrust_, an industrial IoT monitoring prototype that asks a different question — not "is this reading unusual?" but "can this reading be trusted?"

Key Takeaways

·        PulseTrust_ is an industrial sensor-trust and machine-monitoring prototype built around the principle “Trust Before Action.”
·        An abnormal sensor reading does not automatically mean the sensor is faulty; PulseTrust_ evaluates measurement trust separately from machine and process health.
·        The system combines ESP32 telemetry, Supabase sensor history, Isolation Forest anomaly detection, redundant sensor comparison, and deterministic trust scoring.
·        PulseTrust_ turns sensor evidence into interpretable trust scores, states, and reasons instead of simply displaying raw machine readings.
·        Gemini adds an explanation layer for the trust evidence, while the deterministic trust engine remains responsible for calculating the trust score.
·        The working cloud pipeline connects physical sensors to an ESP32, a containerized FastAPI backend on Amazon ECS, Supabase, and a public dashboard hosted with AWS Amplify.
·        Built as a hackathon prototype, PulseTrust_ establishes a foundation for broader sensor coverage, validated training data, stronger access controls, and production-grade deployment hardening.

What Is PulseTrust_, and What Problem Does It Solve?

PulseTrust_ is an industrial sensor-trust and machine-monitoring prototype that combines ESP32 telemetry, Supabase history, Isolation Forest anomaly detection, redundant sensor comparison, and deterministic trust scoring. We built it during a hackathon to answer a question that most  industrial IoT monitoring  systems skip over entirely: when a sensor reports something strange, is the machine actually behaving strangely, or is the sensor itself unreliable?
That question sits at the center of a design principle we called Trust Before Action. Before any alert, dashboard color, or maintenance decision is generated from a reading, PulseTrust_ tries to establish how much that reading deserves to be trusted. This matters because a control system or maintenance team that acts on an untrustworthy reading can cause just as much trouble as one that ignores a real fault.
At the heart of PulseTrust_ is a distinction we kept returning to throughout the build: an abnormal measurement and a faulty sensor are not the same thing. A temperature spike could be a motor genuinely overheating, or it could be electrical noise or drift in a single sensor. PulseTrust_ was designed to tell these situations apart using evidence rather than guesswork.

Why Does an Abnormal Sensor Reading Not Necessarily Mean a Sensor Is Faulty?

An abnormal sensor reading does not necessarily mean a sensor is faulty because industrial environments produce real, transient events that can look unusual on paper. PulseTrust_ evaluates measurement trust separately from process health because collapsing these two ideas into one anomaly score throws away useful information.
Consider a single overheating sensor on a factory floor. If a monitoring system only asks “is this number outside the normal range?” it flags the reading and stops there. That single signal cannot tell you whether the machine has a problem or the sensor does, and the response to each situation is completely different.
This is where redundancy earns its keep. By comparing readings from multiple sensors placed on or near the same equipment, PulseTrust_ can check whether other sensors agree with the one reporting the anomaly. If two independent temperature sensors on the same machine diverge sharply, that disagreement itself becomes evidence about measurement trust.
The stakes behind this distinction are large at an industry level. The original research used for this article cites MarketsandMarkets (2024), Fluke (2025), and Siemens (2024) to illustrate the scale of industrial IoT adoption and the cost of unplanned downtime. The key design takeaway for PulseTrust_ is simple: decisions built on machine telemetry need evidence about the reliability of that telemetry, not just a reading and a threshold.

How Does PulseTrust_ Determine Whether Sensor Data Can Be Trusted?

PulseTrust_ determines sensor trust by combining anomaly detection, redundant sensor comparison, and a deterministic scoring layer into a single trust engine. Rather than trusting one model's opinion, the system gathers multiple pieces of evidence before deciding how much confidence a reading deserves.

How Do ESP32 Telemetry, Supabase, Isolation Forest, and the Trust Engine Work Together?

The PulseTrust_ architecture sends telemetry from physical  ESP32 telemetry  through an ESP32 over HTTPS to a containerized FastAPI backend running on Amazon ECS. FastAPI validates and routes each reading into  Supabase sensor history , where sensor history can be used for feature extraction and trust analysis.
That history matters because a single reading means very little on its own. PulseTrust_ derives behavioral features from recent telemetry, evaluates unusual behavior with Isolation Forest, and compares redundant sensors for agreement. These evidence streams feed the deterministic trust engine, which produces the final trust score, state, and reasons.

Figure 1. PulseTrust_ system architecture: physical sensors flow through ESP32 and AWS ECS to trust analysis, explanation, and the dashboard.

The Deterministic Trust-Scoring Mechanism

The trust engine evaluates each temperature sensor independently with an Isolation Forest model, compares redundant temperature readings, and combines the evidence into an overall trust score and trust state.  Isolation Forest anomaly detection  flags statistically unusual behavior in a sensor's recent pattern, addressing the question: “is this behavior unusual for this sensor?”
Sensor comparison handles a different question: do nearby redundant sensors agree? By layering these signals together,  deterministic trust scoring  converts evidence into a trust score and a state such as TRUSTED, DEGRADED, or UNTRUSTED, together with reasons for that state.
PulseTrust_ uses Gemini to explain trust evidence, while the deterministic trust engine — not Gemini — calculates and controls the trust score. This separation keeps generative AI out of the safety-critical arithmetic: The  Gemini explanation layer  translates the engine's evidence into a readable explanation for a human operator but does not override or recalculate the score.

What Does the PulseTrust_ Dashboard Show?

The PulseTrust_ dashboard provides an overall trust-score overview, live telemetry panels, per-sensor trust evidence, charts, event information, and technical diagnostics. This gives an operator a single interface that answers both “what is the machine doing?” and “how much should I trust what I'm seeing?”

Figure 2. PulseTrust_ live monitoring dashboard showing the trust-score overview, current assessment, telemetry-driven digital twin, and live telemetry panels.
The  real-time sensor monitoring dashboard  is built with HTML, CSS, and JavaScript and consumes the FastAPI backend directly. Keeping the frontend lightweight made the data flow transparent and helped the team debug API-contract issues quickly under hackathon time pressure.

Technology Stack

Layer
Technology
Role
Sensing & telemetry
ESP32, C++
Reads physical sensor values and streams telemetry over the network
Backend API
FastAPI, Python on Amazon ECS
Validates, processes, and serves incoming telemetry
Container delivery
Docker, Amazon ECR
Packages and stores the backend container image
Data storage
Supabase
Stores sensor history for analysis and feature extraction
Anomaly detection
Isolation Forest
Flags statistically unusual sensor behavior
Trust logic
Deterministic trust engine
Combines anomaly and cross-sensor evidence into trust scores and states
Explanation layer
Gemini
Generates human-readable explanations from trust evidence
Dashboard
HTML, CSS, JavaScript on AWS Amplify
Displays telemetry, trust scores, digital-twin status, and diagnostics

How Did We Build PulseTrust_ Under Hackathon Constraints?

Building PulseTrust_ meant assembling hardware, a backend, a machine-learning layer, cloud infrastructure, and a frontend into one working system inside a fixed hackathon window. The team split the build into parallel tracks — hardware and telemetry, backend and trust logic, and dashboard and cloud deployment — so work could progress without blocking on a single component.

How Did We Integrate AWS Into the PulseTrust_ Build?

PulseTrust_ is deployed on AWS rather than existing only as a local cloud demonstration. The FastAPI backend is containerized with Docker, stored in  Amazon ECR , and runs on  Amazon ECS . The public dashboard is hosted through  AWS Amplify . The ESP32 sends physical telemetry over HTTPS to the ECS backend, which processes the data, works with Supabase history and the trust pipeline, and exposes the results to the Amplify-hosted frontend.

Figure 3. PulseTrust_ FastAPI backend running on Amazon ECS, with live CPU, memory, response-time, and request metrics demonstrating the deployed cloud workload.
This gave the team a true end-to-end path from physical hardware to a public cloud application: Sensors → ESP32 → HTTPS → FastAPI on AWS ECS → Supabase and trust analysis → AWS Amplify dashboard. The deployed system can continue serving the dashboard and API independently of the development laptop.

What Challenges and Integration Problems Did We Encounter While Building PulseTrust_?

Several integration gaps fought back throughout the build. The telemetry pipeline needed consistent formatting between the ESP32 firmware and FastAPI backend, and early mismatches could silently drop or malformed readings before the team caught them.
The frontend and API contracts also did not always line up on the first pass. A field represented differently on one side could cause a dashboard panel to show blank or stale data, so the team tightened the mapping between backend evidence and frontend presentation.
Verifying the trust engine against every real hardware failure mode was beyond the hackathon timeline. The team tested normal operation, sensor disagreement, and corroborated abnormal events, but a production system would require substantially more labeled real-world data, calibration, and validation.
During the final demo setup, the physical magnet used by the Hall sensor for RPM measurement became unavailable. To keep the rest of the physical pipeline intact, the demo uses an explicitly simulated RPM/Hall fallback while temperature, vibration, voltage, current, power, fan state, ESP32 networking, cloud ingestion, trust processing, and dashboard updates continue through the live system.

What Comes Next for PulseTrust_ Beyond the Hackathon Prototype?

PulseTrust_ is a hackathon prototype rather than a certified industrial safety system. The current deployment proves the concept end to end, while production use would require broader sensor support, validated training data, stronger security, calibration, reliability testing, and deployment hardening.
·        Broader sensor coverage — extend trust scoring beyond temperature to vibration, pressure, flow, and other industrial signals.
·        Validated training data — replace bootstrap/synthetic anomaly examples with labeled data from real equipment and documented failure modes.
·        Production security — add authentication, role-based permissions, certificate validation on embedded clients, secret management, and least-privilege cloud identities.
·        Reliability and calibration — validate sensor placement, timing, sampling, cross-sensor tolerances, and trust thresholds against real machinery.
·        Operational deployment hardening — add observability, alarms, backup/recovery planning, cost controls, and repeatable infrastructure deployment.

Conclusion: From Sensor Readings to Trusted Evidence

Trust Before Action captures what PulseTrust_ set out to prove: a monitoring system should establish how much a reading can be trusted before treating it as a fact about the machine. Across the ESP32 telemetry layer, Supabase-backed history, Isolation Forest model, redundant sensor comparison, deterministic trust engine, AWS-hosted backend, and public dashboard, every piece of the architecture exists to turn a raw number into evidence rather than an assumption.
PulseTrust_ remains a hackathon prototype, built under real time pressure and clearly scoped as such, not a finished or certified industrial system. Still, it demonstrates a concrete working approach to a problem many monitoring tools sidestep: distinguishing an unreliable sensing channel from a genuinely unusual machine event. If you're building your own monitoring project, start by asking the same question we did — not just “is this reading unusual?” but “can I actually trust it?”

Written by Shoaib Junaid Khan, Computer Science and Engineering student at SRM University-AP and member of Team Arlofield, where he collaborates with his teammates to build software and technology-driven solutions.
Reviewed by Chaitanya Jha, Electronics and Instrumentation Engineering student at Bangalore Institute of Technology; is the hardware/IoT contributor to PulseTrust_.
Prototype disclosure: PulseTrust_ is a hackathon prototype, not a certified industrial safety system. In the final demonstration, RPM/Hall values use a clearly identified simulated fallback because the Hall magnet was unavailable; the remaining listed telemetry and cloud pipeline remain live.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article