
Weekend Agent Challenge: Opportunity Scout
An always-on AI agent that wakes itself up daily, discovers and scores hackathons, scholarships, grants, and fellowships against your profile, and emails a prioritized briefing. It's built on EventBridge, Lambda, DynamoDB, and SES, with a pluggable AI layer.
Vision and What the Agent Does
Opportunities (hackathons, scholarships, grants, fellowships, competitions, conferences) are everywhere, but they're scattered across dozens of platforms with no common thread. The real problem isn't a lack of listings; it's the mental load of hunting for them, evaluating whether they're worth your time, and remembering deadlines before they quietly pass. I built Opportunity Scout to remove that load entirely, not just organize it.
Opportunity Scout is an always-on AI agent that discovers, scores, and prioritizes opportunities for ambitious builders, students, and professionals, and it does this without anyone ever clicking a button. Every morning, it wakes itself up, does the work, and has a briefing waiting in your inbox by the time you check your phone.
What triggers it: an Amazon EventBridge Scheduler rule fires daily at 6:00 AM WAT, invoking the ScoutAgentRun Lambda function directly. That function has no Function URL and no user-facing entry point of any kind; it can only be started by the schedule. That constraint was deliberate. The entire premise of this challenge is that the agent does its work unattended, and I wanted that to be structurally true, not just true in spirit.
What it does on its own: it pulls new opportunities from multiple sources, filters out anything it's already told the user about, analyzes each one against the user's profile, scores it across multiple dimensions (domain fit, innovation level, career value, difficulty, time required, travel required, funding available), computes a single "prioritize this" recommendation, checks for approaching deadlines, persists everything, and composes an email digest, all before sending a single notification.
How it reports back: an SES email digest leads with the single highest-priority recommendation (why it matters, urgency, estimated effort, next step), followed by deadline nudges for anything time-sensitive, then the rest of what it found. The same intelligence renders as an "executive briefing" in the web app for anyone who wants to browse rather than wait for the email.
How I Built It
The project is a TypeScript monorepo with four workspaces: a React/Vite frontend, an AWS CDK infrastructure layer, a shared package holding the core data schema and prioritization logic, and the Lambda backend itself.
The most important architectural decision was making one schema the single source of truth. A Zod schema (category, summary, fit score, fit reasoning, a multi-axis scores object, deadline, and checklist) is the only shape any part of the system produces or consumes. Ranking, recommendations, nudges, and urgency are all just derived views over that one schema, computed in the shared package, so the email digest and the web UI can never quietly drift apart.
The second key decision was isolating the AI analysis step behind a single createAnalyzer() factory with interchangeable implementations (mock, Amazon Bedrock, and Gemini), so the model powering the agent is a one-line configuration swap, not an architectural commitment.
That decision earned its keep almost immediately. Amazon Bedrock turned out to be blocked account-wide: every model's daily token quota was applied at zero and marked "not adjustable" across every region I tried, confirmed directly in the Service Quotas console. Rather than lose hours waiting on a support case with no guaranteed timeline, I pivoted to a deterministic mock analyzer behind the same interface, which let me build and fully verify the entire autonomous loop (discovery, deduplication, scoring, persistence, nudging, digesting) end to end without being blocked by AI provider access. I later wired a real Gemini integration as a second option. It works, but Gemini's free tier restricted the specific model to new keys and rate-limited requests to 5/minute, which isn't practical for batch-analyzing dozens of opportunities in one run. That integration lives in the repo and is a one-line swap away from being the live analyzer; the running demo uses the deterministic version so the autonomous behavior itself is never in question.
Other real obstacles along the way: an Amplify monorepo build failure ("Illegal path for appRoot") fixed with an explicit build spec; a CloudFormation circular dependency between the Amplify domain and a Lambda Function URL's CORS configuration, resolved by fixing the web origin instead of letting it resolve dynamically; an ESM bundling error in Lambda traced to the esbuild output configuration; and a Lambda concurrency quota that required dropping reserved concurrency.
I also made a point of keeping the boundary between "autonomous" and "user-driven" honest rather than blurred. The agent cannot know a user actually submitted an application, so tracker stage changes stay user-driven by design; pretending otherwise would be fabrication, not intelligence. Similarly, a lightweight behavior-learning feature tracks which categories a user engages with past "saved" and nudges future scoring slightly in that direction. It's a real but modest heuristic, described as exactly that rather than oversold as machine learning.
AWS Services Used / Architecture Overview
- AWS Lambda (Node.js 22, ESM): six functions. ScoutAgentRun is the scheduled core (512MB, 10-minute timeout, no public entry point), plus five Function-URL-backed APIs (RefineQuery, ExtractFromPastedContent, UpsertProfile, GetUserOpportunities, UpdateOpportunityStage)
- Amazon EventBridge Scheduler: the daily trigger for ScoutAgentRun, with retries and a dead-letter queue for failed invocations
- Amazon DynamoDB: three tables. Users (profile plus engagement stats), Opportunities (scores, dedup markers), AgentRuns (an audit log of every autonomous run)
- Amazon SES v2: sends the daily digest, sandbox-verified sender, least-privilege IAM condition scoped to the sending address
- Amazon Cognito: self-signup with email verification
- AWS Amplify Hosting: the React frontend, auto-deployed from GitHub
- AWS CDK (TypeScript): infrastructure as code, least-privilege IAM per function
- AI layer: architected to be provider-agnostic. Amazon Bedrock (Nova) was the original target, Gemini is implemented as an alternative, and the live demo runs a deterministic analyzer behind the same interface
Flow: EventBridge triggers ScoutAgentRun, which runs discovery connectors (Devpost, GitHub, Google for Developers, IEEE), deduplicates results, sends them to the analyzer, writes to DynamoDB, computes a recommendation plus nudges, sends the SES digest, and logs the run to AgentRuns.
What I Learned
Building something genuinely unattended is a different discipline than building a request/response app. Error isolation became a first-class concern in a way it never is when a human is present to notice and retry: a failed email send can't be allowed to lose already-persisted work, and a single connector or analysis failure can't be allowed to sink an entire run. I also learned, the hard way, the practical limits of "free" AI tiers in production-shaped workloads. Bedrock's new-account quota gate and Gemini's free-tier rate limits both taught me that provider access is its own kind of infrastructure risk, worth designing around from day one rather than discovering under deadline pressure. Isolating the AI layer behind one interface turned what could have been a blocking failure into a minor pivot, a pattern I'll carry into future projects regardless of provider.
Link to App or Repo
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article