AWS Builder Center
Full Stack Challenge: Ember

Full Stack Challenge: Ember

Transform complex decisions into clear recommendations using AWS. This 48-hour full-stack application demonstrates Cognito, Lambda, DynamoDB, and Bedrock in a production-ready decision analysis system.

Executive Summary

Ember is a full-stack web application that transforms complex, uncertain decisions into clear, evidence-backed recommendations using AWS services and Amazon Bedrock's AI capabilities. Built in 48 hours, Ember demonstrates production-quality architecture combining real authentication, persistent data storage, AI-driven analysis, and a distinctive furnace-inspired user experience.
The application showcases how modern AWS services—Cognito for authentication, DynamoDB for data persistence, Lambda for computation, and Bedrock for AI—can be orchestrated into a cohesive system that delivers genuine value to users navigating difficult decisions.



The Problem: Decision-Making Under Uncertainty

Every day, teams face important decisions with incomplete information:
  • Should we migrate our database?
  • Should we launch the new product this quarter?
  • Should we build or buy this solution?
  • Should we hire or outsource this function?
These decisions are difficult because our thinking is often clouded by:
  • Unconscious assumptions we don't realize we're making
  • Overlooked evidence that contradicts our preferences
  • Cognitive biases that pull us toward familiar options
  • Unknown unknowns we haven't considered
Traditional approaches fail to address these challenges:
  • Ad-hoc discussion: Unstructured, biased, loses context
  • Spreadsheets: Tedious, error-prone, lacks reasoning
  • ChatGPT prompts: Helpful but scattered and informal
Ember solves this by providing a structured, AI-guided decision analysis system that forces clarity at every step.



The Solution: A Decision Furnace

Ember guides every decision through a systematic seven-stage "furnace" process—a metaphor where raw decisions enter, heat (focus) is applied, and refined recommendations emerge.
RAW DECISION
↓
🔥 CONTEXT (extract problem, goals, constraints)
↓
🔥 ASSUMPTIONS (surface what we're assuming)
↓
🔥 EVIDENCE (gather supporting data)
↓
🔥 OPTIONS (generate alternatives)
↓
🔥 RISKS (identify threats and mitigations)
↓
🔥 TRADE-OFFS (compare options systematically)
↓
⚒ FORGED RESULT (clear recommendation with confidence)
Each stage extracts, validates, and refines the decision, producing a final report that clearly distinguishes facts from assumptions, evidence from inference, and recommendations from speculation.



How We Built It

Why This Problem?

We chose decision-making because:
  1. Universal relevance: Every engineer, product manager, and entrepreneur faces difficult decisions
  1. AI adds real value: LLMs excel at structured analysis when prompted correctly
  1. Full-stack showcase: The problem domain requires frontend UI, backend APIs, AI integration, and data persistence
  1. Visual metaphor: The "furnace" is distinctive, professional, and conceptually coherent

Development Phases

Phase 1: Foundation (Hours 1-6)
  • React + Vite frontend scaffold
  • Express + TypeScript backend
  • Cognito authentication configuration
  • DynamoDB schema design
  • CloudFormation infrastructure template
Phase 2: Core Workflow (Hours 7-18)
  • Seven-stage furnace UI component
  • Decision creation form
  • Dashboard with stats
  • Decision report view
  • History with filtering
Phase 3: AI Integration (Hours 19-30)
  • Bedrock API integration
  • Structured JSON schema validation
  • Context analysis endpoint
  • Assumptions extraction endpoint
  • Options, risks, tradeoffs, and verdict endpoints
Phase 4: UX Polish (Hours 31-40)
  • Dark/light mode toggle
  • Heat animations and glow effects
  • Responsive mobile design
  • Error handling and loading states
  • Furnace stage visualizations
Phase 5: Documentation & Deployment (Hours 41-48)
  • Comprehensive README
  • API reference documentation
  • Deployment guide
  • Quick start guide
  • This article



Architecture & Technology

Full-Stack Breakdown

Frontend
  • React 18 + TypeScript for type-safe components
  • Vite for instant HMR and rapid builds
  • Tailwind CSS with custom furnace-inspired colors
  • AWS Amplify for Cognito integration
  • React Router for navigation
Backend
  • Express.js with TypeScript
  • AWS SDK v3 for service integration
  • Bedrock for Claude 3 Sonnet AI
  • DynamoDB for persistent storage
  • Lambda-ready architecture
Infrastructure
  • CloudFormation for reproducible infrastructure
  • DynamoDB on-demand pricing (cost-effective)
  • Lambda with 13 REST endpoints
  • API Gateway for request routing
  • Cognito for user authentication
  • CloudWatch for logging and monitoring

Key Design Decisions

1. Structured AI Output We never accept free-form text from Bedrock. Every response is validated against a strict JSON schema. This prevents hallucinations and garbage-in scenarios while ensuring consistent, parseable data.
2. User Data Isolation User ID is the partition key in DynamoDB. This prevents a user from accessing another user's decisions even if they change IDs in requests. Authorization is enforced at the database layer, not just the API.
3. Stateless Services Lambda functions are stateless and pure. This enables automatic scaling and makes debugging trivial—no hidden state, no race conditions.
4. Real Data Over Fakes Every interaction is real: real authentication, real database writes, real AI analysis. We resisted the temptation to mock or hardcode data, which would have accelerated development but sacrificed integrity.
5. TypeScript Everywhere 100% TypeScript coverage on frontend and backend. Shared type definitions between layers prevent API contract drift. Type safety caught multiple bugs at compile time.



AWS Services in Action

Amazon Cognito

Role: User authentication and session management Why it works: Handles sign-up, sign-in, password recovery, and MFA without custom code. JWT tokens are validated on every protected endpoint.

Amazon DynamoDB

Role: Persistent decision and analysis storage Why it works: Schemaless design fits evolving analysis data. On-demand billing means we pay only for what we use. Point-in-time recovery protects data.

AWS Lambda

Role: Serverless API logic and AI orchestration Why it works: No server management. Automatic scaling. 13 independent functions for different operations. Pay-per-request pricing aligns cost with usage.

API Gateway

Role: REST endpoint management and routing Why it works: Automatic CORS handling. Request throttling and authorization. CloudWatch integration for monitoring.

Amazon Bedrock

Role: Structured AI analysis via Claude 3 Sonnet Why it works: No model management overhead. Managed inference. Fine-grained IAM control. Reliable for structured tasks.

AWS Amplify

Role: Frontend hosting and deployment Why it works: Git-based CI/CD. Automatic HTTPS. Global CDN. Environment-based configuration.

CloudWatch

Role: Logging and monitoring Why it works: All Lambda logs centralized. Real-time debugging. Alarms trigger on errors or anomalies.



Challenges & Solutions

Challenge 1: Bedrock Output Quality

Problem: LLMs hallucinate. JSON schemas help, but validation is critical.
Solution: Every Bedrock response is validated against a strict JSON schema before storage. If validation fails, we return an error and let the user retry rather than storing corrupted data.

Challenge 2: User Data Isolation

Problem: A single authorization bug could expose User A's decisions to User B.
Solution: User ID is embedded in the DynamoDB partition key. Queries cannot accidentally cross user boundaries. Middleware ensures authenticated user context on every request.

Challenge 3: Responsive Furnace UI

Problem: The seven-stage furnace needs to work on phones, tablets, and desktops.
Solution: Sidebar collapses to a modal on mobile. Stage content uses flexible layouts. Tables become scrollable cards. Tested on Chrome, Safari, Firefox.

Challenge 4: Consistent AI Output

Problem: LLM outputs are unpredictable across calls.
Solution: Prompt engineering with specific JSON schemas. Temperature set to 0 for determinism. Schema validation before storage. Clear error messages if output is malformed.



What We Learned

1. AWS Services Scale Naturally

When architected thoughtfully, AWS services scale seamlessly together. DynamoDB's on-demand pricing pairs perfectly with Lambda's per-invocation model. Amplify's Git-based deployment integrates cleanly with Lambda functions.

2. Type Safety Is Force Multiplier

TypeScript prevented bugs before they became runtime errors. Shared types between frontend and backend prevented API mismatches. Initial setup investment paid dividends immediately.

3. Structured Prompts Reduce Hallucinations

Asking Bedrock for structured JSON with explicit schemas produces more reliable output than prose. Validation after generation catches problems early.

4. Dark Mode Should Be Default

The furnace metaphor works best with dark colors and glow effects. Implementing dark mode from the start is easier than retrofitting. Users appreciate it from day one.

5. Real Data Beats Fake Data

Mocking data would have accelerated early development but would have introduced subtle bugs later. Connecting to real AWS services from day one added complexity upfront but eliminated debugging during integration.



Performance & Metrics

Metric
Result
Landing page load
< 2 seconds
Sign-in flow
< 1 second
Decision creation
< 500ms
Single AI analysis stage
3-10 seconds
Report generation
< 2 seconds
Dashboard load
< 1 second
Monthly DynamoDB cost
< $10 (on-demand)



Future Roadmap

Phase 2: Collaboration

  • Team invitations and shared decisions
  • Evidence import from URLs
  • PDF report generation
  • Email notifications

Phase 3: Advanced Features

  • Mobile app (React Native)
  • Multi-region deployment
  • Decision outcome tracking
  • Slack/Teams/Jira integrations
  • Industry-specific templates

Phase 4: Enterprise

  • Real-time collaborative analysis
  • Historical decision learning
  • Predictive models for decision outcomes
  • Custom model fine-tuning
  • Enterprise SSO and RBAC



Key Takeaways

For Full-Stack Developers

  • AWS services integrate seamlessly when architecture is thoughtful
  • Type safety matters: TypeScript catches bugs at compile time
  • User data isolation must be enforced at the database layer
  • Structured AI output is more reliable than free-form text

For AI/ML Engineers

  • Structured prompts reduce hallucinations: JSON schemas force clarity
  • Validation is essential: Never trust AI output without checking
  • Temperature matters: Set to 0 for deterministic output
  • Real data is irreplaceable: Test with actual user scenarios

For Product Managers

  • Ruthless prioritization wins: Focus on core value, defer nice-to-haves
  • Real authentication matters: Users trust systems with real login flows
  • Transparent reasoning builds confidence: Show the decision process
  • Dark mode is table stakes: Users expect it from day one



The Furnace Metaphor

Why does the furnace metaphor work?
Decisions really do need heat—sustained focus, structured analysis, systematic evaluation. Raw decisions enter the furnace as messy questions. Through seven stages of analysis, they're refined into clear recommendations. The heat (focus) is what makes the transformation possible.
Ember doesn't make decisions for you. It makes your reasoning visible, your assumptions explicit, and your evidence clear. It's a tool for thinking better.



Conclusion

Ember proves that in 48 hours, a small team can build a professional, production-quality full-stack AWS application that solves a real problem. The key is ruthless prioritization, leveraging managed services to eliminate toil, and keeping architecture simple.
Every team makes difficult decisions. Ember makes those decisions clearer, faster, and more confident.
Challenge word: FURNACE ✅
Technologies: React, TypeScript, Express, AWS Lambda, DynamoDB, Amazon Bedrock, Cognito, Amplify, CloudFormation


Ready to build? Start with the  GitHub repository  and follow the QUICKSTART.md guide to run Ember locally.
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