Weekend Productivity Challenge: PriorityLens — AI That Sees What Matters Most
How I built a serverless AI productivity tool that uses Amazon Bedrock to auto-classify tasks into the Eisenhower Matrix and recommend your daily top 3 — deployed on AWS for under $0.05/month.
Vision & What the App Does
The Problem: Decision Fatigue is Killing Productivity
If you're a founder, engineering manager, team lead, or anyone juggling 30+ tasks at once — you know this feeling. You open your to-do list on Monday morning and freeze. Everything looks important. Everything feels urgent. You spend 20 minutes just deciding what to work on, which is ironic because that time could have gone toward actually doing the work.
The Eisenhower Matrix is a time-tested framework for this exact problem — classifying tasks by urgency and importance into four quadrants: Do First, Schedule, Delegate, and Eliminate. But here's the catch: manually categorizing tasks requires the same mental energy you're trying to save. You still need to sit there, look at each task, and ask yourself, "Is this urgent? Is this important?" — and most people just... don't.
The Solution: Let AI Do the Thinking
PriorityLens is an AI-powered productivity tool that removes the cognitive overhead entirely. You type what you need to do in plain language. The AI reads it, classifies it into the correct Eisenhower quadrant, assigns a priority score from 1-100, and tells you your top 3 tasks for today.
No setup. No sign-up flow. No decision fatigue. Just type and focus.
How it works from a user perspective:
- Type a task — "Prepare quarterly report for board meeting tomorrow" or "Maybe reorganize bookshelf someday"
- AI instantly classifies it — The first task gets placed in "Do First" with a score of 92. The second lands in "Eliminate" with a score of 12.
- See your Top 3 — A dedicated panel shows the three tasks you should tackle right now, updated in real time as you complete tasks.
- Work through your day — Complete tasks, watch the matrix update, and never wonder "what should I do next?" again.
Light mode
Dark mode:
The app works on desktop and mobile, supports dark/light/system themes, and maintains your data across sessions — all without requiring an email or password.
See It In Action: Real AI Classification Results
To demonstrate how PriorityLens works, I fed it 10 tasks that different professionals might face on any given day — from a founder preparing an investor pitch to an engineer deploying a hotfix to someone casually browsing standing desks. Here's what the AI produced:
The Input: 10 Tasks From Different Worlds
| Task | Who Thinks This |
|---|---|
| "Finalize investor pitch deck — presenting tomorrow at 9 am" | Founder |
| "Review and approve Q3 budget proposal before end of day" | Manager |
| "Deploy hotfix for checkout payment bug reported by 12 customers" | Engineering Lead |
| "Plan team offsite agenda for next quarter's strategy session" | Team Lead |
| "Complete AWS Solutions Architect certification study module 5" | Senior Engineer |
| "Draft blog post about our new product launch for next week" | Marketing Lead |
| "Reply to vendor emails about office supply renewal" | Operations |
| "Update Jira ticket labels and sprint board formatting" | Project Manager |
| "Reorganize Google Drive folder structure for old projects" | Anyone |
| "Browse new standing desk options on Amazon" | Anyone |
The Output: AI-Classified Eisenhower Matrix
The AI analyzed each task's language, detected urgency signals and importance indicators, and produced this classification:
🔴 Do First (Urgent + Important) — Scores 90-95:
| Task | Score | Why AI Chose This |
|---|---|---|
| Deploy hotfix for checkout payment bug reported by 12 customers | 95 | "hotfix" + "bug" + customer impact = urgent AND important |
| Review and approve the Q3 budget proposal before the end of the day | 95 | "before end of day" = hard deadline + "budget approval" = high impact |
| Finalize investor pitch deck — presenting tomorrow at 9 am | 95 | "tomorrow at 9am" = imminent deadline + investor-level importance |
🟡 Schedule (Important, Not Urgent) — Scores 60-65:
| Task | Score | Why AI Chose This |
|---|---|---|
| Plan team offsite agenda for next quarter's strategy session | 65 | "strategy" + "next quarter" = important but no immediate deadline |
| Complete AWS Solutions Architect certification study module 5 | 65 | Career growth keyword + no time pressure |
| Draft blog post about our new product launch for next week | 60 | "next week" = has timeline but not urgent + "product launch" = important |
🔵 Delegate (Urgent-ish, Not Important) — Scores 25-35:
| Task | Score | Why AI Chose This |
|---|---|---|
| Update Jira ticket labels and sprint board formatting | 35 | Administrative, low cognitive value, someone else could do it |
| Reply to vendor emails about office supply renewal | 30 | Responsive (needs reply) but low strategic impact |
| Reorganize Google Drive folder structure for old projects | 25 | Housekeeping task, no deadline, no strategic value |
⚪ Eliminate (Neither Urgent Nor Important) — Score 15:
| Task | Score | Why AI Chose This |
|---|---|---|
| Browse new standing desk options on Amazon | 15 | "Browse" + "options" = no action commitment, pure distraction |
Today's Top 3: AI's Daily Focus Recommendation
From all incomplete tasks, the AI selected the three highest-priority items:
> 1. Deploy hotfix for checkout payment bug reported by 12 customers (Score: 95)
> 2. Review and approve Q3 budget proposal before the end of the day (Score: 95)
> 3. Finalize investor pitch deck — presenting tomorrow at 9 am (Score: 95)
> 2. Review and approve Q3 budget proposal before the end of the day (Score: 95)
> 3. Finalize investor pitch deck — presenting tomorrow at 9 am (Score: 95)
Notice how the Top 3 are all from the "Do First" quadrant — these are the tasks with hard deadlines and real consequences if missed. The AI doesn't just sort by score; it understands that "12 customers affected" and "presenting tomorrow" carry more weight than "next quarter".
How the Algorithm Works
The classification isn't magic — it's structured prompt engineering with clear rules:
- Urgency detection — The AI scans for time signals: "tomorrow", "end of day", "ASAP", specific dates, "hotfix", "bug" (implies production urgency). Tasks with these keywords get urgency = high.
- Importance detection — It looks for impact signals: "investor", "budget", "customers", "strategy", "certification", "product launch". Tasks with outcome-related keywords get importance = high.
- Quadrant assignment — Classic Eisenhower logic:
- Urgent + Important → Do First
- Important + Not Urgent → Schedule
- Urgent + Not Important → Delegate
- Neither → Eliminate
- Score calibration — Each quadrant has a base score range (Do First: 75-100, Schedule: 50-74, Delegate: 25-49, Eliminate: 1-24). The AI adjusts within that range based on specificity, the proximity of the deadline, and the strength of the action verb.
- Context awareness — The prompt includes the user's current task count and today's date, so "tomorrow" resolves to an actual day and relative urgency adjusts based on workload.
The result: a system that takes less than 500ms to classify a task and matches how an experienced productivity coach would categorize it — but without the $200/hour consulting fee.
How I Built It
Development Approach: Spec-Driven with Kiro AI IDE
Rather than jumping straight into code, I used Kiro (an AI-powered IDE) to follow a structured spec-driven development workflow. This meant defining requirements, generating a design document, and breaking the project into implementation tasks before writing a single line of code.
This approach was critical for a weekend challenge because it eliminated the classic "I'll figure out the architecture as I go" trap that turns weekends into weeks.
The development flow:
- Requirements spec — Defined 10 formal requirements with acceptance criteria covering task creation, AI categorization, priority scoring, top-three recommendations, completion/deletion flows, display rules, API design, persistence, and user identification.
- Design document — Produced a full technical design including component diagrams, API contracts, data models, error handling strategy, and a testing plan with property-based testing.
- Task breakdown — The spec generated ~20 implementation tasks in dependency order. Each task was small, testable, and focused.
- Implementation — Worked through tasks sequentially. The backend was built first (types → DB → AI service → business logic → handler), then the frontend (state management → components → integration).
Kiro IDE requirement
Kiro IDE Design
Kiro IDE Task List
Key Technical Decisions
Why a single Lambda function instead of one per route?
For this scale, a single Lambda with internal routing is simpler to deploy, has shared cold starts across routes, and keeps the SAM template minimal. At 7 routes, the overhead of managing 7 separate functions (permissions, environment variables, logging) isn't justified.
Why DynamoDB single-table design?
The app has exactly two access patterns: "get all tasks for a user" and "get incomplete tasks sorted by priority score." A single table with one GSI handles both perfectly. No joins, no relational complexity, and the PAY_PER_REQUEST billing means zero cost at low scale.
Why Amazon Nova Micro instead of larger models?
The task — reading a sentence and outputting 3 JSON fields — is lightweight. Nova Micro handles it in ~300-500ms at a fraction of the cost of larger models. For a structured classification task with clear rules in the prompt, you don't need a reasoning-heavy model - the tradeoff: slightly less nuanced categorization of ambiguous tasks, which is acceptable.
Why "Write-Then-Enrich" instead of waiting for AI?
When a user creates a task, the app saves it immediately to DynamoDB with defaults (quadrant: "schedule", score: 50), then calls Bedrock . If AI succeeds, the task is updated. If AI fails, the task still exists and can be completed. This means the user is never blocked by AI latency or failures — the UX stays snappy regardless of Bedrock's availability.
Why no authentication (Cognito)?
For a personal productivity tool used by one person, a UUID stored in localStorage is sufficient. Adding Cognito would mean: sign-up flows, password resets, token refresh logic, and a dependency that adds zero value for the target use case. It's listed as a future enhancement, but it's explicitly not needed for a weekend MVP.
Why CSS custom properties over Tailwind?
Zero dependencies, full design control, and a smaller bundle. The theme system uses 80+ CSS tokens with smooth transitions between light/dark modes. For a solo project where you are the design system, utility classes add overhead without adding value.
Challenges Encountered
Challenge 1: AI response parsing reliability
Bedrock doesn't always return clean JSON. Sometimes the response is wrapped in markdown code blocks; sometimes there's prose before/after the JSON.
The solution: a robust parser that strips markdown fences, regex-matches the JSON object, validates all fields, and falls back to defaults on any failure. This makes the system bulletproof regardless of model output quirks.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
export function parseAiResponse(rawResponse: string): AiResult {
try {
// Try to extract JSON from the response (handle possible markdown code blocks)
let jsonStr = rawResponse.trim();// Remove markdown code block wrappers if present
const jsonBlockMatch = jsonStr.match(/(?:json)?\s*([\s\S]*?)/);
if (jsonBlockMatch) {
jsonStr = jsonBlockMatch[1].trim();
}
// Try to find a JSON object in the string
const jsonObjectMatch = jsonStr.match(/{[\s\S]*}/);
if (!jsonObjectMatch) {
return { ...DEFAULT_AI_RESULT };
}
const parsed = JSON.parse(jsonObjectMatch[0]);
// Validate and extract quadrant
const quadrant = validateQuadrant(parsed.quadrant);
// Validate and extract priority score
const priorityScore = validatePriorityScore(parsed.priorityScore);
// Extract reasoning (optional, default to empty string)
const reasoning = typeof parsed.reasoning === 'string' ? parsed.reasoning : '';return { quadrant, priorityScore, reasoning };
} catch {
return { ...DEFAULT_AI_RESULT };
}
}Challenge 2: Circuit breaker for Bedrock
During development, I hit Bedrock throttling limits. Without protection, failed AI calls would pile up, each with 3 retries × 5-second intervals = 15 seconds of Lambda execution time per task. The circuit breaker pattern solves this: after 3 consecutive failures, the system stops calling Bedrock for 60 seconds, assigns defaults, and resumes automatically. Users never see a degraded experience.
Challenge 3: Optimistic UI with rollback
To make the app feel instant, task completion/deletion updates the UI immediately before the API responds. But what if the API fails? The Zustand store captures the previous state before each action and rolls back if the request fails. This gives users <16ms feedback while maintaining data consistency.
Creating Task
Challenge 4: CORS configuration with API Gateway
API Gateway's CORS handling with Lambda proxy integration has a well-known gotcha: error responses (4xx/5xx) from the gateway itself (not Lambda) don't include CORS headers by default. This means throttled requests or invalid API keys return a CORS error in the browser instead of the actual error.
The fix: configuring GatewayResponses for DEFAULT_4XX and DEFAULT_5XX to include CORS headers.
AWS Services Used / Architecture Overview
Services Used
| AWS Service | Role | Why This Service |
|---|---|---|
| Amazon Bedrock (Nova Micro v1) | AI classification & scoring | Managed AI inference — no model hosting, no GPUs, pay-per-token |
| AWS Lambda (Node.js 20.x) | Backend compute | Serverless, scales to zero, 1M free requests/month |
| Amazon API Gateway (REST) | API layer + auth + rate limiting | Built-in API key validation, usage plans, CORS |
| Amazon DynamoDB | Task storage | Single-digit ms latency, PAY_PER_REQUEST, always-free tier |
| AWS Amplify Hosting | Frontend CDN + CI/CD | Git-based deploys, HTTPS, custom headers, free tier |
| AWS SAM | Infrastructure as Code | CloudFormation-based, purpose-built for serverless |
Architecture Diagram
High Level Architecture - AI Smart Priority Lens
Why NOT These Alternatives?
| Alternative | Why We Didn't Use It |
|---|---|
| EC2/ECS for compute | Overkill. Lambda handles bursty, low-traffic workloads perfectly at zero baseline cost. No servers to patch. |
| RDS/Aurora for storage | A relational DB adds VPC complexity, connection pooling concerns, and minimum ~$15/month. DynamoDB with 2 access patterns is a better fit. |
| OpenAI/Claude API directly | Vendor lock-in outside AWS, separate billing, no IAM integration. Bedrock gives unified access with AWS credentials. |
| Cognito for auth | Adds sign-up friction for a personal tool. The challenge says "personal productivity tool" — anonymous UUID works. |
| Step Functions for orchestration | The write-then-enrich pattern is simple enough for inline code. Step Functions would add latency and cost for a 2-step flow. |
| SQS for async AI processing | Considered, but synchronous gives users immediate feedback. With the circuit breaker pattern, we get resilience without message queuing complexity. |
| S3 + CloudFront for hosting | Amplify does the same thing with less configuration — Git push deploys, HTTPS, custom headers, all built-in. |
DynamoDB console showing the ai-smart-todo table with PK/SK structure, GSI1, and actual task items demonstrating the single-table design
DynamoDB Showing Task List
Cost Profile
For a single user with typical usage (1,000 tasks/month):
| Service | Monthly Cost |
|---|---|
| Lambda | $0.00 (free tier) |
| API Gateway | $0.00 (free tier) |
| DynamoDB | $0.00 (free tier) |
| Bedrock (Nova Micro) | ~$0.05 |
| Amplify Hosting | $0.00 (free tier) |
| Total | ~$0.05/month |
This entire application runs for less than a nickel a month. The AWS Free Tier covers everything except Bedrock inference, which is negligible at Nova Micro's pricing ($0.000035/1K input tokens).
Security Layers
Even without full authentication, the app implements defense-in-depth:
- API Key validation — Every request must include a valid
x-api-keyheader, checked at the API Gateway layer before reaching Lambda - Rate limiting — API Gateway usage plan enforces 100 req/s sustained, 50 burst, and a hard cap of 10,000 requests/day
- Input validation — Server-side validation of all inputs (description length 1-500 chars, UUID v4 format for user/task IDs)
- Data isolation — Each user's tasks are partitioned by userId in the DynamoDB partition key — no cross-user data access is possible
- CORS — Configured at API Gateway with specific allowed headers and methods
- Frontend security headers — Amplify serves all responses with HSTS, X-Frame-Options: DENY, and X-Content-Type-Options: nosniff
- User identification — Anonymous UUID v4 stored in localStorage — no PII collected, no credentials to leak
Security Considerations for Priority Lens Application
AI Prompt Engineering
The Bedrock prompt is structured to produce deterministic, parseable output. Key elements:
- Explicit classification rules — Each Eisenhower quadrant has defined conditions (e.g., "do-first" = urgent AND important with time keywords like "today", "deadline", "tomorrow")
- Score calibration ranges — Each quadrant maps to a base score range (Do First: 75-100, Schedule: 50-74, Delegate: 25-49, Eliminate: 1-24) with adjustments for specificity and deadline proximity
- Context injection — The prompt includes the user's current task count and today's date, so relative time references ("by Friday") resolve correctly
- Output constraint — The prompt ends with "Return ONLY a valid JSON object" to minimize model verbosity and simplify parsing
- Defensive parsing — Despite the constraint, the response parser handles markdown fences, extra prose, and malformed output with regex extraction and validated fallbacks
AI Prompt Strategy
This approach keeps AI behavior predictable and testable while still leveraging the model's natural language understanding for nuanced classification.
What I Learned
1. Spec-driven development compresses timelines
Writing requirements before code feels slow, but it eliminates the "wait, what should this endpoint actually return?" moments mid-implementation. For a 48-hour challenge, having a clear contract between frontend and backend meant both could be built in parallel (mentally, at least) without integration surprises.
2. Amazon Nova Micro is surprisingly capable for structured tasks
I initially assumed I'd need Claude 3 Haiku for quality task classification. Nova Micro handles it at ~1/10th the cost with comparable accuracy for this specific use case (structured JSON output from a short text input with clear classification rules). The key insight: match model capability to task complexity, not to marketing tier.
3. The circuit breaker pattern is essential for AI-backed features
AI services have variable latency and occasional failures. Without a circuit breaker, one bad minute from Bedrock could cascade into Lambda timeouts, client retries, and a degraded experience. The pattern (3 failures → 60s cooldown → auto-recover) took 30 minutes to implement and saves hours of potential debugging.
4. Write-then-enrich unlocks great UX with unreliable dependencies
The single best architectural decision was decoupling "save the task" from "AI-classify the task." Users never wait for AI. Tasks appear instantly. AI enriches them in the background. If AI dies, the app still works. This pattern applies broadly to any feature where an external service enhances but isn't required for core functionality.
5. DynamoDB single-table design clicks when access patterns are clear
If you know your queries upfront (and you should, via spec-driven design), single-table DynamoDB is elegant. One table, one GSI, two access patterns, zero maintenance. The learning curve is in designing the key schema, not in operating the database.
6. Serverless cost at low scale is effectively free
The total infrastructure cost for this project during development and testing is less than $1. Lambda, API Gateway , DynamoDB, and Amplify all stay within the free tier for a personal tool. The only line item is Bedrock inference , and Nova Micro makes even that negligible. For portfolio projects and MVPs, serverless on AWS is the optimal cost story.
7. Optimistic UI with rollback is worth the implementation effort
The difference between "click → wait 500ms → see result" and "click → instant result" is visceral. Zustand makes this straightforward: snapshot state before the action, apply the update, call the API, rollback on failure. The 10 extra lines of code per action make the app feel native.
What's Next: Future Enhancements
PriorityLens was built as a weekend MVP, but the architecture is designed to grow. Here's the roadmap:
| Enhancement | Why It Matters |
|---|---|
| Amazon Cognito authentication | Replace anonymous UUIDs with real accounts — enables cross-device sync and proper per-user rate limiting |
| Recurring tasks | Scheduled Lambda that auto-generates daily/weekly tasks (e.g., "Review inbox every morning") |
| Natural language dates | Parse "by Friday" or "next Tuesday" into deadline fields, giving the AI stronger urgency signals |
| Team collaboration | Share quadrant views with team members — a manager can see their team's prioritized workload |
| Mobile app (React Native) | Shared TypeScript types between web and mobile, same Zustand store architecture |
| Offline mode | Service worker + IndexedDB for offline task creation, sync when reconnected |
| Productivity analytics | Track completion patterns over time — which quadrant do you spend most time in? Are you actually doing your "Do First" tasks first? |
| AI response caching | Cache Bedrock results for similar task descriptions to cut cost and latency |
| Per-user rate limiting | WAF rules or custom authorizer to throttle by user ID, preventing single-user abuse |
Upcoming Future Enhancement List
The serverless architecture means none of these require infrastructure migrations — they're additive. Cognito slots into API Gateway as an authorizer. Recurring tasks are a single EventBridge + Lambda rule. Analytics is a DynamoDB Stream feeding into a lightweight aggregation function.
Link to App or Repo
GitHub Repository: https://github.com/bdmostafa/ai-smart-priority-lens
Amplify Live Link:
https://master.xxxxxxx.amplifyapp.com/ (taken down after testing — API key is embedded in the frontend bundle, so the live deployment was removed to prevent unauthorized usage and cost exposure)The repository includes:
- Complete frontend source (React 19 + TypeScript + Vite)
- Complete backend source (Lambda + Bedrock + DynamoDB)
- AWS SAM template for one-command infrastructure deployment
- 100+ unit and property-based tests
- Architecture documentation and deployment guide
Built during the AWS Builder Center Weekend Productivity Challenge, July 2026.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article