Weekend Productivity Challenge: AI Task Prioritizer

TL;DR / Key Takeaways

1. The Problem: I built a web application to solve decision fatigue by automatically sorting messy brain-dump to-do lists into High, Medium, and Low priorities using AI.
2. The Tech Stack: The app relies on a decoupled architecture featuring a vanilla Bootstrap 5 frontend, a Python Flask API, and the Gemma 3 (4B) model hosted via Ollama.
3. The Infrastructure: Everything is deployed on AWS using a custom CloudFormation template that provisions a VPC, an EC2 t3.large instance, and an S3 bucket for data storage.

Introduction

Table of Contents

• The Core Vision: What the App Actually Does
• The Architecture: AWS Services and Why I Chose Them
• The Engineering: How I Built It & What I Learned
  • The Development Process
  • Challenges and The Desi Jugaad
  • What I Learned
• Frequently Asked Questions
• Conclusion
• Check Out the Code

The Core Vision: What the App Actually Does

1. The Input: You open the sleek, dark-themed dashboard and paste your completely unfiltered, messy to-do list into a text area. No formatting required.
2. The Engine: You click "Prioritize My Life". The frontend sends this text to a custom backend hosted in the cloud.
3. The Output: Within seconds, the AI analyzes the context of each task. It returns a clean, structured list grouped by High, Medium, and Low priority. Better yet, it provides a one-sentence logical reason for why a task was given that specific priority.

The Architecture: AWS Services and Why I Choose Them

• AWS CloudFormation: I did not want to click around the AWS console manually like a beginner. I wrote a YAML CloudFormation template to script my entire infrastructure. This allowed me to deploy the network and servers in just a few minutes.
• Amazon VPC & Networking: The template creates an isolated Virtual Private Cloud (VPC) with an Internet Gateway, a Public Subnet, and custom Route Tables to ensure the app is accessible securely over the internet.
• Amazon EC2 (Elastic Compute Cloud): This is the heavy lifter. I deployed a t3.large Ubuntu instance. Why this specific size? Because running a 4-billion parameter LLM locally requires a decent chunk of RAM, and the t3.large gives a good balance of cost and performance. I configured the Security Group to only allow SSH (port 22) and API traffic (port 5000).
• Amazon S3 (Simple Storage Service): I provisioned an S3 bucket (ai-task-prioritizer-data) attached via an IAM Role and Instance Profile. Right now, it acts as a foundation for future features, like storing user history logs or custom model weights.

The Engineering: How I Built It & What I Learned

The Development Process

1. Bootstrapping the Server: First, I deployed the CloudFormation stack. I used a bash script in the UserData section of the EC2 configuration to automatically install Ollama, pull the gemma3:4b model, and install Python dependencies.
2. Writing the API: I built a lightweight backend using Python. My requirements.txt specifically called for Flask>=3.0.0, Flask-Cors>=4.0.0, and requests>=2.31.0. I wrote a single /prioritize route that accepts the raw text and packages it into a strict prompt.
3. Crafting the Frontend: I wanted a premium feel, so I used Bootstrap 5 with custom CSS to create a glassmorphism effect. The UI includes dynamic loading spinners, collapsible settings to input the EC2 IP address, and color-coded task cards.

Challenges and The Desi Jugaad

What I Learned

• Local LLM Hosting is Powerful: I learned how incredibly easy it is to self-host models using Ollama on an EC2 instance. It gives you complete data privacy.
• Infrastructure as Code (IaC): Writing the CloudFormation template taught me the value of repeatable deployments. If I mess up the server, I can tear it down and spin up an identical one in exactly 5 minutes.
• Prompt Engineering is Coding: I realized that framing the context and constraints for an LLM is a unique coding syntax of its own.

Screenshots

1. How much does it cost to run this AI model on AWS?
   Running a t3.large instance on AWS costs roughly $0.08 to $0.09 per hour depending on the region. Since this was a weekend project, the total cost for development and testing was less than a cup of coffee. You can always stop the instance when you aren't actively prioritizing tasks to save money.
2. How does the frontend connect to the cloud backend?
   The frontend is a static HTML file that uses JavaScript's fetch() API. It hits a specific endpoint (http://<YOUR-EC2-IP>:5000/prioritize). I built a settings panel in the UI where you can simply paste your active EC2 Public IP, saving it to your browser's local storage so you don't have to hardcode anything.
3. Can I use a different AI model besides Gemma 3?
   Absolutely. Because the app uses Ollama as the model runner, you can SSH into your EC2 instance and run ollama pull llama3 or mistral. You just need to update the model name in the app.py payload to match the new model you downloaded.

Conclusion

Check Out the Code

• AWS User Group Kolkata Meetup: Building AI Web Apps with Amazon Bedrock 
• AWS Summit Bengaluru 2026: An Epic Ride of Networking, Cloud, and Community! 
• Scaling Web3 Infrastructure: Containerized Workloads on AWS 
• Pixel Perfect Power Building Tetris with Amazon Q CLI Game 3