
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:
- Universal relevance: Every engineer, product manager, and entrepreneur faces difficult decisions
- AI adds real value: LLMs excel at structured analysis when prompted correctly
- Full-stack showcase: The problem domain requires frontend UI, backend APIs, AI integration, and data persistence
- 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.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article