AWS Builder Center
๐Ÿš€ Building a Student Task Manager with AWS Blocks

๐Ÿš€ Building a Student Task Manager with AWS Blocks

A hands-on walkthrough of building a full-stack Student Task Manager with React, TypeScript, AWS Blocks, authentication, user-scoped storage, APIs, and testing.

๐Ÿš€ Introduction

I built Student Task Manager, a full-stack task management application designed around a simple idea: provide students with a focused place to manage their daily technical and academic tasks.
But the main goal of this project was not just to build another CRUD application.
I wanted to understand how AWS Blocks can be used to build authentication, typed APIs, user-scoped storage, and a full-stack application that can run locally before being deployed to AWS.
The application is built with React, TypeScript, Vite, and AWS Blocks.

๏ปฟ

๐Ÿ–ฅ๏ธ What I Built

The application provides an authenticated workspace where each user can manage their own tasks.
๏ปฟ
A user can:
  • Sign up and sign in
  • Create tasks
  • Edit tasks
  • Mark tasks complete/incomplete
  • Delete tasks
  • View their incomplete-task count
  • Restore their session after refreshing the page
The important part is that the application is multi-user aware. Tasks are isolated by the authenticated user rather than being stored in one shared list.

๏ปฟ

๐Ÿ› ๏ธ Technology Stack

The project is intentionally built with a relatively small stack:
Frontend โ†’ React + TypeScript
Build Tool โ†’ Vite
Backend โ†’ AWS Blocks ApiNamespace
Authentication โ†’ AWS Blocks AuthBasic
Storage โ†’ AWS Blocks KVStore
Runtime โ†’ Node.js
Testing โ†’ End-to-End API tests
The frontend contains the authentication interface and task-management UI, while the ย aws-blocksย  workspace contains the backend capabilities.

๏ปฟ

๐Ÿ—๏ธ How the Project Is Structured

The repository separates the frontend and AWS Blocks backend:
student-task-manager/
โ”‚
โ”œโ”€โ”€ src/
โ”‚ โ”œโ”€โ”€ index.tsx
โ”‚ โ”œโ”€โ”€ AuthPanel.tsx
โ”‚ โ”œโ”€โ”€ App.tsx
โ”‚ โ””โ”€โ”€ app.css
โ”‚
โ”œโ”€โ”€ aws-blocks/
โ”‚ โ”œโ”€โ”€ index.ts
โ”‚ โ”œโ”€โ”€ index.cdk.ts
โ”‚ โ”œโ”€โ”€ index.handler.ts
โ”‚ โ””โ”€โ”€ scripts/
โ”‚
โ””โ”€โ”€ test/
โ””โ”€โ”€ e2e.test.ts
ย src/ย  contains the React application.
ย aws-blocks/index.tsย  contains the backend implementation using AuthBasic, ApiNamespace, and KVStore.
The project also includes CDK and deployment-related files for running the backend in AWS.

๏ปฟ

๐Ÿงฉ Architecture

The core architecture connects the React application to AWS Blocks through a typed API.
๏ปฟ
There are three important AWS Blocks components in the backend:

AuthBasic

Handles username/password authentication and the user's session.

ApiNamespace

Exposes typed operations such as:
createTask()
listTasks()
updateTask()
toggleTask()
deleteTask()

KVStore

The application uses two stores:
taskStore
โ†’ stores Task objects
๏ปฟ
indexStore
โ†’ stores ordered task IDs
The local environment persists data to ย .bb-data/ย , while the AWS deployment uses DynamoDB-backed storage.

๏ปฟ

๐Ÿ” Authentication and User Isolation

Authentication is handled by AuthBasic.
When a user signs in, the application maintains the session and checks that state when the page loads.
๏ปฟ
The backend doesn't simply trust the task ID received from the frontend.
It first verifies the authenticated user and then works with user-scoped storage keys:
tasks:<userId>:<taskId>
The task index is also scoped to the user:
task-index:<userId>
This makes ownership part of the application's data model.

๏ปฟ

๐Ÿ”„ What Happens When I Create a Task?

This is where the different parts of the project come together.
๏ปฟ
When a user creates a task:
User
โ†“
React App
โ†“
AWS Blocks API Proxy
โ†“
ApiNamespace
โ†“
AuthBasic
โ†“
taskStore + indexStore
โ†“
Typed Task Response
โ†“
React State
โ†“
Updated UI
For example, ย App.tsxย  calls:
api.createTask(title)
The request reaches ย ApiNamespaceย , which verifies the session using ย requireAuth()ย .
The backend then stores the task using the authenticated user's identity and updates the user's task index.
Finally, the typed task is returned to React and added to the existing state, allowing the UI to update without a complete page reload.

๏ปฟ

๐Ÿ’ป Local-First Development

One of the aspects I particularly liked about this project is the local-first development workflow.
The application can be started with:
npm install
npm run dev
No AWS account is required for the local development workflow.
This makes it possible to build and test the application locally first, while keeping the project structured for AWS deployment later.

๏ปฟ

๐Ÿงช Testing

The project also includes end-to-end tests that exercise the application through its typed API.
The test suite covers important workflows such as authentication and task CRUD operations.
This allowed me to validate the backend behavior instead of relying only on manually testing the UI. The repository contains the E2E test suite in ย test/e2e.test.tsย .

๏ปฟ

๐Ÿง  What This Project Taught Me

The biggest learning from this project was understanding how a seemingly simple task manager can demonstrate real full-stack concepts.
I worked with:
  • React + TypeScript frontend architecture
  • AWS Blocks backend capabilities
  • Authentication and session handling
  • User-scoped data isolation
  • Typed API operations
  • KVStore data modeling
  • Local-first development
  • AWS deployment structure
  • End-to-end testing
The project helped me move from thinking about "building a UI" to thinking about the complete lifecycle of a request:
User โ†’ Frontend โ†’ API โ†’ Authentication โ†’ Storage โ†’ Response โ†’ UI

๏ปฟ

๐Ÿš€ What's Next?

The current implementation focuses on the core task-management workflow.
Possible future improvements include:
  • Task categories
  • Due dates and priorities
  • Search and filtering
  • Productivity analytics
  • Notifications and reminders
  • Further AWS deployment and production testing

๏ปฟ

๐ŸŽฏ Conclusion

Student Task Manager started as a small project for managing daily tasks, but it became a practical way for me to explore full-stack architecture with AWS Blocks.
The most valuable part was seeing how authentication, typed APIs, user-scoped storage, frontend state, and testing can work together as one application.
The complete source code is available on GitHub:
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