AWS Builder Center
Beginner-friendly Student task manager

Beginner-friendly Student task manager

Build a beginner-friendly full-stack Student Task Manager using React, TypeScript, and AWS Blocks.this project demonstrates how authbasic, KVstore, and APInamespace work together to provide authentication, secure user-scoped task storage, and type-safe backend operations. It supports creating, editiing, completing, searching, filtering, and deleting tasks, while AWS Blocks local implementations Enable development without an AWS Account. the project also demonstragtes a simple path from local development.

Introduction

As part of an event we conducted for our juniors, me and my three friends decided to build a small full-stack application using AWS Blocks and demonstrate it to them.
We wanted the project to be simple enough for beginners to understand, but at the same time it should show how a real application connects the frontend, backend, authentication and data storage.
So, we decided to build a Student Task Manager using React, TypeScript and AWS Blocks.
The idea was pretty simple - students can Create their own tasks, edit them, mark them as completed and delete them. We also added a few small features like task priority, due dates, search and filters.
More than just building the application, the main purpose of the event was to give our juniors a hands-on introduction to AWS Blocks and show them how they can build and test a full-stack application without starting with a complicated AWS setup.

What We Built

The Student Task Manager includes:
  • Sign up and sign in
  • Sign out
  • Create, edit and delete tasks
  • Mark tasks as completed or incomplete
  • Set task priority
  • Add an optional due date
  • Search tasks
  • Filter by All, Active and Completed
  • View total, completed and remaining tasks
  • Responsive UI
Each task contains information like:
{
id: string;
title: string;
completed: boolean;
createdAt: string;
userId: string;
priority: "low" | "medium" | "high";
dueDate?: string;
}

We intentionally kept the project small because the main focus was learning the basic concepts rather than building a very large application.

AWS Blocks We Used

For the project, we used three AWS Blocks:
  • AuthBasic – for Authentication
  • KVStore – for Storing tasks
  • ApiNamespace – for backend operations
The basic flow is:
React + TypeScript
↓
ApiNamespace
↓
AuthBasic + KVStore

This gave us the basic pieces needed to build the application without adding unnecessary services.

Authentication With AuthBasic

We used AuthBasic for sign up, sign in and sign out.
After a user signs in, the backend canidentify the authenticated user. We use this user ID when working with their tasks.
One important thing we wanted to show our juniors was that the backend should not simply trust a  userId  coming from the frontend.
Instead, the backend gets the user ID from the authenticated session.

Storing Tasks with KVStore

For storage, we used KV Store.
Tasks are stored using user-scoped keys:
tasks:{userId}:{taskId}

For example:
tasks:user123:task001
tasks:user123:task002

This helps keep the tasks of different users separate.

API with APINamespace

We used ApiNamespace to handle the backend operations.
The application has four basic operations:
GET /tasks
POST /tasks
PUT /tasks/:id
DELETE /tasks/:id

Whenever a request comes to the backend, the application checks the authenticated user before accessing the task data.
For update and delete operations, it also checks whether the task belongs to that user.
So User A cannot simply change a task ID and modify User B's task.

React Frontend

The frontend was built using React and TypeScript.
We kept the UI straightforward so that it would be easy for our juniors to follow during the event.
The user can add a task with a title, priority and optional due date. Each task has options to edit, complete or delete it.
We also added search and filters to make the application a little more useful.

Local Development

One of the things we wanted to demonstrate during the event was the local development experience.
With the AWS Blocks local implementations, we were able to run the application without requiring an AWS account.
The project can be started using:
npm install
npm run dev

This made the workshop easier because everyone could focus on understanding the application instead of spending time configuring cloud resources first.

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

User A should only see User A's tasks, and User B should only see User B's tasks.
This was a good example to show why authentication alone is not enough. The backend also needs to check what data the authenticated user is allowed to access.

What We Learned

Building this project and conducting the event helped us understand AWS Blocks better, especially because we had to explain the concepts to our juniors.
We learned about:
  • authentication with AuthBasic
  • Data storage with KVStore
  • Backend APIs with ApiNamespace
  • User-scoped data
  • Server-side authorization
  • React and TypeScript
  • Local development with AWS Blocks
For us, explaining the project to others was also useful because it made us think more clearly about how each part of the application actually works.

Conclusion:

The Student Task Manager is a simple project, but it gave us a practical way to understand AWS Blocks and full-stack development.
By using AuthBasic, KVStore and ApiNamespace, we were able to build authentication, backend APIs and user-specific data storage without Making the project too complicated
More importantly, building this application and sharing it with our juniors gave us a chance to learn together and introduce them to a different way of building full-stack applications with AWS.
We hope this small project also gives other beginners a starting point to try AWS Blocks and build something of their own.
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