AWS Builder Center
Weekend Showcase Challenge: Serverless Task Tracker

Weekend Showcase Challenge: Serverless Task Tracker

This project is a streamlined, serverless to-do application that ensures tasks persist across page reloads by leveraging robust cloud infrastructure. Built entirely on AWS, it provides a lightweight frontend connected to an API-driven backend architecture for seamless, highly available task management.

Vision and What It Does

The "hello world" of web development is often a basic to-do list, but most beginner iterations suffer from a critical flaw: data volatility. The moment a user refreshes the browser, their entire list vanishes. The vision for this project was to bridge the gap between a simple, accessible user interface and enterprise-grade backend persistence. This application solves the problem of ephemeral data by allowing users to add and delete tasks that are persisted directly in an Amazon DynamoDB database. Because the tasks live in the cloud database rather than local browser storage, they survive page reloads reliably.
The user experience is designed to be highly responsive and visually distinct. I opted for a brutalist, high-contrast aesthetic featuring a bright yellow background ( #ffe14d ), stark uppercase typography utilizing the Space Grotesk font, and thick black borders. When a user types a new item into the input field placeholder labeled "WHAT NEEDS DOING?" and hits the Add button, the task is logged to the database and populates the screen with a dedicated red deletion button.

How I Built It

I approached the build by strictly decoupling the frontend client from the backend API. The frontend is a static HTML page relying entirely on standard JavaScript  fetch  calls rather than a heavy web framework. To ensure the application could move easily between environments, the base API URL is stored in a dedicated  config.js  file, which is designed to be overwritten dynamically at deploy time with the final API Gateway URL.
A key architectural decision was designing the DynamoDB schema for simplicity and speed. For this demonstration, the database relies on a single shared list keyed by a fixed partition string called "todo". To guarantee that each task has a unique identifier, the Python backend generates an ID by combining the current timestamp in milliseconds with a truncated UUID. The Lambda function acts as a centralized router; it inspects the HTTP method from the incoming request context and directs the flow to specific helper functions like _list(), _add(event), or _delete(event). If a user attempts to hit the API with an unsupported method, it gracefully returns a 405 error code indicating the method is not allowed.
The primary challenge during development was navigating Identity and Access Management (IAM) and Cross-Origin Resource Sharing (CORS). I had to meticulously construct a Lambda execution role and attach an IAM policy that explicitly permitted  dynamodb:PutItem ,  dynamodb:DeleteItem , and  dynamodb:Query  actions specifically for my table's Amazon Resource Name (ARN). Furthermore, when provisioning the API Gateway via the AWS CLI, configuring CORS required a specific flag to allow  GET ,  POST ,  DELETE , and  OPTIONS  methods, ensuring the frontend could communicate with the API without triggering browser security blocks.

AWS Services Used and Architecture Overview

The application relies on a completely serverless architecture, meaning there are no virtual machines to provision or manage. The infrastructure consists of the following components:
  • AWS Lambda: Handles the core business logic, utilizing a Python 3.12 runtime to read from and write to the database.
  • Amazon DynamoDB: Acts as the NoSQL storage layer, utilizing a PAY_PER_REQUEST billing mode to ensure costs remain tied directly to actual database usage. The table schema is minimal, using pk as the partition key and sk as the sort key.
  • API Gateway (HTTP API): Serves as the front door for the backend, exposing the Lambda function over HTTP and routing traffic via a default catch-all route. The defined API contract dictates that  GET /todo  fetches items,  POST /todo  creates an item (returning a 201 status), and  DELETE /todo?id=<id>  removes it.
  • Amazon S3: Serves as an optional hosting environment for the static frontend assets, though the HTML file can also be run locally using a simple Python HTTP server on port 8000.

What I Learned Across the Summer

Diving deep into cloud architecture this summer fundamentally shifted my approach to software engineering. I learned that "serverless" development shifts a developer's focus entirely away from operating systems and server maintenance, allowing for pure concentration on business logic and API contracts. Building this application solidified my grasp on stateless application design. Because Lambda functions spin up on demand and shut down rapidly, they cannot rely on local state or memory; every single request must be self-contained and independently query the DynamoDB table.
Additionally, I gained a profound appreciation for automating infrastructure. By deploying this application entirely through AWS CLI commands rather than clicking through a web console, I learned how to codify infrastructure. Creating the database, provisioning IAM roles, and linking the API Gateway programmatically taught me the vital importance of repeatable, error-free deployments. Navigating these tools underscored the principle of least privilege—granting a system only the exact database permissions it requires to function, thereby drastically reducing security risks.
App Screenshot

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