AWS Builder Center
Weekend Annoying Task Challenge: LinkTriage AI

Weekend Annoying Task Challenge: LinkTriage AI

A Serverless AWS app that sorts a messy "read later" list of saved links into Must Read, Quick Skim, Reference, and Ignore in one click.

Cloud Architect
Vision & What the App Does
As a developer and continuous learner, I constantly save AWS tutorials, technical articles, and documentation links to a "read later" list throughout the week. By the time the weekend rolls around, this list has turned into an overwhelming wall of text. Some of it is genuinely valuable. Some of it is clickbait I saved on autopilot and will never actually read. Manually re-reading and sorting that pile of links to figure out what is actually worth my time is a small but very real weekly chore. It usually ends the same way: I read none of it and just save more links on top.
I built LinkTriage AI to remove that decision fatigue entirely. It is a simple, serverless web app. You paste your messy list of saved links and titles, click one button, and it instantly sorts everything into four actionable categories: Must Read (high value, directly relevant), Quick Skim (good to know, under 5 minutes), Reference (worth keeping but not urgent), and Ignore (clickbait or no longer relevant). What used to be a vague pile of guilt becomes a clear, prioritized reading plan in seconds.

How I Built It

I wanted this to be strictly serverless and free tier friendly, so I kept the stack to just two AWS services. A static frontend on S3, and a single backend function on Lambda, connected directly through a Lambda Function URL instead of API Gateway. That meant one less moving part to configure.
The trickiest part of the build was CORS. I initially configured cross origin headers in two places at once: in the Lambda Function URL settings, and also manually inside my Python response. This meant the browser received a duplicated Access Control Allow Origin header with two values instead of one, and it silently blocked every request with a "Failed to fetch" error. I found the exact cause by opening the browser console and generating a SAM export of my function's configuration, which let me see both CORS sources side by side. Once I removed the manual headers from the Lambda code and let the Function URL handle CORS on its own, the request went through cleanly on the first try.
The second real constraint I hit was Amazon Bedrock's daily token quota on a brand new AWS account. It throttled every model invocation before I could get a single response back. Rather than wait on a quota increase request against the weekend deadline, I implemented the categorization logic as a lightweight, keyword based rule engine for this version. The Lambda function parses each item and checks it against category signals. Official docs and product pages score as Must Read. Older or informal blog posts score as Quick Skim. Code repositories score as Reference. Clickbait style phrasing scores as Ignore. The function returns the same structured JSON a model call would have returned. The architecture is built so that swapping this rule engine for a Bedrock Nova Micro prompt is a single function change once the account's quota is approved. The request and response contract on the frontend does not need to move at all.

AWS Services Used / Architecture Overview

LinkTriage AI runs on a lightweight, two service serverless architecture:
AWS Lambda is the backend logic layer, exposed directly through a public Lambda Function URL with no API Gateway involved. It receives the raw pasted text, categorizes each item, and returns structured JSON.
Amazon S3 hosts the static frontend, a single HTML and JS file, through Static Website Hosting. This gives the app a public, globally reachable URL with zero server management.
Architecture flow: The user pastes a messy list of links into the S3 hosted frontend. The browser sends a POST request straight to the Lambda Function URL. Lambda parses and categorizes the list. Lambda returns structured JSON. The frontend renders it into four color coded cards.
architecture-diagram.png

See the attached architecture diagram for a visual walkthrough of this flow, and the CORS diagram for how the header conflict was diagnosed and fixed.
cors-fix-diagram


What I Learned

This challenge was a genuinely useful crash course in the parts of serverless development that do not show up in tutorials until something breaks. I learned exactly how CORS negotiation works at the browser level, and why duplicate headers from two configuration sources cause a hard failure instead of a graceful fallback. I also got hands on experience with Lambda Function URLs as a simpler alternative to API Gateway for single endpoint use cases. I picked up a habit I will keep using going forward: exporting a function's SAM template is a fast way to see its actual deployed configuration when the console UI leaves you guessing. Finally, hitting a real quota limit on Bedrock was a good reminder to design for graceful degradation. Separating the categorization logic from the categorization engine meant a hard constraint did not have to block the whole project.

Link to App

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