I'm starting a new project with these requirements:
- [List your requirements]
- [Performance needs]
- [Team size and expertise]
- [Timeline constraints]
- [Budget considerations]

What technology stack would you recommend?

Compare React, Vue, and Angular for:
1. Learning curve
2. Performance characteristics
3. Ecosystem maturity
4. Community support
5. Long-term maintenance

Analyze Node.js vs Python vs Go for:
- API development
- Microservices architecture
- Performance requirements
- Team expertise
- Deployment complexity

Design a React-based stack for:
- State management (Redux, Zustand, Context)
- Routing (React Router, Next.js)
- Styling (CSS-in-JS, Tailwind, Styled Components)
- Build tools (Vite, Webpack, Parcel)
- Testing (Jest, React Testing Library, Cypress)

Recommend Vue.js stack including:
- Vue 3 Composition API vs Options API
- State management (Pinia, Vuex)
- UI frameworks (Vuetify, Quasar, Element Plus)
- Build tools (Vite, Vue CLI)
- TypeScript integration

Plan Angular application with:
- Angular version selection
- State management (NgRx, Akita)
- UI components (Angular Material, PrimeNG)
- Testing strategies (Jasmine, Karma, Protractor)
- Build optimization

Optimize frontend performance with:
1. Bundle splitting strategies
2. Lazy loading implementation
3. Image optimization techniques
4. Caching strategies
5. CDN integration

Implement PWA features:
- Service worker strategies
- Offline functionality
- Push notifications
- App shell architecture
- Performance budgets

Design micro-frontend architecture:
- Module federation setup
- Shared dependencies
- Communication patterns
- Deployment strategies
- Team boundaries

Build Node.js backend with:
- Framework choice (Express, Fastify, Koa, NestJS)
- TypeScript integration
- Database ORM (Prisma, TypeORM, Sequelize)
- Authentication strategies
- API documentation (Swagger, GraphQL)

Develop Python backend using:
- Framework selection (Django, FastAPI, Flask)
- Async vs sync considerations
- Database integration (SQLAlchemy, Django ORM)
- API frameworks (DRF, FastAPI, GraphQL)
- Deployment options (WSGI, ASGI)

Implement Go backend with:
- Web framework (Gin, Echo, Fiber, Chi)
- Database drivers and ORMs
- Concurrency patterns
- Microservices architecture
- Performance optimization

Choose database technology based on:
1. Data structure and relationships
2. Scalability requirements
3. Consistency needs
4. Query complexity
5. Team expertise

Compare SQL databases:
- PostgreSQL: Advanced features, JSON support
- MySQL: Performance, widespread adoption
- SQLite: Simplicity, embedded use cases
- SQL Server: Enterprise features, .NET integration

Evaluate NoSQL solutions:
- MongoDB: Document flexibility
- Redis: Caching and real-time features
- Cassandra: High availability and scalability
- DynamoDB: Serverless and managed

Design containerization approach:
1. Multi-stage build optimization
2. Security best practices
3. Image size optimization
4. Development vs production configs
5. Health check implementation

Plan Kubernetes deployment:
- Cluster architecture
- Service mesh integration
- Monitoring and logging
- Auto-scaling strategies
- Security policies

Leverage AWS services:
- Compute: EC2, Lambda, ECS, EKS
- Storage: S3, EBS, EFS
- Database: RDS, DynamoDB, ElastiCache
- Networking: VPC, CloudFront, Route 53
- Monitoring: CloudWatch, X-Ray

Utilize Azure services:
- App Service, Functions, AKS
- Cosmos DB, SQL Database
- Storage Account, CDN
- Application Insights
- DevOps integration

Implement GCP solutions:
- Compute Engine, Cloud Functions, GKE
- Firestore, Cloud SQL, BigQuery
- Cloud Storage, Cloud CDN
- Stackdriver monitoring
- Firebase integration

Select build tooling:
- Vite: Fast development and building
- Webpack: Mature and configurable
- Rollup: Library bundling
- esbuild: Ultra-fast compilation
- SWC: Rust-based compilation

Choose package manager:
- npm: Default Node.js package manager
- Yarn: Fast and reliable
- pnpm: Efficient disk space usage
- Rush: Monorepo management

Implement comprehensive testing:
1. Unit testing frameworks
2. Integration testing approaches
3. End-to-end testing tools
4. Performance testing
5. Security testing

Enforce code quality with:
- ESLint/TSLint: Code linting
- Prettier: Code formatting
- Husky: Git hooks
- SonarQube: Code analysis
- CodeClimate: Maintainability

Integrate AI capabilities:
1. Natural language processing
2. Computer vision
3. Recommendation systems
4. Predictive analytics
5. Automated testing

Choose ML frameworks:
- TensorFlow.js: Browser-based ML
- PyTorch: Research and production
- Scikit-learn: Traditional ML
- Hugging Face: NLP models
- OpenAI API: GPT integration

Implement edge computing:
- CDN edge functions
- IoT device deployment
- Mobile edge computing
- Real-time processing
- Latency optimization

Explore Web3 technologies:
- Smart contract development
- DeFi protocol integration
- NFT marketplace features
- Wallet connectivity
- Decentralized storage

Create technology decision matrix:

Criteria | Weight | Option A | Option B | Option C
---------|--------|----------|----------|----------
Performance | 25% | 8 | 7 | 9
Security | 20% | 9 | 8 | 7
Ecosystem | 20% | 9 | 6 | 8
Cost | 15% | 6 | 9 | 7
Team Fit | 20% | 7 | 9 | 6
---------|--------|----------|----------|----------
Total | 100% | 7.8 | 7.8 | 7.6

Plan incremental modernization:
1. Strangler Fig pattern
2. API-first approach
3. Database migration strategies
4. Feature flag implementation
5. Rollback procedures

Address technical debt:
- Dependency updates
- Security patches
- Performance improvements
- Code refactoring
- Architecture evolution

Validate technology choices:
1. Build minimal viable prototypes
2. Performance benchmarking
3. Security assessment
4. Team feedback collection
5. Stakeholder review

Prepare contingency plans:
- Alternative technology options
- Migration rollback procedures
- Data backup strategies
- Team training alternatives
- Timeline adjustments

Regularly assess technology choices:
1. Performance monitoring
2. Security vulnerability tracking
3. Community health evaluation
4. Cost analysis updates
5. Team satisfaction surveys

Maintain technology documentation:
- Decision rationale records
- Architecture decision records (ADRs)
- Technology comparison matrices
- Migration guides
- Best practices documentation