Building PlantNexus: From an Industrial Sustainability Idea to a Working Prototype
PlantNexus helps manufacturing plants identify energy inefficiencies and industrial waste through machine telemetry analysis. Built for Environmental Hacks, it uses the AWS Strands Agents SDK with Gemini to generate AI-powered explanations and recommendations. With a Python-based factory simulator, it demonstrates how smarter resource management can reduce operating costs and support environmental sustainability.
Building PlantNexus: My Journey of Turning an Industrial Sustainability Idea into a Working Prototype
From an idea to a working demo at Environmental Hacks — Event 02 of the Bharat Builds Tour with AWS
Where the idea started
When I started working on PlantNexus, I wanted to build something that could contribute to solving a real-world problem.
We often talk about sustainability through individual actions, and those actions definitely matter. But I also started thinking about the manufacturing industry. Manufacturing plants consume significant amounts of energy, and inefficient machine operations can lead to unnecessary energy consumption and industrial waste. This affects not only the company's operating costs but also the environment.
What if we could use machine data to identify these inefficiencies, understand what might be going wrong, and help operators make better decisions?
That question became the starting point for PlantNexus.
PlantNexus is an industrial resource intelligence platform designed to help small and medium manufacturing plants monitor machine performance, detect potential inefficiencies, understand the issues through AI-powered explanations, and verify whether machine conditions improve.
The goal was not just to build another dashboard with charts. I wanted to demonstrate a complete workflow that connects industrial data with more informed resource management.
The biggest challenge: I didn't have access to a real factory
One of the first practical challenges was that I didn't have access to an actual manufacturing plant or industrial machines.
Without real equipment, collecting live telemetry and demonstrating machine degradation was not possible. I could have limited the project to a UI prototype, but that wouldn't demonstrate how the system actually works.
So, I decided to build a factory simulator.
Using Python, I created a simulator that generates telemetry for a virtual machine, identified as M-017. It produces readings such as energy consumption, production rate, waste, and temperature. It can simulate healthy, degraded, and recovery scenarios.
This became an important part of the project because it gave me a controlled environment to test the pipeline without physical hardware.
It also helped me think about how the project could eventually connect to a real factory. The simulator is a substitute for the data source during development, not the final vision of the product.
Building the complete pipeline
I wanted PlantNexus to demonstrate more than collecting readings and displaying them.
The workflow I worked towards was:
Industrial data → Analysis → Detection → Explanation → Action → Verification
I built the frontend using React, TypeScript, and Vite. The backend uses Node.js and Express, while Supabase stores the machine telemetry. I also built the landing page and dashboard to make the system understandable and demonstrate its capabilities.
The dashboard allows users to inspect machine readings and telemetry trends. The analysis layer evaluates the data to identify potential inefficiencies. The explanation layer helps make the results easier to understand and provides recommendations for further investigation.
Finally, recovery verification checks whether the machine meets configured recovery criteria based on subsequent readings.
This last step was particularly important to the idea. Detecting a problem and confirming that conditions have improved are two different things. I wanted the prototype to demonstrate both.
Bringing AI into the project with AWS Strands Agents SDK
Another part of the project was exploring how AI could make industrial analysis more useful to operators.
I integrated the AWS Strands Agents SDK into the AI layer alongside Google's Gemini model for explanations and recommendations based on available machine data and analysis results.
The idea is to make the output more understandable than simply showing a metric or flagging an abnormal reading. An operator should be able to understand why a condition deserves attention and what they could investigate next.
At the same time, I learned that AI should not be responsible for everything. PlantNexus uses deterministic logic for its core detection and recovery checks, while the language model supports the explanation layer.
This separation matters because the system still needs to provide useful, predictable results when the AI service is unavailable or its API quota is exhausted. I worked on a deterministic fallback so that an unavailable model would not stop the entire demonstration.
That was an important lesson for me: adding AI is not just about generating a response. It is also about deciding where AI is useful, what should remain rule-based, and how the application should behave when the model cannot respond.
The role of AWS and what comes next
Working with the AWS ecosystem also got me thinking beyond the current prototype.
The Strands Agents SDK is part of the project's AI integration. For a future deployment in an actual manufacturing environment, I would like to explore AWS IoT Greengrass to support edge computing closer to factory equipment.
That could provide a path towards processing machine data nearer to its source before integrating it with the broader PlantNexus pipeline.
However, this is a future direction rather than a feature I am claiming to have implemented in the current prototype. Right now, the focus has been on demonstrating the data pipeline, analysis, explanations, and recovery workflow using simulated telemetry.
The part nobody sees: debugging and making things work together
Building PlantNexus was not a straight line from idea to finished product.
I had to work through backend integration, database configuration, telemetry ingestion, frontend state, deployment issues, and the challenge of making different components work together.
At several points, I had to decide whether to keep adding features or focus on getting the existing workflow to work reliably. With the hackathon deadline approaching, that decision became increasingly important.
I learned to prioritise the core experience: generate data, receive it in the backend, store it, display it, analyse it, and verify the result. A smaller working pipeline was more valuable than a long list of features that could not be demonstrated end to end.
Testing also became an important part of the process. I worked on backend tests, frontend builds, and the integration between the simulator and the deployed backend. I wanted to be able to show the system doing something real, even though the machine data itself was simulated.
As a solo builder, I was responsible for the frontend, backend, database, simulator, AI integration, and deployment. It was challenging, but it also gave me a much better understanding of how the individual parts of a software system fit together.
Why this matters for sustainability
PlantNexus is still a prototype, and I don't want to claim environmental savings that have not been measured in a real factory.
The potential impact comes from helping manufacturing plants identify avoidable energy consumption and waste, investigate the causes, and verify whether corrective actions improve machine performance.
If those insights lead to actual reductions in resource consumption, the benefits could include lower operating costs and a reduced environmental footprint.
For me, that is the important connection between industrial intelligence and sustainability: data becomes valuable when it helps people make better decisions and take meaningful action.
What's next?
The current milestone is a working prototype that demonstrates the core workflow using simulated machine telemetry.
The next steps would be to test the system with real industrial data, improve the reliability of the analysis and recommendations, explore edge integration, and measure actual resource savings when suitable data becomes available.
Building PlantNexus during Environmental Hacks has taught me that a useful project is not just about choosing a technology stack or building an attractive interface. It is about identifying a problem, working within real constraints, testing assumptions, and creating a solution that can be evaluated honestly.
I started with a question about how manufacturing plants could use resources more efficiently. PlantNexus is my attempt to turn that question into something tangible.
There is still a lot to improve, but this journey has given me a clearer picture of how software, industrial data, AI, and cloud technologies can work together towards a more sustainable future.
PlantNexus is a step towards making industrial resource intelligence more accessible, one machine and one decision at a time.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article