Build a complete, production-ready MVP web application from scratch, delivering all source files, configuration, and deployment instructions as a cohesive, working project.

BUILD METHODOLOGY:

1. Architecture Planning
   - Analyze the app idea and define the core data model (entities, relationships, key attributes)
   - Design the application architecture: which components handle which responsibilities
   - Define the API contract between frontend and backend (endpoints, payloads)
   - Identify third-party services or libraries needed and justify each choice
   - Plan the file/folder structure following conventions for the chosen stack

2. Backend Development (if applicable)
   - Set up the project scaffolding: package manager config, entry point, environment variables
   - Implement the data layer: database schema/models, migrations, seed data
   - Build API routes/controllers with input validation and error handling
   - Implement authentication and authorization if required by the features
   - Add middleware: CORS, rate limiting, logging, error handling
   - Write key utility functions and shared modules

3. Frontend Development
   - Set up the project with proper build tooling and configuration
   - Build the component hierarchy: layout, pages, reusable UI components
   - Implement routing and navigation
   - Connect to the backend API with proper error handling and loading states
   - Add form validation and user feedback (toasts, error messages)
   - Implement responsive design for mobile and desktop
   - Ensure basic accessibility (semantic HTML, ARIA labels, keyboard navigation)

4. Integration and Configuration
   - Create all environment variable templates (.env.example) with documentation
   - Configure development and production build modes
   - Set up database connection pooling and configuration
   - Add health check endpoints
   - Write a complete package.json (or equivalent) with all scripts: dev, build, start, test, lint

5. Deployment Preparation
   - Provide a step-by-step setup guide: clone, install, configure, run
   - Include Docker configuration if appropriate for the stack
   - Document the deployment process for at least one platform (Vercel, Railway, Fly.io, AWS, etc.)
   - List environment variables needed in production with descriptions
   - Note security considerations for production (HTTPS, secrets management, CORS policy)

OUTPUT CONSTRAINTS:
- Every file must be complete and functional; no placeholder comments like "// TODO: implement this"
- Include meaningful code comments that explain WHY, not WHAT (the code shows what)
- Use current, stable versions of all dependencies
- Follow the official style guide and conventions for each technology in the stack
- Handle errors gracefully throughout; never let the app crash on bad input
- If a requested feature is too complex for an MVP, say so and propose a simpler version with a note on how to extend it later
- Deliver files in a clear order: project config first, then backend, then frontend, then deployment docs

FORMAT:
## Architecture Overview
[Data model, component diagram, API endpoints summary]

## File Structure
```
[tree view of all files]
```

## Files
[Each file with its full path as a header, complete contents in a code block, and a brief explanation of its role]

## Setup Instructions
[Step-by-step from git clone to running app]

## Deployment Guide
[Platform-specific deployment steps]

## Future Enhancements
[What to build next beyond the MVP]

---

MY INFO:

App Idea (describe what it does): (required)

Tech Stack Preferences: (required)
- Frontend (React/Vue/Next.js/Svelte/vanilla JS):
- Backend (Node.js/Express/Python-FastAPI/Go/none):
- Database (PostgreSQL/MongoDB/SQLite/Firebase/Supabase):
- Styling (Tailwind CSS/plain CSS/Bootstrap/shadcn):

Core Features Needed: (required)
1.
2.
3.

Authentication Required (yes/no): (optional)

Target Deployment Platform: (optional)

Any Design Preferences or Constraints: (optional)