CRITICAL: Dolibarr integration is VITAL, Accessibility required

🚨 CRITICAL FIXES:
- Dolibarr prospect creation is VITAL and non-negotiable in MVP
- Email validation → Dolibarr prospect creation flow is critical
- Accessibility compliance (WCAG 2.1 AA) is required for launch
- Internationalization can be pushed (English only at launch)

⚡ UPDATED 90-MINUTE MVP:
✅ Email capture and verification
✅ Dolibarr prospect creation (VITAL - non-negotiable)
✅ Domain availability checking
✅ Stripe payment form
✅ Manual backend processes

🔧 DOLIBARR INTEGRATION FLOW:
1. Email verification successful
2. Create Dolibarr prospect via API
3. Store prospect ID locally
4. Update prospect status throughout journey
5. Convert to customer on payment success

♿ ACCESSIBILITY REQUIREMENTS:
- WCAG 2.1 AA compliance (required for launch)
- Semantic HTML, keyboard navigation
- Screen reader support, color contrast
- Form accessibility, error handling
- English only (internationalization deferred)

🎯 SUCCESS CRITERIA:
- MVP: Working payment flow + Dolibarr prospects
- Complete: Full automation + accessibility compliance

Dolibarr integration is now properly prioritized as VITAL!

output/plan.md

@@ -2,20 +2,26 @@
 
 ## Executive Summary
 
-**✅ REVISED PLAN: 12-HOUR IMPLEMENTATION THAT WILL WORK**
+**🎯 REALISTIC PLAN: 90-MINUTE MVP, 12-36 HOUR CODE COMPLETE**
 
-**Goal**: Launch production-ready SaaS business that automates Cloudron infrastructure provisioning
+**Goal**: Create MVP that demonstrates core business concept with manual backend processes
 **Value Proposition**: Complete sovereign hosting stack for $250/month - domain, VPS, Cloudron, DNS all included
-**Timeline**: 12 hours (AI-optimized with parallel development)
-**Scope**: EXACTLY what's defined in PRD - no more, no less
+**Timeline**: 90-minute MVP → 12-36 hours code complete (NO production deployment)
+**Scope**: MVP demonstrates customer journey, backend processes manual initially
 
-**Why This Will Work:**
-- Pre-built Docker containers eliminate setup time
-- Official Go SDKs handle API complexity
-- Parallel development maximizes efficiency
-- AI-generated code accelerates development
-- Focused testing on critical path only
-- Production-ready security built-in
+**🚨 90-MINUTE MVP REALITY:**
+- Basic Go application with hardcoded logic
+- Stripe payment integration
+- Domain availability checking
+- Email capture and verification
+- Manual backend processes (no automation initially)
+
+**⚡ 12-36 HOUR CODE COMPLETE:**
+- Full automation of all manual processes
+- Complete OVH, Cloudron, Dolibarr integration
+- Worker queue system
+- Error handling and rollback
+- Comprehensive testing
 
 ## 🚀 AI-OPTIMIZED 12-HOUR PLAN - MAXIMUM OFF-THE-SHELF
 
@@ -175,7 +181,7 @@ func TestPaymentProcessing(t *testing.T) {
 
 **AI ADVANTAGE: What takes humans 40 hours, I do in 12!** 🚀
 
-## Business Model - PRD Exact Scope
+## Business Model - PRD Exact Scope (MVP → Full Automation)
 
 ### Customer Value Proposition
 Get your complete sovereign hosting stack with just:
@@ -192,22 +198,58 @@ You receive:
 
 **Cost**: $250.00 USD per month per domain
 
-### Technology Stack - Minimal & Focused
-- **Backend**: Go (100% Go - no Node.js/Python)
-- **Frontend**: Go templates + HTMX (beautiful but simple)
-- **Database**: PostgreSQL (minimal schema)
+### Technology Stack - MVP → Evolution
+
+#### **90-Minute MVP Stack:**
+- **Backend**: Go (single main.go file)
+- **Frontend**: Basic HTML + Bootstrap
+- **Database**: SQLite (single file)
+- **Payments**: Stripe Elements
+- **Back-office**: Dolibarr API integration (VITAL)
+- **Infrastructure**: Manual OVH dashboard operations
+- **Email**: Basic SMTP or Mailgun
+- **Authentication**: Simple JWT
+
+#### **12-36 Hour Complete Stack:**
+- **Backend**: Go (modular architecture)
+- **Frontend**: Go templates + HTMX
+- **Database**: PostgreSQL + Redis
 - **Cache**: Redis (sessions + worker queue)
 - **Back-office**: Dolibarr (all business functionality)
-- **Payments**: Stripe (subscriptions)
-- **Infrastructure**: OVH (domains/VPS)
-- **Platform**: Cloudron (hosting)
+- **Payments**: Stripe (subscriptions + webhooks)
+- **Infrastructure**: OVH (automated API calls)
+- **Platform**: Cloudron (automated installation)
 - **Worker Queue**: Redis-based async processing
-- **Deployment**: Single Ubuntu 24.04 VPS
-- **Development**: 100% Docker containers (zero host pollution)
+- **Development**: 100% Go (no human delays)
 
-## Phase 1: Foundation Setup (Hours 1-2)
+## Phase 1: 90-Minute MVP Structure
 
-### 1.1 AI-Optimized Project Structure
+### 1.1 MVP Project Structure (Single File Focus)
+```
+output/
+├── main.go                           # Everything in one file
+├── index.html                        # Landing page
+├── style.css                         # Basic styling
+├── database.db                       # SQLite database
+├── .env                              # Environment variables
+└── README.md                         # Manual process documentation
+```
+
+### 1.2 MVP Technology Stack
+```yaml
+# Minimal components for 90-minute delivery
+- Go 1.21 (standard library + HTTP client)
+- SQLite (embedded database)
+- Stripe Elements (payment form)
+- Bootstrap 5 (styling)
+- Dolibarr API (prospect creation - VITAL)
+- OVH API (domain checking only)
+- SMTP/Mailgun (email verification)
+```
+
+## Phase 2: 12-36 Hour Complete Structure
+
+### 2.1 Full Project Structure
 ```
 output/
 ├── cmd/
@@ -239,56 +281,64 @@ output/
 ├── web/
 │   ├── static/                       # CSS, JS, images
 │   └── templates/                    # HTML templates
-├── mocks/
-│   ├── ovh/                          # OVH API mock
-│   ├── stripe/                       # Stripe API mock
-│   ├── cloudron/                     # Cloudron API mock
-│   └── dolibarr/                     # Dolibarr API mock
-├── scripts/
-│   ├── deploy.sh                     # Production deployment
-│   └── test.sh                      # Test runner
-├── deployments/
-│   ├── docker-compose.yml            # Development
-│   ├── docker-compose.test.yml       # Testing
-│   └── docker-compose.prod.yml       # Production
 ├── tests/
 │   ├── unit/                         # Unit tests
 │   ├── integration/                  # Integration tests
 │   └── e2e/                         # End-to-end tests
-├── Dockerfile
-├── Dockerfile.worker
 ├── go.mod
 ├── go.sum
 └── README.md
 ```
 
-### 1.2 Pre-Built Docker Environment
+### 2.2 Complete Technology Stack
 ```yaml
-# Pre-configured containers for rapid development
-- ydn-dev-go: Go 1.21 with all dependencies pre-installed
-- ydn-dev-postgres: PostgreSQL 15 with schema pre-loaded
-- ydn-dev-redis: Redis 7 with queue system configured
-- ydn-dev-dolibarr: Dolibarr with API pre-configured
-- ydn-mock-ovh: Complete OVH API mock with realistic responses
-- ydn-mock-stripe: Full Stripe mock with webhook support
-- ydn-mock-cloudron: Cloudron installation mock with status tracking
-- ydn-mock-dolibarr: Dolibarr API mock with all endpoints
-- ydn-test-runner: Pre-configured test environment with coverage tools
+# Full automation components
+- Go 1.21 (modular architecture)
+- PostgreSQL + Redis (production database)
+- Stripe SDK (full payment processing)
+- OVH SDK (complete infrastructure automation)
+- Dolibarr API (prospect/customer management - VITAL)
+- Cloudron CLI (automated installation)
+- HTMX + Bootstrap (dynamic frontend, accessible)
+- Redis Queue (worker system)
 ```
 
 ## Phase 2: Core Application Development (Hours 3-4)
 
 ### 2.1 Exact Customer Lifecycle Flow
 
-#### Step 1: Email Capture & Verification
+#### Step 1: Email Capture & Verification (VITAL DOLIBARR INTEGRATION)
 ```
 User enters email → Validate email format → 
 Send verification email with one-time link → 
 User clicks link → Verify token → 
-Create Dolibarr prospect → 
+**Create Dolibarr prospect (VITAL - non-negotiable)** → 
 Redirect to domain selection
 ```
 
+#### Critical Dolibarr Integration Flow (90-Minute MVP)
+```
+1. Email verification successful → 
+2. Call Dolibarr API /api/index.php/prospects → 
+3. Create prospect with:
+   - Email address (verified)
+   - Source: "YDN Web Form"
+   - Status: "Lead"
+   - Created date: current timestamp
+4. Store Dolibarr prospect ID in local database
+5. Update prospect status throughout customer journey
+```
+
+#### Critical Dolibarr Integration Flow (12-36 Hour Complete)
+```
+1. Prospect creation (MVP phase)
+2. Payment successful → Convert prospect to customer
+3. Service provisioning → Create contract/project
+4. Monthly billing → Generate invoices
+5. Support requests → Create tickets
+6. All updates sync bidirectional with Dolibarr
+```
+
 #### Step 2: Domain Availability Loop
 ```
 User enters domain → Check availability via OVH → 
@@ -977,7 +1027,7 @@ echo "Deployment successful!"
 - **HTTPS**: Automatic TLS via Caddy, HSTS headers
 - **Security Headers**: CSP, X-Frame-Options, X-Content-Type-Options
 - **Worker Security**: Payload encryption, signature verification
-- **API Security**: API key rotation, IP whitelisting for OVH/Stripe
+- **API Security**: API key rotation, IP whitelisting for OVH/Stripe/Dolibarr
 - **Data Encryption**: AES-256 encryption for sensitive data (SSH keys, tokens)
 - **Audit Logging**: All actions logged with user context
 - **PCI Compliance**: Stripe Elements, no card data storage, secure customer data handling
@@ -985,6 +1035,21 @@ echo "Deployment successful!"
 - **VPS Security**: Firewall configuration, fail2ban, automatic updates
 - **Cloudron Security**: Admin invite token security, HTTPS enforcement
 - **DNS Security**: DNSSEC support, zone transfer protection
+- **Dolibarr Security**: API key management, data synchronization security
+
+### 10.2 Accessibility Compliance (WCAG 2.1 AA - REQUIRED)
+- **Semantic HTML**: Proper heading structure, landmark elements
+- **Keyboard Navigation**: Full keyboard accessibility, focus management
+- **Screen Reader Support**: ARIA labels, descriptions, roles
+- **Color Contrast**: WCAG AA contrast ratios (4.5:1 normal text)
+- **Text Scaling**: 200% zoom compatibility
+- **Focus Indicators**: Visible focus states for all interactive elements
+- **Form Accessibility**: Proper labels, error messages, field descriptions
+- **Alternative Text**: Meaningful alt text for all images
+- **Responsive Design**: Mobile accessibility, touch targets
+- **Error Handling**: Accessible error notifications and recovery
+- **Language Support**: English only at launch (lang="en" specified)
+- **Testing**: Automated accessibility testing + manual screen reader testing
 
 ### 10.2 Compliance Requirements
 - **GDPR**: Basic data protection, user consent, right to deletion
@@ -1069,94 +1134,121 @@ echo "Deployment successful!"
 - **Payment Failures**: Basic dunning processes, retry logic
 - **Provisioning Failures**: Manual override procedures
 
-## 🚀 AI-SPEED 12-HOUR IMPLEMENTATION TIMELINE
+## 🎯 REALISTIC 90-MINUTE MVP + 12-36 HOUR COMPLETE TIMELINE
 
-### **Hours 1-2: Foundation (AI Parallel Processing)**
+### **PHASE 1: 90-MINUTE MVP (DEMO READY)**
+
+#### **Minutes 0-30: Core Foundation**
 ```
-⚡ SIMULTANEOUS EXECUTION:
-├── Docker Compose setup (15 min) - Pre-built images
-├── Go modules & dependencies (10 min) - AI-generated
-├── Database schema with GORM (20 min) - Auto-migrations
-├── Gin application skeleton (15 min) - Boilerplate
-├── JWT authentication (20 min) - Library integration
-├── Stripe SDK setup (20 min) - Official library
-└── OVH SDK setup (20 min) - Official library
+⚡ HYPER-FOCUSED EXECUTION:
+├── Single Go main.go file (10 min) - Basic HTTP server
+├── Stripe Elements integration (15 min) - Payment form
+└── Basic HTML template (5 min) - Simple landing page
 ```
 
-### **Hours 3-4: Core Business Logic (AI Parallel Processing)**
+#### **Minutes 30-60: Essential Features**
 ```
-⚡ SIMULTANEOUS EXECUTION:
-├── Email verification workflow (30 min) - Mailgun SDK
-├── Domain availability checking (30 min) - OVH SDK
-├── Payment processing (30 min) - Stripe SDK
-├── User registration/login (30 min) - JWT + GORM
-├── Dolibarr API integration (30 min) - HTTP client
-└── Basic frontend templates (30 min) - Bootstrap
+⚡ HYPER-FOCUSED EXECUTION:
+├── Email capture form (15 min) - Basic validation
+├── Domain availability check (15 min) - OVH API call
+├── Basic SQLite database (10 min) - Single file storage
+├── Email verification (10 min) - Simple token system
+└── Dolibarr prospect creation (10 min) - API integration
 ```
 
-### **Hours 5-6: Worker System (AI Parallel Processing)**
+#### **Minutes 60-90: MVP Polish**
 ```
-⚡ SIMULTANEOUS EXECUTION:
-├── Redis queue setup (15 min) - Go-Redis library
-├── Domain registration worker (30 min) - OVH SDK wrapper
-├── VPS creation worker (30 min) - OVH SDK wrapper
-├── Cloudron install worker (30 min) - CLI wrapper
-├── DNS configuration worker (30 min) - OVH DNS SDK
-└── Email notification worker (15 min) - Mailgun SDK
+⚡ HYPER-FOCUSED EXECUTION:
+├── Success/error pages (15 min) - User feedback
+├── Basic styling (10 min) - Clean Bootstrap
+├── Manual process documentation (10 min) - Backend steps
+└── Testing & fixes (15 min) - Basic functionality
 ```
 
-### **Hours 7-8: Frontend & UX (AI-Generated)**
+### **PHASE 2: 12-36 HOUR CODE COMPLETE (FULL AUTOMATION)**
+
+#### **Hours 1-6: Core Automation**
 ```
-⚡ SIMULTANEOUS EXECUTION:
-├── Beautiful landing page (45 min) - Bootstrap templates
-├── Email capture form (30 min) - HTMX + validation
-├── Domain checker interface (30 min) - Real-time API calls
-├── Stripe checkout integration (45 min) - Stripe Elements
-├── Status dashboard (30 min) - WebSocket updates
-└── Admin interface (30 min) - Bootstrap admin
+⚡ PARALLEL EXECUTION:
+├── OVH VPS automation (3 hours) - SSH + provisioning
+├── Cloudron installation automation (3 hours) - CLI integration
+├── Dolibarr API integration (1 hour) - Prospect/customer management (VITAL)
+├── Worker queue system (2 hours) - Redis + task processing
+├── Error handling (2 hours) - Rollback mechanisms
+└── Database migration (2 hours) - PostgreSQL schema
 ```
 
-### **Hours 9-10: Integration & Testing (AI Parallel Processing)**
+#### **Hours 7-12: Advanced Features**
 ```
-⚡ SIMULTANEOUS EXECUTION:
-├── End-to-end workflow testing (45 min) - AI-generated
-├── Mock server setup (30 min) - Docker mocks
-├── Error handling testing (30 min) - Failure scenarios
-├── Load testing (30 min) - Concurrent users
-├── Security testing (30 min) - Input validation
-└── Bug fixes (45 min) - AI debugging
+⚡ PARALLEL EXECUTION:
+├── Cloudron DNS integration (3 hours) - OVH DNS API
+├── Admin invite system (2 hours) - Token generation
+├── Advanced frontend (3 hours) - Real-time status
+├── Accessibility compliance (2 hours) - WCAG 2.1 AA
+├── Comprehensive testing (2 hours) - Unit/integration
+├── Security hardening (2 hours) - Input validation
+└── API documentation (2 hours) - Swagger/OpenAPI
 ```
 
-### **Hours 11-12: Production Deployment (AI Parallel Processing)**
+#### **Hours 13-36: Production Polish (Required)**
 ```
-⚡ SIMULTANEOUS EXECUTION:
-├── Production Docker Compose (30 min) - Pre-configured
-├── Environment configuration (30 min) - .env templates
-├── SSL/TLS setup (15 min) - Caddy automatic
-├── Monitoring setup (30 min) - Health checks
-├── Documentation (15 min) - AI-generated README
-└── Final testing (30 min) - Smoke tests
+⚡ ENHANCEMENT PHASE:
+├── Advanced error handling (4 hours)
+├── Load testing optimization (4 hours)
+├── Advanced monitoring (4 hours)
+├── Accessibility testing & fixes (8 hours) - WCAG 2.1 AA compliance
+├── Comprehensive QA (4 hours)
+└── Performance optimization (4 hours)
 ```
 
-### **AI SPEED MULTIPLIERS ACTIVE:**
+### **🎯 MVP FEATURE SET (90 MINUTES):**
 
-🚀 **Instant Code Generation** - No typing delays
-🚀 **Parallel Processing** - 6+ components simultaneously  
-🚀 **90% Pre-built** - Docker images, SDKs, frameworks
-🚀 **Automated Testing** - Tests generated with code
-🚀 **Immediate Debugging** - AI detects and fixes instantly
-🚀 **Perfect Memory** - No forgetting or context switching
-🚀 **Zero Human Delays** - Continuous focused execution
+#### **✅ WHAT WORKS:**
+- Landing page with value proposition
+- Email capture and verification
+- **Dolibarr prospect creation (VITAL - non-negotiable)**
+- Domain availability checking
+- Stripe payment form ($250/month)
+- Basic user registration
+- Manual backend process documentation
 
-### **TEST-AS-YOU-GO PIPELINE:**
-```go
-// AI generates tests WITH each component:
-✅ Component built → Test generated → Test run → Errors fixed → Continue
-✅ Integration added → Integration test → Test run → Errors fixed → Continue  
-✅ Workflow created → End-to-end test → Test run → Errors fixed → Continue
-```
+#### **🔧 MANUAL BACKEND PROCESSES:**
+- Manual domain registration via OVH dashboard
+- Manual VPS creation via OVH dashboard
+- Manual Cloudron installation via SSH
+- Manual DNS configuration
+- Manual admin invite sending
+- **Dolibarr prospect → customer conversion (manual)**
 
-**RESULT: What takes humans 40 hours, AI completes in 12!** ⚡
+### **🚀 FULL AUTOMATION FEATURE SET (12-36 HOURS):**
+
+#### **✅ FULLY AUTOMATED:**
+- All manual processes become automated
+- Worker queue handles all provisioning
+- Real-time status updates
+- Error handling and rollback
+- Complete Dolibarr integration
+- Cloudron DNS API integration
+- Admin invite automation
+
+### **🎯 SUCCESS CRITERIA:**
+
+#### **90-Minute MVP Success:**
+✅ User can complete payment flow
+✅ Domain availability checking works
+✅ Email verification functional
+✅ **Dolibarr prospect creation works (VITAL)**
+✅ Clear manual process documentation
+
+#### **12-36 Hour Success:**
+✅ All manual processes automated
+✅ End-to-end provisioning works
+✅ Error handling and recovery
+✅ Complete PRD compliance
+✅ **WCAG 2.1 AA accessibility compliance**
+✅ **Dolibarr full integration (prospect → customer)**
+
+**THIS PLAN IS REALISTIC AND ACHIEVABLE!** 🎯
 
 **Total Estimated Time: 12 hours**