┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   Frontend      │    │   Load Balancer  │    │   CDN/CloudFront│
│   (React)       │◄───┤   (ALB)          │◄───┤   (Static Assets)│
└─────────────────┘    └──────────────────┘    └─────────────────┘
         │                        │
         │                        ▼
         │              ┌──────────────────┐
         │              │   Django Backend │
         │              │   (ECS Cluster)  │
         │              └──────────────────┘
         │                        │
         │                        ▼
         │              ┌──────────────────┐
         │              │   PostgreSQL     │
         │              │   (RDS)          │
         │              └──────────────────┘
         │
         ▼
┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   WebSocket     │    │   Redis Cache    │    │   S3 Storage    │
│   (Channels)    │◄───┤   (ElastiCache)  │    │   (Media Files) │
└─────────────────┘    └──────────────────┘    └─────────────────┘
         │
         ▼
┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   LiveKit       │    │   AI/ML Services │    │   Monitoring    │
│   (Video/Audio) │    │   (AWS Services) │    │   (DataDog)     │
└─────────────────┘    └──────────────────┘    └─────────────────┘

# Core business logic modules
INSTALLED_APPS = [
    'jobhive.users',           # User management and authentication
    'jobhive.company',         # Company profiles and management  
    'jobhive.interview',       # Interview sessions and analysis
    'jobhive.billing',         # Subscription and payment processing
    'jobhive.utils',           # Shared utilities and middleware
]

# Interview Management
POST   /api/interview/interviews/              # Create interview session
GET    /api/interview/interviews/{id}/         # Get interview details
PUT    /api/interview/interviews/{id}/         # Update interview
DELETE /api/interview/interviews/{id}/         # Delete interview

# AI Analysis
GET    /api/interview/interviews/{id}/benchmark-comparison/  # Benchmark data
POST   /api/interview/sentiment-sessions/      # Create sentiment session
GET    /api/interview/skill-assessments/       # Get skill assessments

# User Management  
GET    /api/users/me/                          # Current user profile
POST   /api/auth/login/                        # User authentication
POST   /api/auth/register/                     # User registration

# Billing
GET    /api/billing/plans/                     # Subscription plans
POST   /api/billing/subscriptions/            # Create subscription
GET    /api/billing/analytics/                # Billing analytics

-- Interview session indexes for fast queries
CREATE INDEX CONCURRENTLY idx_interview_sessions_user_status 
ON interview_interviewsession(user_id, status, start_time);

CREATE INDEX CONCURRENTLY idx_interview_sessions_completion 
ON interview_interviewsession(completion_percentage);

-- Sentiment analysis indexes
CREATE INDEX CONCURRENTLY idx_sentiment_sessions_created 
ON interview_sentimentsession(interview_session_id, created_at);

-- Billing indexes for performance
CREATE INDEX CONCURRENTLY idx_billing_user_subscription 
ON billing_customersubscription(user_id, status);

# Core Models Relationships
User (1) ──── (1) Company                    # Company profile
User (1) ──── (*) InterviewSession           # Interview sessions
InterviewSession (1) ──── (*) SentimentSession    # Sentiment analysis
InterviewSession (1) ──── (*) SkillAssessment     # Skill evaluations
InterviewSession (1) ──── (1) CulturalFit         # Cultural fit analysis
User (1) ──── (1) CustomerSubscription       # Billing relationship

# WebSocket routing configuration
websocket_urlpatterns = [
    path('ws/interview/<session_id>/', InterviewConsumer.as_asgi()),
    path('ws/dashboard/<user_id>/', DashboardConsumer.as_asgi()),
]

# Consumer for real-time interview updates
class InterviewConsumer(AsyncWebsocketConsumer):
    async def connect(self):
        self.session_id = self.scope['url_route']['kwargs']['session_id']
        self.room_group_name = f'interview_{self.session_id}'
        
        await self.channel_layer.group_add(
            self.room_group_name,
            self.channel_name
        )

class EnhancedSentimentAgent:
    def analyze_sentiment_with_context(self, text, context_factors):
        # Base sentiment analysis
        sentiment_scores = self.base_sentiment_analyzer(text)
        
        # Context enhancement
        context_scores = self.analyze_context_factors(text, context_factors)
        
        # Weighted combination
        final_score = self.calculate_weighted_sentiment(
            sentiment_scores, context_scores
        )
        
        return final_score

# AI Agent Hierarchy
OrchestratorAgent           # Coordinates all AI processes
├── SentimentAnalysisAgent  # Emotional and engagement analysis
├── SkillAssessmentAgent    # Technical skill evaluation
├── CulturalFitAgent        # Company culture alignment
├── RecommendationsAgent    # Improvement suggestions
└── WorkerAgent             # Background processing tasks

# Session data caching
CACHES = {
    'default': {
        'BACKEND': 'django_redis.cache.RedisCache',
        'LOCATION': 'redis://elasticache-endpoint:6379/1',
        'OPTIONS': {
            'CLIENT_CLASS': 'django_redis.client.DefaultClient',
            'SERIALIZER': 'django_redis.serializers.json.JSONSerializer',
        }
    }
}

# Cache usage patterns
@cache_result(timeout=300)  # 5-minute cache
def get_interview_analytics(user_id, date_range):
    return calculate_interview_metrics(user_id, date_range)

# Optimized queryset patterns
interviews = InterviewSession.objects.select_related(
    'user', 'job', 'job__company'
).prefetch_related(
    'sentiment_sessions',
    'skill_assessments__skill',
    'recommendations'
).filter(
    status='completed',
    start_time__gte=start_date
)

# Celery configuration for background tasks
@shared_task(bind=True, max_retries=3)
def process_interview_analysis(self, interview_session_id):
    try:
        # Run comprehensive AI analysis
        session = InterviewSession.objects.get(id=interview_session_id)
        
        # Execute analysis pipeline
        sentiment_analysis.delay(session.id)
        skill_assessment.delay(session.id)
        cultural_fit_analysis.delay(session.id)
        
    except Exception as exc:
        self.retry(countdown=60, exc=exc)

# Periodic tasks
@periodic_task(run_every=crontab(minute=0, hour=0))  # Daily at midnight
def generate_daily_analytics():
    for company in Company.objects.filter(is_active=True):
        InterviewStatistics.update_statistics(company)

1. Session Creation
   ├── User initiates interview
   ├── WebSocket connection established
   ├── LiveKit room created
   └── Database session record created

2. Real-time Processing
   ├── Audio/video stream processing
   ├── Live transcription and sentiment analysis
   ├── WebSocket updates to frontend
   └── Intermediate results cached

3. Post-Interview Analysis
   ├── Comprehensive AI analysis triggered
   ├── Skill assessments calculated
   ├── Cultural fit evaluation
   ├── Recommendations generated
   └── Final results stored and cached

4. Results Delivery
   ├── Dashboard updates via WebSocket
   ├── Email notifications sent
   ├── Analytics data aggregated
   └── Reports generated

Client Request
    ↓
Load Balancer (ALB)
    ↓
Django Application
    ↓
Authentication Middleware
    ↓
Permission Checks
    ↓
Business Logic Layer
    ↓
Database Query (with caching)
    ↓
Response Serialization
    ↓
JSON Response to Client

# JWT-based authentication
SIMPLE_JWT = {
    'ACCESS_TOKEN_LIFETIME': timedelta(minutes=60),
    'REFRESH_TOKEN_LIFETIME': timedelta(days=7),
    'ROTATE_REFRESH_TOKENS': True,
    'ALGORITHM': 'HS256',
}

# Permission-based access control
class InterviewSessionViewSet(ModelViewSet):
    permission_classes = [IsAuthenticated, IsOwnerOrReadOnly]
    
    def get_queryset(self):
        return InterviewSession.objects.filter(
            user=self.request.user
        )

# ECS Service Configuration
services:
  django-web:
    image: jobhive/backend:latest
    cpu: 512
    memory: 1024
    desired_count: 3
    load_balancer:
      target_group: jobhive-web-tg
      
  celery-worker:
    image: jobhive/backend:latest
    command: celery -A config worker
    cpu: 256  
    memory: 512
    desired_count: 2
    
  celery-beat:
    image: jobhive/backend:latest
    command: celery -A config beat
    cpu: 128
    memory: 256
    desired_count: 1

# CloudWatch metrics for scaling
SCALING_METRICS = {
    'cpu_utilization': {
        'target': 70,
        'scale_up_cooldown': 300,
        'scale_down_cooldown': 600
    },
    'memory_utilization': {
        'target': 80,
        'scale_up_cooldown': 300,
        'scale_down_cooldown': 600
    }
}

# Custom metrics tracking
from datadog import DogStatsdClient

statsd = DogStatsdClient(host='localhost', port=8125)

class InterviewMetricsMiddleware:
    def process_request(self, request):
        statsd.increment('interview.session.started')
        
    def process_response(self, request, response):
        statsd.timing('interview.response_time', response.time)
        statsd.increment(f'interview.response.{response.status_code}')

# Logging configuration
LOGGING = {
    'version': 1,
    'handlers': {
        'console': {
            'class': 'logging.StreamHandler',
            'formatter': 'json',
        },
        'datadog': {
            'class': 'datadog.DogStatsdLogHandler',
            'level': 'INFO',
        }
    },
    'formatters': {
        'json': {
            'class': 'pythonjsonlogger.jsonlogger.JsonFormatter',
            'format': '%(asctime)s %(name)s %(levelname)s %(message)s'
        }
    }
}

# Infrastructure Components
VPC:
  - Public Subnets (ALB, NAT Gateway)
  - Private Subnets (ECS, RDS)
  - Database Subnets (Multi-AZ RDS)

ECS Cluster:
  - Fargate launch type
  - Auto Scaling Groups
  - Service discovery
  
RDS PostgreSQL:
  - Multi-AZ deployment
  - Read replicas for analytics
  - Automated backups
  
ElastiCache Redis:
  - Cluster mode enabled
  - Multi-AZ replication
  - Automatic failover

# GitHub Actions Workflow
name: Deploy to Production
on:
  push:
    branches: [main]
    
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Build Docker Image
        run: docker build -t jobhive/backend:${{ github.sha }} .
        
      - name: Push to ECR
        run: docker push $ECR_REGISTRY/jobhive/backend:${{ github.sha }}
        
      - name: Deploy to ECS
        run: aws ecs update-service --cluster prod --service jobhive-web