AWS Builder Center
Building a Full-Stack Student Task Manager with AWS Blocks and Kiro IDE

Building a Full-Stack Student Task Manager with AWS Blocks and Kiro IDE

In this hands-on build, I created a full-stack Student Task Manager using AWS Blocks and Kiro IDE, with authentication, typed APIs, persistent task storage, user-level data isolation, real-time capabilities, and a responsive React interface - all developed locally before deployment.

AWS Cloud & AI Enthusiast | Full-Stack Developer | CSE Student
Building My First Full-Stack App with AWS Blocks and Kiro IDE
Building a full-stack application was something I wanted to try, but I knew that there were several parts involved, including the frontend, backend, authentication, APIs, and data storage.
During the Build Your First Full-Stack App with AWS Blocks & Kiro IDE session on 11 August 2026, I decided to build a Student Task Manager. My main goal was to understand how the different parts of a full-stack application work together instead of learning them separately.
I started by creating the project using the AWS Blocks application generator:
npm create @aws-blocks/blocks-app@latest student-task-manager
After creating the project, I installed the required dependencies using  npm install . Once the installation was completed, I started the development server using  npm run dev .
The application started running locally at:
http://localhost:3000
After getting the application running, I explored the generated project structure. I looked through the frontend files, backend files, configuration files, and AWS Blocks workspace to understand how everything was organized.
Then I started working on the actual Student Task Manager.
I wanted the application to be simple but useful for students. I decided that users should be able to create an account, sign in, sign out, add tasks, edit tasks, mark tasks as completed, delete tasks, and view their own tasks.
I started working on the backend first. I used AWS Blocks for authentication and data storage. For authentication, I used  AuthBasic , which handles sign-up, sign-in, sign-out, and user sessions.
After that, I worked on storing the task information using  KVStore . Each task contains information such as the task ID, user ID, title, creation time, and completion status. I also used Zod validation to validate the task data before storing it.
One thing I specifically wanted to handle was user isolation. If two students use the application, one student should not be able to see or modify another student's tasks.
To achieve this, I used a user-specific key structure:
tasks:{userId}:{taskId}
I also added ownership checks before updating or deleting a task.
While implementing this, I understood that authentication alone is not enough. The backend also needs to check whether the authenticated user is actually allowed to access or modify the requested data.
After completing the backend functionality, I started working on the frontend using React and TypeScript.
I created different components for the authentication form, task input, task list, and individual task items. I then connected the frontend with the backend operations.
After that, I added the main task features. I could add a task, edit it, mark it as completed, and delete it. I also added inline editing so that I could change a task directly from the task list.
Once the main functionality was working, I focused on improving the user interface.
I didn't want the application to look like a basic CRUD application, so I added a gradient background, glass-style cards, animated checkboxes, task hover effects, loading states, skeleton loading, empty states, error messages, responsive design, and a progress bar.
I also added different styling for completed tasks so that it was easier to distinguish completed tasks from pending tasks.
After finishing the main features, I tested the application.
I created end-to-end tests for the important application flows. The tests checked authentication, creating tasks, listing tasks, completing tasks, updating tasks, deleting tasks, and user isolation.
I ran the complete test suite and all 10 tests passed.
The user-isolation test was particularly important to me because it verified that one user could not access another user's tasks.
Throughout the development process, I also used Kiro IDE to explore the project, understand the generated code, and make changes to the application.
Since I was working with AWS Blocks for the first time, Kiro helped me understand the project structure and work through different parts of the application. At the same time, I made sure to understand the changes instead of simply accepting generated code without checking it.
After completing the development and testing, I had a working Student Task Manager running locally.
I could start the application using:
npm run dev
and access it through:
http://localhost:3000
One thing I liked about this workflow was that I could build and test the application locally without setting up AWS resources first. This made it easier to experiment, test different features, and fix issues during development.
While building this project, I learned more about how the different parts of a full-stack application connect together.
I also understood the difference between authentication and authorization more clearly. Authentication tells me who the user is, while authorization determines what that user is allowed to access or modify.
Implementing task ownership and user isolation made this difference much more practical for me.
The current version of the application is working and tested locally, but I still have more ideas that I would like to add, such as task priorities, due dates, categories, search and filtering, notifications, better dashboard statistics, shared tasks, and additional tests.
My next step is to explore the AWS deployment workflow and move the application beyond local development.
Overall, this project gave me an opportunity to actually build a full-stack application instead of only learning the concepts separately.
I started with the AWS Blocks starter project, explored the generated structure, built the task functionality, added authentication and user isolation, worked on the React interface, tested the application, and finally got it running locally.
The Student Task Manager is a simple application, but building it helped me understand how the different pieces of a full-stack application fit together.
For me, the biggest takeaway from this session was simple:
I didn't just learn about building a full-stack application. I actually built one.
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