
From a Campus Complaint Idea to a Working AWS Application: Our CampusCare Journey
We built CampusCare to make it easier for students to report and track common campus issues. In this article, we share how we took our initial frontend prototype and connected it to AWS services like S3, API Gateway, Lambda and DynamoDB to create a working application.
From a Campus Complaint Idea to a Working AWS Application: Our CampusCare Journey
When we first thought about CampusCare, the idea was simple:
What if reporting a problem on campus was as easy as reporting it online, and students could actually see what happened to their complaint?
A broken fan, Wi-Fi that keeps disconnecting, a faulty light, a smartboard that isn't working, or a damaged power socket may seem like small problems. But when there is no proper way to report and track them, they can remain unresolved or get lost in messages and conversations.
That became the starting point for our project, CampusCare.
We are Team Cloudpulse, a two-member team, and this project was also an opportunity for us to understand something beyond writing frontend code: how to take a local prototype and connect it to AWS to create a working application.
What is CampusCare?
CampusCare is a campus issue reporting and tracking platform designed for students and campus administrators.
A student can report an issue by entering:
- Name and email
- Issue category
- Building
- Room number
- Description of the problem
After submitting the report, the issue is sent to our backend and stored in the database.
On the admin side, the administrator can view the reported issues, filter them by status, and update their progress.
Our basic status flow is:
Pending → In Progress → Cleared
This gives students and administrators a clearer way to track what is happening with a reported issue.
Starting with a Simple Prototype
We initially focused on getting the user interface and basic workflow working.
We built the Student and Admin pages using HTML, CSS and JavaScript.
At this stage, our main goal was to understand the complete user flow:
Student reports an issue → Admin sees the issue → Admin updates the status
Getting this basic flow working helped us understand what our MVP should contain before connecting the application to AWS.
But we soon reached an important question:
How do we make this work outside our local system?
That's where AWS became a major part of our project.
Connecting CampusCare to AWS
We used several AWS services, with each service handling a specific part of the application.
Our architecture is:
Student / Admin → Amazon S3 → Amazon API Gateway → AWS Lambda → Amazon DynamoDB
Amazon S3 — Hosting our frontend
We used Amazon S3 to host our Student and Admin frontend pages.
This was one of the first steps that made the project feel different from a local prototype. Instead of opening the HTML files only on our computers, we could access the application through a public URL.
Amazon API Gateway — Connecting frontend and backend
We used Amazon API Gateway to create the API endpoint used by our frontend.
The Student page sends issue information to the API, while the Admin page uses the API to retrieve the stored issues and update their status.
AWS Lambda — Handling the backend logic
Our backend logic runs through AWS Lambda.
The Lambda function handles the main operations required by CampusCare:
- Creating a new issue
- Retrieving issues
- Updating issue status
- Storing admin messages
This was useful for us because we didn't have to set up and manage a traditional server for our backend.
Amazon DynamoDB — Storing the issues
We used Amazon DynamoDB to store the reported issue information.
Each report contains information such as the issue ID, student details, category, location, description, status and timestamps.
When a student submits an issue, Lambda stores it in DynamoDB.
When the Admin dashboard requests the reports, Lambda retrieves the data and sends it back through API Gateway.
AWS IAM — Managing permissions
We also used AWS IAM to provide the Lambda function with the permissions it needed to access our DynamoDB table.
This was an important part of our learning because we realized that simply creating AWS services isn't enough. The services also need the correct permissions to communicate with each other.
The Part We Didn't Expect: Debugging
One of the most useful parts of this project wasn't when everything worked.
It was when it didn't.
At different points, we had to figure out why the browser wasn't communicating correctly with our API.
One issue we encountered was CORS.
The API could work when tested directly, but the browser frontend was not able to communicate with it correctly. We had to understand what CORS was and configure it properly in API Gateway.
We also had to understand IAM permissions when connecting Lambda with DynamoDB.
There were moments where the problem wasn't in our JavaScript code at all. It was in the configuration between AWS services.
That was an important lesson for us:
Building a cloud application is not only about writing code. It is also about understanding how different services communicate with each other.
Seeing the Complete Flow Work
The most satisfying moment was seeing the complete flow work together.
We submitted an issue from the Student page.
The request went through:
S3 → API Gateway → Lambda → DynamoDB
The issue was stored successfully.
Then we opened the Admin dashboard and retrieved the issue through the API.
From there, the administrator could update the issue status and add a message.
Seeing the data travel through the different AWS services made the architecture much easier for us to understand than simply reading about it.
What We Learned
This project taught us several things that we wouldn't have understood as clearly by only building a local application.
We learned:
- How to host a frontend using Amazon S3
- How APIs connect a frontend to backend logic
- How API Gateway works with Lambda
- How Lambda can interact with DynamoDB
- How IAM permissions affect service-to-service communication
- Why CORS matters when a browser communicates with an API
- How to debug problems across multiple cloud services
- How a local prototype can be turned into a deployed application
Most importantly, we learned to stop looking at AWS services as completely separate tools.
Each service has a role, but the real application comes from connecting them together correctly.
What's Next for CampusCare?
The current version focuses on the core reporting and tracking workflow.
There are several things we would like to explore in future versions, including:
- Student authentication
- Image uploads with issue reports
- Better notification support
- Automatic issue categorization
- Detecting duplicate or recurring complaints
- Identifying high-priority issues
- Using AI to help analyze submitted reports
These are future improvements, not features of our current implementation.
For now, our main achievement is getting the basic CampusCare workflow running on AWS.
Final Thoughts
CampusCare started with a simple campus problem.
We didn't start by knowing exactly how S3, API Gateway, Lambda, DynamoDB and IAM would all fit together.
We learned that while building it.
There were configuration problems, API issues, CORS problems and plenty of testing. But each problem helped us understand a little more about how cloud applications actually work.
For us, the biggest takeaway from this project is simple:
A project doesn't become real just because the code works on your laptop. It becomes much more meaningful when you understand how to connect it, deploy it and make the complete flow work.
That's what CampusCare gave us the opportunity to experience.
And this is only our first step into building applications on AWS.
Project: CampusCare
Team: Cloudpulse
Track: Ship It
Technologies: HTML, CSS, JavaScript, Amazon S3, Amazon API Gateway, AWS Lambda, Amazon DynamoDB, AWS IAM
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article