
AIdeas: Global Impact AI Navigator
Global Impact AI Navigator is a multi-agent AI platform that transforms a raw idea into a complete strategy: SWOT diagnostic, feasibility/impact scoring, SDG alignment, real funding opportunities via live web search, personalized roadmap, and a context-aware AI advisor. Designed for innovators in emerging markets, it democratizes access to strategic guidance in under 60 seconds.
Global Impact AI Navigator falls squarely in the Social Impact category. It is a platform built to democratize access to strategic guidance, funding discovery, and actionable planning for entrepreneurs, students, NGOs, and innovators — especially those in emerging markets where information asymmetry is the single biggest barrier between a great idea and a real-world project.
You can try the mvp here: Global Impact AI Navigator
You can try the mvp here: Global Impact AI Navigator
My Vision
The Problem
Every year, millions of high-potential social impact ideas never see the light of day. A student in Nairobi with a water-purification concept, an engineer in Dhaka with an affordable medical device, or a cooperative in Bogotá with an agrotech solution — they all face the same wall: fragmented information, no mentorship, and zero visibility into the funding landscape.
Traditional approaches require hiring consultants, attending expensive conferences, or simply knowing the right people. That does not scale.
What I Built
Global Impact AI Navigator is a full-stack, AI-powered decision-support platform that transforms a raw idea — even just a few sentences — into a comprehensive strategic package:
- A SWOT diagnostic — sector classification, strength/weakness analysis, feasibility and impact scoring (0–100), SDG alignment, key risks, and actionable recommendations.
- A live-funded opportunity portfolio — real grants, accelerators, competitions, and impact investment programs discovered via Amazon Nova Web Grounding (live internet search with citations), not hallucinated links. Users choose what they need (financing, mentoring, incubation, networking, training, technical support, market access, legal support) and the search is tailored to those needs.
- A personalized roadmap — a time-boxed action plan (2 weeks → 6 months) tailored to the project's maturity, region, and SWOT findings, with specific funding recommendations and success factors.
- A context-aware AI advisor — a chat interface that remembers the full project context (SWOT, opportunities, roadmap) and can answer follow-up questions, refine strategies, or brainstorm pivots.
- A guided assessment quiz — for users who don't know where to start, a 5-question interactive quiz builds a structured idea and launches the full analysis pipeline automatically.
The platform is designed around three design principles:
- Accessible — works on mobile, tablet, or desktop; works without AWS credentials in mock-data mode for demos
- Honest — scoring is conservative, weaknesses are surfaced alongside strengths, funding links are real (web-grounded)
- Actionable — every output is a concrete next step, not vague encouragement
Why This Matters
The information gap is real — and it costs the world
According to the UN, over 1.3 billion people live in multidimensional poverty. Many solutions to their challenges already exist as ideas in the minds of local innovators — but these ideas are stuck at the concept stage because their creators lack:
- Strategic clarity — Is my idea viable? What are the risks? What sector does it really belong to?
- Funding visibility — What grants exist for my specific sector, region, and maturity level? What are the deadlines?
- Execution guidance — What should I do in the next 2 weeks? 3 months? 6 months?
- Ongoing mentorship — I have follow-up questions, but I can't afford a consultant.
Global Impact AI Navigator addresses every single one of these gaps in a single session lasting under 60 seconds per analysis.
Why Social Impact matters here
The platform explicitly aligns projects with the UN Sustainable Development Goals (SDGs), ensuring that every idea is evaluated not just for feasibility but for real-world impact. Whether it's SDG 2 (Zero Hunger), SDG 6 (Clean Water), or SDG 13 (Climate Action), the navigator connects ideas to the global framework that funders, policymakers, and impact investors all speak.
This is not a generic business advisor. It is a purposeful tool designed for the people who need guidance the most and can afford it the least.
How I Built This
Architecture Overview
The platform is a multi-agent application orchestrated as a phased pipeline using Amazon Bedrock's Converse API, with Firebase Authentication for user management and a Node.js/Express backend:

AWS Services Stack
| Service | Role | Free Tier |
|---|---|---|
| Amazon Bedrock | AI model inference (Converse API) | Nova token allowances |
| Amazon Nova (Micro, Lite, Pro) | Foundation models for all 4 agents | 100M/25M/10M tokens/month |
| Nova Web Grounding | Live internet search via nova_grounding systemTool | Included with Nova Lite |
| Strands Agents SDK | Declarative multi-agent orchestration framework | Open source |
| Amazon Bedrock AgentCore | Managed agent runtime & deployment | Free Tier eligible |
| Kiro | AI-powered IDE for spec-driven architecture | Free |
| AWS Lambda | Serverless compute for API handlers | 1M requests/month free |
| Amazon API Gateway | REST API management, CORS, throttling | 1M calls/month free |
| Amazon DynamoDB | NoSQL storage for projects & sessions | 25 GB + 25 WCU/RCU free |
| Amazon S3 | Static frontend hosting | 5 GB storage free |
The Multi-Agent Pipeline — Strands Agents Deep Dive
The core of the platform is a sequential multi-agent workflow built with the Strands Agents SDK, where each agent is declaratively defined with its model, tools, and system prompt. Each agent's output feeds into the next — this is not a single prompt but a coordinated pipeline managed by Amazon Bedrock AgentCore where context accumulates at every step.
Phase 1: Diagnostic — Runs automatically when the user submits their idea. The user sees results immediately and can review their SWOT before proceeding.
User Decision Point — The user selects their specific needs (financing, mentoring, incubation, networking, training, technical support, market access, legal support) from a multi-select interface. This shapes the entire downstream search and roadmap.
Phase 2: Scout — Searches for funding opportunities tailored to the user's expressed needs using live web grounding. Automatically chains into Phase 3.
Phase 3: Strategist — Generates a personalized roadmap that addresses the user's SWOT findings AND their expressed needs with concrete action steps.
Each agent's output feeds into the next — this is a coordinated pipeline where context accumulates at every step.
Phase 1: Diagnostic — Runs automatically when the user submits their idea. The user sees results immediately and can review their SWOT before proceeding.
User Decision Point — The user selects their specific needs (financing, mentoring, incubation, networking, training, technical support, market access, legal support) from a multi-select interface. This shapes the entire downstream search and roadmap.
Phase 2: Scout — Searches for funding opportunities tailored to the user's expressed needs using live web grounding. Automatically chains into Phase 3.
Phase 3: Strategist — Generates a personalized roadmap that addresses the user's SWOT findings AND their expressed needs with concrete action steps.
Each agent's output feeds into the next — this is a coordinated pipeline where context accumulates at every step.
Agent 1: The Diagnostic Agent (Nova Micro)
Purpose: Classify the idea and perform a full SWOT analysis.
Input: The user's raw idea (free-text or quiz-generated).
Process:
- The agent receives a detailed system prompt instructing it to classify the project by sector (10 categories), region (8 regions), and maturity (4 levels).
- It performs a SWOT analysis: 2–4 items each for Strengths, Weaknesses, Opportunities, and Threats.
- It scores Feasibility (0–100) and Impact (0–100) using a structured scoring rubric.
- It identifies 1–3 relevant UN SDGs.
- It surfaces 2–4 key risks and 2–4 actionable recommendations.
Output: A structured JSON object with 13+ fields.
Why Nova Micro? It is the fastest and cheapest model on Bedrock, ideal for structured classification tasks. Temperature is set to 0.5 for consistent outputs, with 2,500 max tokens.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// Example DiagnosticResult
{
sector: "Agriculture",
region: "Sub-Saharan Africa",
maturity: "Concept",
strengths: ["Addresses real farmer pain points", "SMS accessibility"],
weaknesses: ["No prototype yet", "Unclear monetization"],
opportunities: ["Growing mobile penetration", "Donor interest in agtech"],
threats: ["Existing competitors", "Slow tech adoption in rural areas"],
feasibilityScore: 45,
impactScore: 82,
sdgAlignment: ["SDG 2: Zero Hunger", "SDG 1: No Poverty"],
keyRisks: ["High rural CAC", "Data accuracy"],
recommendations: ["Interview 20+ farmers", "Build SMS prototype"],
summary: "High-impact concept needing validation and differentiation."
}Agent 2: The Scout Agent (Nova 2 Lite + Web Grounding)
Purpose: Find real, current funding opportunities tailored to the user's expressed needs using live web grounding. Automatically chains into 3 Agent.
Input: The full diagnostic context (sector, region, maturity, SWOT, scores, SDGs) plus the user-selected needs array.
Process:
- The agent uses Amazon Nova's 2 native Web Grounding — a built-in
systemToolcallednova_groundingthat enables the model to perform live web searches during inference. - The API call includes
toolConfig: { tools: [{ systemTool: { name: "nova_grounding" } }] }. - Nova searches the internet, synthesizes results, and returns text interleaved with
citationsContentblocks that contain source URLs. - The agent extracts both the JSON output and the citation URLs, then enriches any opportunities that have missing or generic links with fuzzy title matching.
- Every link is verified with an HTTP HEAD request (with GET fallback for 405/403 responses). Broken links are replaced with Google search fallback URLs.
A freshness filter removes opportunities with expired deadlines or stale year references.
6. Graceful fallback: If Web Grounding fails (e.g., missing bedrock:InvokeTool permission), the agent retries without grounding using Nova Lite's training knowledge. If that also fails, it falls back to a Bedrock Agent runtime call.
Output: A JSON array of 5–8
FundingOpportunity objects with real titles, real URLs, real deadlines, and contextual descriptions.This is the key differentiator: Unlike most AI tools that hallucinate funding links, every URL in our output comes from a live web search with actual citations.
1
2
3
4
5
6
7
8
9
10
11
// Web Grounding API usage (simplified)
const command = new ConverseCommand({
modelId: 'us.amazon.nova-lite-v1:0',
messages: [{ role: 'user', content: [{ text: prompt }] }],
toolConfig: {
tools: [{
systemTool: { name: 'nova_grounding' } // Live web search!
}]
},
inferenceConfig: { maxTokens: 4096, temperature: 0.4 }
});This is the key differentiator: Unlike most AI tools that hallucinate funding links, every URL in our output comes from a live web search with actual citations, then verified via HTTP HEAD.
Agent 3: The Strategist Agent (Nova Pro)
Purpose: Generate a personalized, time-boxed action roadmap.
Input: The original idea + full diagnostic (with SWOT) + all discovered funding opportunities + user-selected needs.
Process:
- The agent receives the complete context: the idea text, the full SWOT analysis, and the formatted list of funding opportunities.
The user's expressed needs (financing, mentoring, incubation, etc.) are injected into the prompt, and the agent is instructed to prioritize and specifically address each need with concrete action steps. - It builds a structured roadmap with:
- Immediate Actions (2 weeks) — validation, quick wins
- Short-Term Goals (1–3 months) — momentum, early traction
- Medium-Term Milestones (3–6 months) — scaling, growth
- Recommended Opportunities — top 2–4 from the scout results with reasoning
- Key Success Factors — critical factors and pitfalls to avoid
- The roadmap adapts to the maturity level: Concept-stage projects get validation-heavy plans; Growth-stage projects get scaling strategies.
Output: A rich Markdown-formatted roadmap.
Why Nova Pro? Roadmap generation needs the most capable model for nuanced reasoning, longer output (4,000 max tokens), and creative yet structured writing.
Agent 4: The Chat Agent (Nova Lite)
Purpose: Provide an always-on AI advisor that can answer follow-up questions in the context of the full project analysis.
Input: The full project context (idea, SWOT, opportunities, roadmap) + conversation history.
Process:
- A sliding-window token management system keeps the prompt under 30,000 tokens by trimming older messages while preserving the system context.
- The full SWOT analysis, scores, SDGs, risks, recommendations, opportunities, and roadmap are injected into every chat prompt so the advisor is always contextually aware.
The chat is available as soon as the diagnostic is complete — users don't have to wait for the full pipeline.
Output: Contextual responses that reference specific findings from the analysis.
Why Nova Lite? Provides strong conversational quality with lower latency and cost than Nova Pro, with 2,000 max tokens and temperature 0.5.
Security & Production Readiness
The backend implements multiple layers of security, enforced both at the API Gateway level and within the Lambda handlers:
| Layer | Implementation |
| Authentification | Firebase Authentication with Google OAuth and email/password sign-up. Backend verifies Firebase ID tokens on every API call. Session fallback for migration from anonymous to authenticated sessions. |
| API Gateway | Request throttling, API key management, WAF integration |
| Rate Limiting | 4 tiers of rate limiting (general: 100/15min, analysis: 10/hr, chat: 60/15min, daily interaction: 2/day per user). Supports Redis store for multi-instance deployments. |
| Input Validation | Zod schemas validate all request bodies with min/max length enforcement. HTML tag stripping, XSS prevention (javascript: URI removal, event handler stripping), and string sanitization on all user inputs. |
| HTTP Security | Helmet (CSP, HSTS, X-Frame-Options) + custom headers |
| Security Headers | Helmet with strict CSP, HSTS, X-Frame-Options DENY, no camera/microphone permissions. Additional custom headers for content-type sniffing and referrer policy. |
| CORS | Whitelist-based origin validation (API Gateway + Express) |
| Compression | gzip/brotli for all responses |
| Project Limits | 3 projects max per session (DynamoDB atomic counters) |
| Structured Logging | Request method, path, status, duration per request |
AWS Free Tier Compliance
The platform is designed to run entirely within the AWS Free Tier:
AI Services:
| Model | Agent | Input Tokens | Output Tokens | Free Tier (Monthly) |
|---|---|---|---|---|
| Nova Micro | Diagnostic | ~2,000 | ~800 | 100M input / 25M output |
| Nova Lite | Scout (Web Grounding) | ~2,500 | ~1,500 | 25M input / 25M output |
| Nova Pro | Strategist + Chat | ~3,000 | ~2,000 | 10M input / 10M output |
Infrastructure Services:
| Service | Usage | Free Tier Allowance |
|---|---|---|
| AWS Lambda | ~5 functions, <300s/invocation | 1M requests + 400K GB-s/month |
| Amazon API Gateway | REST API, ~5 routes | 1M API calls/month |
| Amazon DynamoDB | 2 tables (projects + sessions) | 25 GB storage + 25 WCU/RCU |
| Amazon S3 | Frontend static hosting | 5 GB storage + 20K GET requests |
With the 3-project limit per session, a typical usage generates ~25,000 tokens total per full analysis — well within free tier bounds. The serverless architecture (Lambda + API Gateway) means zero cost when idle.
Frontend Features
- React 19 with lazy-loaded code-split routes (30+ pages accross projects)
- Tailwind CSS v4 with dark mode and glass morphism effects
- Framer Motion animations for page transitions and UI elements
- shadcn/ui component library for consistent, accessible UI
- Interactive SWOT Dashboard — color-coded 4-quadrant grid (Strengths in green, Weaknesses in amber, Opportunities in blue, Threats in red)
- Score Bars — animated progress bars with color coding (green ≥70, amber ≥40, red <40)
- SDG Badges — visual tags for each aligned Sustainable Development Goal
- Responsive Design — fully adaptive from 320px mobile to 4K desktop
- Progressive Loading — real-time status updates as each agent completes
Development with Kiro
Kiro was instrumental in accelerating development from initial concept to a fully working multi-agent platform.
Spec-Driven Architecture. I described the Global Impact AI Navigator's requirements in natural language — the multi-agent pipeline, the SWOT diagnostic data model, the Web Grounding integration flow, the session-based project management, the security middleware stack — and Kiro generated structured specs (
requirements.md, design.md, tasks.md) that decomposed the system into discrete, sequenced implementation tasks. This spec-driven workflow forced me to think through the entire agent orchestration before writing a single API handler or prompt file.Scaffolding at Scale. The project spans 4 AI agents, 15 frontend pages (lazy-loaded), 10+ REST API endpoints, a middleware stack (Helmet, rate limiters, Zod validators), a file-system storage layer, and a workflow orchestrator. Kiro scaffolded the foundational patterns — the Express server structure, the agent handler signatures, the TypeScript types shared between frontend and backend, the Zod validation schemas, and the project context provider — so I could focus on the hard domain-specific problems: crafting the SWOT diagnostic prompt with its scoring rubric, integrating Nova Web Grounding's
systemTool API, building the citation extraction pipeline, and designing the token management system for the chat agent.Iterative Refinement. As the project evolved — expanding the diagnostic from 3 fields to 13+ SWOT fields, replacing fake web search loops with real Web Grounding, adding the guided quiz flow — Kiro helped me rapidly propagate changes across the entire codebase: updating shared types in both backend and frontend, rewriting test suites to match new agent behaviors, and keeping prompt files synchronized with their corresponding agent implementations.
Key Development Milestones
- Spec & architecture with Kiro — Natural language requirements → structured specs → task breakdown
- Project foundation — Express 5 + React 19 + TypeScript monorepo with shared types
- Multi-agent orchestration — Sequential pipeline with error propagation and fallback paths
- SWOT diagnostic overhaul — Expanded from 3 fields to 13+ fields with scoring rubric
- Web Grounding integration — Native
nova_groundingsystemTool replacing fake search loops - Chat agent with token management — Sliding-window context with SWOT injection
- Security hardening — Rate limiting, Zod validation, Helmet, CORS, input sanitization
- Free Tier guardrails — 3-project limit, session management, optimized token usage
- Assessment quiz — 5-question guided flow that auto-creates projects and launches analysis
Demo
What I Learned
1. Multi-agent orchestration is about context propagation, not just chaining
The single biggest insight was that the value of a multi-agent pipeline comes not from running multiple models, but from how you propagate context between them. The diagnostic output isn't just "consumed" by the scout — it fundamentally reshapes what the scout searches for. The user's expressed needs don't just "filter" opportunities — they shape the entire search strategy and roadmap structure.
Every agent receives a progressively richer context: the scout sees the diagnostic's SWOT plus the user's needs; the strategist sees both plus the opportunities; the chat agent sees everything. This accumulation is what makes the output feel coherent rather than disjointed.
Every agent receives a progressively richer context: the scout sees the diagnostic's SWOT plus the user's needs; the strategist sees both plus the opportunities; the chat agent sees everything. This accumulation is what makes the output feel coherent rather than disjointed.
2. Web Grounding changes everything for trust
Before integrating Nova 2 Lite's native Web Grounding (nova_grounding systemTool), the Scout agent was returning plausible-sounding but ultimately fabricated funding opportunities. This is the number one credibility killer for any AI-powered advisory tool.
With Web Grounding, the model performs real web searches during inference and returns citations with actual URLs. The response contains interleaved text and citationsContent blocks, which we parse to extract genuine links. We then verify every link with an HTTP HEAD request — broken links are replaced with Google search fallback URLs. The difference is night and day — users get clickable links to real programs.
Key technical learning: Web Grounding requires
With Web Grounding, the model performs real web searches during inference and returns citations with actual URLs. The response contains interleaved text and citationsContent blocks, which we parse to extract genuine links. We then verify every link with an HTTP HEAD request — broken links are replaced with Google search fallback URLs. The difference is night and day — users get clickable links to real programs.
Key technical learning: Web Grounding requires
us.amazon.nova-2-lite-v1:0 (Nova 2 Lite), not the original Nova Lite model. It is a systemTool, not a toolSpec. The API pattern is::1
2
3
4
5
{
"toolConfig": {
"tools": [{ "systemTool": { "name": "nova_grounding" } }]
}
}3. Kiro's spec-driven approach changes how you build AI systems
Using Kiro to generate structured specs before coding was a game-changer for a multi-agent system. When you describe "a diagnostic agent that performs SWOT analysis with feasibility scoring" in natural language, Kiro breaks it into concrete tasks: define the type interface, write the prompt file, implement the parser, add validation, write tests. This forced rigor prevented the kind of architectural drift that plagues AI projects where "just one more prompt tweak" cascades into inconsistencies across agents.
4. Prompt engineering is architecture, not copywriting
Each of our four agents has a dedicated prompt file (Markdown) that functions as a detailed engineering specification. The diagnostic prompt includes a scoring rubric table, the scout prompt includes search strategy guidelines and factual description requirements, and the strategist prompt includes maturity-adapted guidelines with needs-specific action steps.
Treating prompts as versioned, testable artifacts — loaded from disk, cached in memory, and validated at startup — was far more maintainable than embedding instructions in code.
Treating prompts as versioned, testable artifacts — loaded from disk, cached in memory, and validated at startup — was far more maintainable than embedding instructions in code.
5. Graceful degradation is essential for production AI
Every agent has a fallback path:
- Scout Agent: Web Grounding → knowledge-only fallback → Bedrock Agent fallback
- All agents: robust JSON parsing that handles
\<thinking\>tags, markdown code blocks, and extra text around the JSON - Frontend: progressive loading with real-time status, error boundaries, and retry options
- Link verification: HTTP HEAD -> GET retry (for 405/403) -> Google search fallback for broken links
AI model outputs are inherently unpredictable. Building defensive parsing (regex extraction, field validation, sensible defaults) was the difference between a demo that works sometimes and a platform that works reliably.
6. Free Tier design is a feature, not a constraint
Designing for the AWS Free Tier forced us to make smart architectural decisions:
- Use Nova Micro (cheapest) for structured classification, Nova Lite for search, Nova Pro (most capable) only for creative generation
- Limit projects to 3 per session to prevent runaway costs
- Keep token budgets tight (2,500 → 4,096 range) with temperature tuning
- Cache prompts in memory to avoid repeated disk reads
- Daily interaction limit of 2 per user for sustainable usage
These constraints resulted in a more efficient, better-designed system than an unconstrained budget would have produced.
7. SWOT analysis is the strategic backbone
Expanding the diagnostic from a simple 3-field classification (sector, region, maturity) to a full 13-field SWOT analysis was the single highest-impact change. It transformed the entire downstream pipeline:
- The scout became more targeted (searching for programs that match strengths and address weaknesses)
- The strategist became more actionable (building on strengths, mitigating threats)
- The chat agent became more contextually aware (answering questions with full SWOT context)
- User agency improves output quality
The decision to make the workflow user-guided — with a pause between diagnostic and opportunity search where users select their specific needs — was a critical design choice. Instead of guessing what the user wants, we ask. The needs selection (financing, mentoring, incubation, networking, training, technical support, market access, legal support) directly shapes:
What the Scout searches for on the web
How the Strategist prioritizes roadmap actions
What kind of opportunities are surfaced first
This simple interaction point dramatically improves relevance. A user who needs mentoring gets mentoring programs, not just grants. A user who needs legal support gets regulatory guidance programs, not just accelerators.
Diagrams & Visual Assets
Diagram 1: Multi-Agent Pipeline Flow

Diagram 2: Web Grounding Data Flow

Diagram 3: SWOT Analysis Output

Diagram 4: Full System Architecture

Diagram 5: User Journey

Built with Amazon Bedrock, Amazon Nova (Micro, Lite, Pro), Nova Web Grounding, React 19, Express 5, TypeScript, and a belief that the next world-changing idea might be sitting in someone's notebook right now — waiting for the right guidance to become real.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article