🏗️ ResuMate Architecture

High-Level Architecture

graph TB
    subgraph Client["Client Layer"]
        WEB["Web Client<br/>React/Angular/Vue"]
        MOB["Mobile App<br/>Flutter/React Native"]
        API_CLIENT["External API<br/>Third-party integrations"]
    end

    subgraph Gateway["API Gateway Layer"]
        NGINX["Nginx<br/>Load Balancer & Reverse Proxy"]
        RATE["Rate Limiting<br/>DRF Throttling"]
    end

    subgraph App["Application Layer"]
        AUTH["Authentication<br/>JWT Tokens"]
        RESUME["Resume Service<br/>CRUD Operations"]
        AI_SVC["AI Service<br/>Content Generation"]
        JOB["Job Tracker<br/>Application Management"]
    end

    subgraph External["External AI Services"]
        GEMINI["Google Gemini<br/>Premium AI Model"]
        OPENROUTER["OpenRouter<br/>Multiple AI Models"]
    end

    subgraph Data["Data Layer"]
        POSTGRES[("PostgreSQL<br/>Primary Database")]
        REDIS[("Redis<br/>Caching & Sessions")]
        FILES["File Storage<br/>Static/Media Files"]
    end

    WEB --> NGINX
    MOB --> NGINX
    API_CLIENT --> NGINX

    NGINX --> RATE
    RATE --> AUTH
    RATE --> RESUME
    RATE --> AI_SVC
    RATE --> JOB

    AI_SVC --> GEMINI
    AI_SVC --> OPENROUTER

    AUTH --> POSTGRES
    RESUME --> POSTGRES
    JOB --> POSTGRES

    AUTH --> REDIS
    RESUME --> FILES

    style POSTGRES fill:#336791,color:#fff
    style GEMINI fill:#4285f4,color:#fff
    style OPENROUTER fill:#ff6b6b,color:#fff
    style NGINX fill:#009639,color:#fff

Database Schema (ERD)

erDiagram
    auth_user {
        int id PK
        string username UK
        string email
        string password
        string first_name
        string last_name
        timestamp last_login
        boolean is_superuser
        boolean is_staff
        boolean is_active
        timestamp date_joined
    }

    resume_resume {
        bigint id PK
        int user_id FK
        string title
        text content
        timestamp created_at
        timestamp updated_at
    }

    job_tracker_jobapplication {
        bigint id PK
        int user_id FK
        bigint resume_used_id FK
        string job_title
        string company_name
        text original_job_description
        date date_applied
        string status
        text notes
        boolean is_deleted
        boolean is_example
        timestamp created_at
        timestamp updated_at
    }

    ai_aimodel {
        bigint id PK
        string display_name UK
        string model_name
        string api_provider
        string api_key_name
        boolean is_active
        boolean login_required
        int daily_limit
        string response_time_info
        text description
        timestamp created_at
        timestamp updated_at
    }

    auth_group {
        int id PK
        string name UK
    }

    auth_permission {
        int id PK
        string name
        int content_type_id FK
        string codename
    }

    django_content_type {
        int id PK
        string app_label
        string model
    }

    auth_user ||--o{ resume_resume : "owns"
    auth_user ||--o{ job_tracker_jobapplication : "creates"
    resume_resume ||--o{ job_tracker_jobapplication : "used_in"
    auth_user ||--o{ auth_user_groups : "belongs_to"
    auth_group ||--o{ auth_user_groups : "contains"
    auth_user ||--o{ auth_user_user_permissions : "has"
    auth_permission ||--o{ auth_user_user_permissions : "granted_to"
    django_content_type ||--o{ auth_permission : "defines"

Key Database Features:

Database Table Structure

Core Application Tables

Django System Tables

Database Indexes & Performance

-- Resume table indexes
CREATE INDEX resume_resume_user_id_0b155703 
    ON resume_resume(user_id);

-- Job application table indexes  
CREATE INDEX job_tracker_jobapplication_user_id_a3f6cbf6 
    ON job_tracker_jobapplication(user_id);
CREATE INDEX job_tracker_jobapplication_resume_used_id_68776f96 
    ON job_tracker_jobapplication(resume_used_id);

-- Authentication system indexes
CREATE INDEX auth_user_groups_user_id_6a12ed8b 
    ON auth_user_groups(user_id);
CREATE INDEX auth_user_user_permissions_user_id_a95ead1b 
    ON auth_user_user_permissions(user_id);

-- All FK constraints use DEFERRABLE INITIALLY DEFERRED
-- for transaction-level consistency checking
ALTER TABLE job_tracker_jobapplication
    ADD CONSTRAINT job_tracker_jobapplication_user_id_a3f6cbf6_fk_auth_user_id 
    FOREIGN KEY (user_id) REFERENCES auth_user (id)
    DEFERRABLE INITIALLY DEFERRED;

API Request Flow

sequenceDiagram
    participant Client
    participant Nginx
    participant Django
    participant JWT
    participant AI
    participant DB
    participant External

    Note over Client,External: AI Resume Generation Flow

    Client->>Nginx: POST /api/ai/generate/
    Nginx->>Django: Forward Request

    Django->>JWT: Validate Token (Optional)
    alt Authenticated User
        JWT-->>Django: Valid User
    else Anonymous User
        JWT-->>Django: Anonymous Access
    end

    Django->>Django: Validate Request Data
    Django->>DB: Check AI Model Permissions
    DB-->>Django: Model Configuration

    Django->>AI: Process Generation Request
    AI->>External: Call AI API (Gemini/OpenRouter)
    External-->>AI: AI Response
    AI-->>Django: Processed Content

    Django->>DB: Save Resume (resume_resume table)
    DB-->>Django: Resume ID

    Django-->>Client: Response with resume_id and content

    Note over Client,External: Error Handling

    alt API Error
        External-->>AI: AI Service Error
        AI-->>Django: Exception
        Django-->>Client: 503 Service Unavailable
    else Rate Limit Exceeded
        Django-->>Client: 429 Too Many Requests
    else Authentication Required
        JWT-->>Django: Invalid/Missing Token
        Django-->>Client: 401 Unauthorized
    end

Flow Breakdown:

# JWT Token Validation
if token_provided:
    user = authenticate_jwt(token)
    permissions = get_user_permissions(user)
else:
    user = AnonymousUser()
    permissions = get_anonymous_permissions()

# AI Model Selection & Validation
model = ai_aimodel.objects.get(
    display_name=request_data['model'],
    is_active=True
)

if model.login_required and not user.is_authenticated:
    raise PermissionError("Authentication required")

# AI API Call with Error Handling
try:
    ai_response = generate_resume_content(
        model_instance=model,
        user_input=request_data['user_input']
    )
except Exception as e:
    return Response(
        {"error": "AI service unavailable"}, 
        status=503
    )

Technology Stack

Redis Caching Architecture

# Docker Compose Configuration
redis:
  image: redis:alpine
  container_name: resumate_redis_prod
  restart: always
  command: redis-server --maxmemory 256mb --maxmemory-policy allkeys-lru
  volumes:
    - redis_data_prod:/data

# Cache Implementation
CACHE_KEY = "ai_models_list"
CACHE_TIMEOUT = 60 * 60  # 1 hour

def get(self, request):
    # Try cache first
    cached_data = cache.get(self.CACHE_KEY)
    if cached_data:
        return Response({
            'cache_status': 'HIT (Response from Redis cache)',
            'data': cached_data
        }, headers={'X-Cache-Status': 'HIT'})

    # Cache miss - fetch from database
    active_models = ai_aimodel.objects.filter(is_active=True)
    serializer = AIModelSerializer(active_models, many=True)
    cache.set(self.CACHE_KEY, serializer.data, self.CACHE_TIMEOUT)

    return Response({
        'cache_status': 'MISS (Response from database)',
        'data': serializer.data
    }, headers={'X-Cache-Status': 'MISS'})

# Cache implementation for example job applications
CACHE_KEY = "example_job_applications_list"
CACHE_TIMEOUT = 60 * 60  # 1 hour

def get(self, request):
    cached_data = cache.get(self.CACHE_KEY)
    if cached_data:
        return Response({
            'cache_status': 'HIT (Response from Redis cache)',
            'data': cached_data
        }, headers={'X-Cache-Status': 'HIT'})

    # Cache miss - fetch example applications
    example_apps = job_tracker_jobapplication.objects.filter(
        is_example=True, 
        is_deleted=False
    )
    serializer = JobApplicationSerializer(example_apps, many=True)
    cache.set(self.CACHE_KEY, serializer.data, self.CACHE_TIMEOUT)

    return Response({
        'cache_status': 'MISS (Response from database)',
        'data': serializer.data
    }, headers={'X-Cache-Status': 'MISS'})

Security Architecture

graph LR
    subgraph Security["Security Layers"]
        subgraph Network["Network Security"]
            HTTPS["HTTPS/TLS"]
            CORS["CORS Policy"]
            NGINX_SEC["Nginx Security Headers"]
        end

        subgraph Application["Application Security"]
            JWT["JWT Tokens"]
            RATE_LIMIT["Rate Limiting"]
            VALIDATION["Input Validation"]
        end

        subgraph DataSec["Data Security"]
            DB_ENCRYPT["DB Encryption"]
            SOFT_DELETE["Soft Deletes"]
            API_KEYS["API Key Management"]
        end
    end

    HTTPS --> JWT
    CORS --> RATE_LIMIT
    NGINX_SEC --> VALIDATION
    JWT --> DB_ENCRYPT
    RATE_LIMIT --> SOFT_DELETE
    VALIDATION --> API_KEYS

    style HTTPS fill:#d73027,color:#fff
    style JWT fill:#1a9850,color:#fff
    style DB_ENCRYPT fill:#313695,color:#fff

Security Implementation:

Scalability Design

graph TB
    subgraph LoadBalancer["Load Balancer"]
        LB["Load Balancer<br/>Nginx/HAProxy"]
    end

    subgraph AppServers["Application Servers"]
        APP1["Django Instance 1"]
        APP2["Django Instance 2"]
        APP3["Django Instance 3"]
    end

    subgraph DataLayer["Data Layer"]
        DB_MASTER[("PostgreSQL Master")]
        DB_READ1[("Read Replica 1")]
        DB_READ2[("Read Replica 2")]
        REDIS_CLUSTER[("Redis Cluster")]
    end

    subgraph AIServices["AI Services"]
        AI_POOL["AI Service Pool<br/>Multiple API Keys"]
    end

    LB --> APP1
    LB --> APP2
    LB --> APP3

    APP1 --> DB_MASTER
    APP2 --> DB_READ1
    APP3 --> DB_READ2

    APP1 --> REDIS_CLUSTER
    APP2 --> REDIS_CLUSTER
    APP3 --> REDIS_CLUSTER

    APP1 --> AI_POOL
    APP2 --> AI_POOL
    APP3 --> AI_POOL

    style LB fill:#2ecc71,color:#fff
    style DB_MASTER fill:#e74c3c,color:#fff
    style DB_READ1 fill:#3498db,color:#fff
    style DB_READ2 fill:#3498db,color:#fff
    style REDIS_CLUSTER fill:#e67e22,color:#fff

Scalability Features:

Deployment Architecture

graph TB
    subgraph Development["Development"]
        DEV_CODE["Local Development<br/>Docker Compose"]
        GIT["Git Repository<br/>GitHub"]
    end

    subgraph CICD["CI/CD Pipeline"]
        ACTIONS["GitHub Actions"]
        TESTS["Automated Tests"]
        BUILD["Docker Build"]
        REGISTRY["Docker Hub<br/>Image Registry"]
    end

    subgraph Production["Production Environment"]
        PROD_SERVER["Production Server<br/>Linux/Cloud"]
        PROD_DB[("PostgreSQL<br/>Production")]
        PROD_REDIS[("Redis<br/>Production")]
        NGINX_PROD["Nginx<br/>Reverse Proxy"]
    end

    DEV_CODE --> GIT
    GIT --> ACTIONS
    ACTIONS --> TESTS
    TESTS --> BUILD
    BUILD --> REGISTRY

    REGISTRY --> PROD_SERVER
    PROD_SERVER --> PROD_DB
    PROD_SERVER --> PROD_REDIS
    NGINX_PROD --> PROD_SERVER

    style ACTIONS fill:#2ecc71,color:#fff
    style REGISTRY fill:#0db7ed,color:#fff
    style PROD_SERVER fill:#e74c3c,color:#fff
    style NGINX_PROD fill:#009639,color:#fff

Deployment Process:

# GitHub Actions Workflow
name: CI/CD Pipeline
on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Run Tests
        run: docker-compose -f docker-compose.test.yml up --abort-on-container-exit

  build:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - name: Build & Push Docker Image
        run: |
          docker build -t resumate:${{ github.sha }} .
          docker push resumate:${{ github.sha }}

Design Decisions & Trade-offs