
๐ 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 + TypeScriptBuild Tool โ ViteBackend โ AWS Blocks ApiNamespaceAuthentication โ AWS Blocks AuthBasicStorage โ AWS Blocks KVStoreRuntime โ Node.jsTesting โ End-to-End API testsThe 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 IDsThe 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 UIFor 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 installnpm run devNo 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:
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article