Why it began
RootSense was completed in 2025 over four months by a five-person team, including me. It began as a way to automate the work involved in caring for crops and operating an irrigation system. The goal was to reduce constant manual supervision and turn field conditions into information that could guide action.
The project connected two objectives: help the people responsible for crops make decisions with better context and improve water stewardship through automation.
The problem
Crop and irrigation management often depends on manual work. Important information can be lost during the process, the operation demands near-constant attention, and many decisions end up guided only by intuition.
Without consistent field data, it is difficult to understand what happened, respond in time or compare system behavior across different moments.
What makes the project different
RootSense combines web development, hardware, real-time communication and distributed services in one solution. Its microservice-based architecture separates responsibilities and uses MQTT events to connect the physical environment with software services.
The system goes beyond visualizing sensor readings. It also includes actuators and irrigation automation based on conditions recorded in real time.
How the system is divided
The monitoring interface uses React and TypeScript. Backend services are built with Node.js and Express, separating system responsibilities into independent processes.
MongoDB stores recorded information. Redis optimizes data access and holds temporary state. MQTT transports messages between devices and services. A Raspberry Pi connects the software to irrigation sensors and actuators. Docker isolates and configures the services during deployment.
System flow
- Sensors record conditions related to crops and irrigation.
- The Raspberry Pi receives information from the physical environment.
- MQTT publishes events for the appropriate services to process.
- Microservices store information, maintain state and coordinate decisions.
- The interface presents the current state of the system.
- Actuators execute the irrigation actions defined by the automation.
Architecture
The architecture is organized around specialized services that communicate through messages. This keeps sensor acquisition, processing, storage and the interface from depending on one process.
MQTT provides the lightweight channel between hardware and backend services. MongoDB keeps persistent data, Redis supports fast access and short-lived state, and Docker provides a shared strategy for isolating, configuring and deploying the services.
Technologies
- React and TypeScript for the interface.
- Node.js and Express for backend services.
- MongoDB for persistent storage.
- Redis for optimized access and temporary state.
- MQTT for event-driven communication.
- Raspberry Pi for sensor and actuator integration.
- Docker for isolation, configuration and deployment.
Key technical decisions
- Separate responsibilities through microservices instead of placing hardware, data and interface concerns in one application.
- Use MQTT as a lightweight protocol for events from the physical environment.
- Keep persistent and temporary state in different tools: MongoDB and Redis.
- Package services with Docker so configuration and deployment strategy remain explicit.
My contribution
I developed the backend and the communication between microservices. I also defined the service deployment strategy.
My work focused on making the distributed components exchange information consistently; I do not present the complete frontend, hardware or product implementation as my own.
The problem that took days to solve
The hardest challenge was achieving reliable communication between microservices. Configuring MQTT, making the services exchange messages correctly and reviewing the reliability of the flow took several days.
The problem did not end when a message arrived once. The system needed a coherent configuration so every service understood when to publish, when to listen and how to preserve the state it required.
What I learned
RootSense taught me event-driven communication through MQTT and gave me a concrete system in which to connect software with a physical environment.
It also reinforced that communication and reliability are part of distributed-system architecture, not details that can be added at the end.
Outcome and current state
RootSense is a completed project that demonstrates the integration of web development, IoT, real-time communication, hardware and distributed systems in an automated irrigation solution. The automation was used with real crops; no unverified water-efficiency metric is claimed.
Evidence and confidentiality
The interface, deployment, hardware and demonstration remain private. This case study documents the technical flow and my contribution without publishing confidential material or replacing it with fabricated evidence.
Source and scope
The repository is private. This case study describes the system and my contribution without presenting a source-code action.