
AWS_BLOCKS
We built a simple Student Task Manager as part of an event conducted for our juniors. The main goal was to give beginners a practical idea of how a full-stack application works using React, TypeScript and AWS Blocks.
Student Task Manager Using AWS Blocks
Introduction
As part of an event we conducted for our juniors, me and my three friends decided to build a small full-stack application and demonstrate it to them.
We wanted to make something which is simple enough for beginners to understand, but still shows how a real application works with frontend, backend, authentication and database/storage.
So we decided to build a Student Task Manager using React, TypeScript and AWS Blocks.
The main idea was simple. Students can create their own tasks, edit them, mark them as completed and delete them. We also added some extra features like priority, due dates, search and filters.
The main purpose of doing this project was not to build a very big application. We mainly wanted our juniors to understand AWS Blocks and see how a full-stack application can be developed without starting with a complicated AWS configuration.
What We Built
Our Student Task Manager has features like:
- Sign up and sign in
- Sign out
- Create tasks
- Edit tasks
- Delete tasks
- Mark tasks as completed or incomplete
- Set task priority
- Add an optional due date
- Search tasks
- Filter tasks by All, Active and Completed
- See total, completed and remaining tasks
- Responsive UI
Each task contains details like:
{ id: string; title: string; completed: boolean; createdAt: string; userId: string; priority: "low" | "medium" | "high"; dueDate?: string;}
We kept the application small intentionally. Since this was mainly for a learning event, we didn't want to add too many features and make it difficult for the juniors to understand.
AWS Blocks We Used
For this project we mainly used three AWS Blocks:
- AuthBasic – Authentication
- KVStore – Storing task data
- ApiNamespace – Backend API operations
The basic flow of our application was:
React + TypeScript ↓ApiNamespace ↓AuthBasic + KVStore
These three blocks were enough for our basic application.
We didn't want to add a lot of AWS services because then the main purpose of the workshop could get lost. We wanted everyone to first understand the basic flow.
Authentication Using AuthBasic
For authentication, we used AuthBasic.
It was used for sign up, sign in and sign out.
After a user logs in, our backend is able to identify which user is making the request. We then use that user ID when working with the tasks.
One thing we really wanted to explain to our juniors was that we should not just trust a
userId coming from the frontend.For example, if someone changes the user ID from the frontend, the backend should not simply accept it.
Instead, the backend gets the user information from the authenticated session.
This was one of the important concepts we wanted to demonstrate because authentication and authorization are not exactly the same thing.
Storing Tasks Using KVStore
For storing the tasks, we used KVStore.
We used user-specific keys for storing each task.
For example:
tasks:{userId}:{taskId}
Some example keys can be:
tasks:user123:task001tasks:user123:task002
This way the tasks can be connected to the correct user.
So if User A creates some tasks, those tasks should not be shown to User B.
It was a simple way for us to demonstrate the idea of user scoped data without making the storage system too complicated.
Backend API with ApiNamespace
We used ApiNamespace for handling the backend operations.
The application basically has four main API operations:
GET /tasksPOST /tasksPUT /tasks/:idDELETE /tasks/:id
When a request comes to the backend, we first check the authenticated user.
For example, when getting tasks, the backend should only return tasks belonging to that user.
For update and delete also, we check whether the task actually belongs to the logged in user.
This means User A cannot just take the ID of User B's task and try to modify or delete it.
This was a small thing in the project, but it helped us understand why authorization needs to be handled on the backend.
React Frontend
The frontend was developed using React and TypeScript.
We kept the UI simple because we wanted the juniors to easily understand what was happening.
A user can create a task by entering a title, selecting the priority and optionally adding a due date.
After creating the task, the user can:
- Edit it
- Complete it
- Mark it incomplete
- Delete it
We also added search and filters so that the application feels a little more like a real task management application.
The UI was kept responsive so that it can also be used on smaller screens.
Local Development
One part that was really useful during the event was the local development setup.
Using the local implementations of AWS Blocks, we were able to run the project locally without requiring everyone to setup a complete AWS environment first.
The basic commands were:
npm installnpm run dev
This made things much easier during the workshop.
Instead of spending most of the time creating cloud resources and configuring everything, the juniors could directly run the application and start understanding how the different parts were connected.
For a beginner workshop, we felt this was very useful.
Testing User Isolation
We also tested the application using two different users.
For example:
User A ├── Complete AWS assignment └── Prepare presentation
User B ├── Study Java └── Finish project
When User A logs in, only User A's tasks should be visible.
When User B logs in, only User B's tasks should be visible.
We tested this because we wanted to make sure that users cannot access each other's tasks.
This also gave us a good example to explain one important thing:
Just having authentication doesn't mean the application is secure.
The backend also needs to check whether the authenticated user is actually allowed to access the requested data.
What We Learned
While building this project, we learned quite a few things about AWS Blocks and full-stack development.
Some of the main things we learned were:
- Authentication using AuthBasic
- Data storage using KVStore
- Creating backend APIs using ApiNamespace
- Working with user-specific data
- Server-side authorization
- React and TypeScript
- Local development using AWS Blocks
But apart from the technical part, one more thing we learned was that explaining something to someone else makes you understand it better yourself.
While preparing the event, we had to think about how each part works and how we could explain it to our juniors in a simple way.
Sometimes while building the project we understood something only after trying to explain it.
Conclusion
The Student Task Manager is a small project, but for us it was a good way to understand AWS Blocks and some important full-stack concepts.
Using AuthBasic, KVStore and ApiNamespace, we were able to build the main parts of a full-stack application like authentication, backend APIs and user-specific data storage without making the project too complicated.
The main goal was not to build a huge or production-level application.
It was more about learning, building something that actually works, and then sharing what we learned with our juniors.
Conducting the event also made the learning experience more interesting because we were not only building the application, we also had to explain why we built each part in that way.
We hope this small project can also give other beginners a starting point to explore AWS Blocks and try building their own full-stack applications.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article