Weekend Showcase Challenge: Smart Campus Air Quality Monitor — An IoT + AI Agent System

Here's a description you can use for your GitHub repository: 🌐 Smart Campus Air Quality Monitor — An IoT + AI Agent system that monitors campus air quality in real-time using ESP32 sensor nodes, AWS IoT Core, Amazon Timestream, and a conversational AI agent powered by Amazon Bedrock (Nova). Built entirely on AWS Free Tier.

Rajkumar kk

Assistant Professor | AI, Cloud Computing & IoT | AWS Builder

Published Aug 28, 2026

Last modified Aug 28, 2026

Vision & What It DoesAir quality is an invisible crisis on college campuses. Students and faculty spend hours in classrooms, labs, and corridors without knowing whether the air they breathe is safe. Particulate matter, volatile organic compounds, and CO₂ levels spike during peak hours, yet most institutions lack real-time monitoring — let alone intelligent alerting.
Smart Campus Air Quality Monitor solves this by deploying low-cost IoT sensor nodes across campus that continuously stream environmental data to the cloud. But it goes further than a simple dashboard: at the heart of the system is an AI-powered conversational agent that anyone — students, faculty, or administrators — can ask natural-language questions like:
"How was the air quality in Block C yesterday?"
"Which building had the highest CO₂ levels this week?"
"Alert me if PM2.5 crosses 150 in the electronics lab."
The system transforms raw sensor telemetry into actionable intelligence, combining the reliability of IoT edge hardware with the accessibility of a conversational AI interface.
Key FeaturesReal-time environmental monitoring — Temperature, humidity, CO₂, PM2.5, and volatile organic compounds sampled every 30 seconds.
AI Conversational Agent — Built on Amazon Bedrock (Nova model), the agent queries time-series data and responds in plain English with context-aware summaries.
Threshold-based alerting — Automated SMS/email notifications via Amazon SNS when any parameter crosses unsafe levels.
Historical analytics dashboard — A web-based dashboard hosted on AWS Amplify showing trends, heatmaps, and comparative charts across locations.
Edge-first architecture — Sensor nodes perform local filtering and only transmit meaningful data, reducing bandwidth and cost.
﻿
How I Built ItDevelopment ProcessThe project evolved through three phases across the summer:
Phase 1 — Hardware & Connectivity (Week 1)
I started with the sensor nodes. Each node is built around an ESP32 microcontroller connected to:
MQ-135 — Air quality (CO₂, ammonia, benzene detection)
PMS5003 — Laser-based PM2.5/PM10 particulate sensor
DHT22 — Temperature and humidity
Sound sensor module — Ambient noise level
The ESP32 runs MicroPython firmware that reads sensors every 30 seconds, applies a moving-average filter to reduce noise, and publishes a JSON payload over MQTT to AWS IoT Core. I used the TLS mutual authentication model with X.509 certificates provisioned through AWS IoT Device Management.
Phase 2 — Cloud Pipeline & Storage (Week 2)
Once telemetry was flowing, I built the ingestion pipeline:
AWS IoT Core receives MQTT messages and applies IoT Rules.
An IoT Rule routes data to a Lambda function that validates the payload schema, enriches it with location metadata, and writes to Amazon Timestream (time-series database optimized for IoT workloads).
A second IoT Rule evaluates threshold conditions and publishes alerts to an SNS topic, which fans out to email and SMS subscribers.
A key decision was choosing Timestream over DynamoDB for storage. While DynamoDB would work, Timestream's built-in time-series functions (interpolation, smoothing, aggregation over time windows) made analytical queries dramatically simpler.
Phase 3 — AI Agent & Dashboard (Week 3)
This was the most exciting phase. I built a conversational agent using Amazon Bedrock with the Nova model that can:
Accept natural-language questions about air quality data
Translate them into Timestream SQL queries
Summarize results in a human-friendly response
The agent uses a tool-use pattern: it has access to a Lambda function that executes parameterized Timestream queries and returns results. The Nova model decides when and how to call this tool based on the user's question.
For the dashboard, I built a React application deployed on AWS Amplify that connects to an API Gateway → Lambda backend to fetch historical data and render charts using Chart.js.
Challenges & SolutionsChallenge
Solution
ESP32 WiFi drops in concrete buildings
Implemented automatic reconnection with exponential backoff and local SD card buffering
Timestream query costs during development
Created a scheduled Lambda that pre-computes hourly aggregates into a summary table
Agent hallucinating sensor values
Constrained the agent with strict system prompts and tool-only data access — no fabrication allowed
MQTT payload size limits
Compressed payloads using MessagePack instead of raw JSON, reducing size by 40%
﻿
AWS Services Used / Architecture OverviewArchitecture DiagramPlain text
┌─────────────────┐     MQTT/TLS      ┌──────────────────┐
│  ESP32 Sensor   │ ──────────────────▶│  AWS IoT Core    │
│  Node (x3)      │                    │  (Message Broker)│
└─────────────────┘                    └────────┬─────────┘
                                                │
                                    ┌───────────┼───────────┐
                                    ▼           ▼           ▼
                            ┌──────────┐ ┌──────────┐ ┌─────────┐
                            │IoT Rule 1│ │IoT Rule 2│ │IoT Rule 3│
                            │(Ingest)  │ │(Alerts)  │ │(Archive) │
                            └────┬─────┘ └────┬─────┘ └────┬────┘
                                 ▼             ▼            ▼
                          ┌──────────┐  ┌──────────┐  ┌─────────┐
                          │  Lambda  │  │   SNS    │  │   S3    │
                          │(Process) │  │(Notify)  │  │(Raw Log)│
                          └────┬─────┘  └──────────┘  └─────────┘
                               ▼
                        ┌─────────────┐
                        │  Amazon     │
                        │  Timestream │
                        │  (Storage)  │
                        └──────┬──────┘
                               │
                 ┌─────────────┼─────────────┐
                 ▼                           ▼
        ┌────────────────┐         ┌─────────────────┐
        │ Amazon Bedrock │         │  API Gateway    │
        │ (Nova Agent)   │         │  + Lambda       │
        │ + Lambda Tool  │         │  (Dashboard API)│
        └────────────────┘         └────────┬────────┘
                                            ▼
                                   ┌─────────────────┐
                                   │  AWS Amplify    │
                                   │  (React App)    │
                                   └─────────────────┘
﻿
AWS Services SummaryService
Purpose
AWS IoT Core
MQTT message broker, device authentication, rules engine
AWS Lambda
Data processing, Timestream writes, agent tool execution, API backend
Amazon Timestream
Time-series storage for sensor data with built-in analytics
Amazon Bedrock (Nova)
Conversational AI agent for natural-language data queries
Amazon SNS
Alert notifications via email and SMS
Amazon S3
Raw data archival and static asset hosting
AWS Amplify
Frontend hosting and CI/CD for the React dashboard
Amazon API Gateway
RESTful API layer for dashboard data access
AWS IoT Device Management
Certificate provisioning and device fleet management
All services used are exclusively AWS and fall within or are optimized for the AWS Free Tier, making this project reproducible at zero cost for new builders. No third-party cloud services are used — the entire stack runs on AWS infrastructure end-to-end.
﻿
What I Learned Across the SummerThis summer's build series taught me several valuable lessons:
1. The Power of Serverless for IoTComing from an electronics background, I was used to thinking about dedicated servers and always-on infrastructure. Discovering that Lambda + IoT Core can handle thousands of messages per second — and you only pay per invocation — was a paradigm shift. For campus-scale IoT, serverless is not just cheaper; it is architecturally simpler.
2. AI Agents Need Guardrails, Not Just PromptsMy first iteration of the Bedrock agent would sometimes fabricate plausible-sounding sensor readings. The fix was not a better prompt — it was architectural: the agent can ONLY access data through its Lambda tool. No tool call, no data in the response. This "tool-gated" pattern is now my default for any data-retrieval agent.
3. Edge Computing MattersSending every raw sensor reading to the cloud is wasteful and expensive. By adding a simple moving-average filter and only transmitting when values change beyond a threshold (dead-band filtering), I reduced data transmission by 60% without losing meaningful signal. The ESP32 is powerful enough for this preprocessing.
4. Time-Series Databases Are Worth LearningI initially stored everything in DynamoDB because it is familiar. Migrating to Timestream cut my query complexity in half. Queries like "average PM2.5 per hour for the last 7 days, grouped by location" went from complex scan-and-filter operations to single SQL statements.
5. Community Inspiration Drives Better BuildsThe Summer Build Series community pushed me to think beyond "does it work?" to "is it useful and impressive?" Seeing others build creative agents and apps inspired me to add the conversational AI layer — which turned a standard IoT dashboard into something genuinely novel.
﻿
Link to App & RepositoryLive Dashboard:  https://smart-campus-monitor.amplifyapp.com 
GitHub Repository:   https://github.com/rajkksns/smart-campus-air-monitor 

Challenge	Solution
ESP32 WiFi drops in concrete buildings	Implemented automatic reconnection with exponential backoff and local SD card buffering
Timestream query costs during development	Created a scheduled Lambda that pre-computes hourly aggregates into a summary table
Agent hallucinating sensor values	Constrained the agent with strict system prompts and tool-only data access — no fabrication allowed
MQTT payload size limits	Compressed payloads using MessagePack instead of raw JSON, reducing size by 40%

Service	Purpose
AWS IoT Core	MQTT message broker, device authentication, rules engine
AWS Lambda	Data processing, Timestream writes, agent tool execution, API backend
Amazon Timestream	Time-series storage for sensor data with built-in analytics
Amazon Bedrock (Nova)	Conversational AI agent for natural-language data queries
Amazon SNS	Alert notifications via email and SMS
Amazon S3	Raw data archival and static asset hosting
AWS Amplify	Frontend hosting and CI/CD for the React dashboard
Amazon API Gateway	RESTful API layer for dashboard data access
AWS IoT Device Management	Certificate provisioning and device fleet management

# application # productivity

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

Builder Center

Weekend Showcase Challenge: Smart Campus Air Quality Monitor — An IoT + AI Agent System

Rajkumar kk

Vision & What It Does

Key Features

How I Built It

Development Process

Challenges & Solutions

AWS Services Used / Architecture Overview

Architecture Diagram

AWS Services Summary

What I Learned Across the Summer

1. The Power of Serverless for IoT

2. AI Agents Need Guardrails, Not Just Prompts

3. Edge Computing Matters

4. Time-Series Databases Are Worth Learning

5. Community Inspiration Drives Better Builds

Link to App & Repository