AWS Builder Center
AWS_BLOCKS

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:task001
tasks: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 /tasks
POST /tasks
PUT /tasks/:id
DELETE /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 install
npm 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.
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