diff --git a/Dockerfile b/Dockerfile
index 6347c80..26b62bc 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,113 +1,38 @@
-# ULTIMATE SAFETY VERSION 9000
 FROM python:3.11-slim-bullseye
 
-# Install ALL monitoring and verification tools
-RUN apt-get update && \
-    DEBIAN_FRONTEND=noninteractive apt-get install -y \
-    --no-install-recommends \
-    tree \
-    curl \
-    procps \
-    htop \
-    net-tools \
-    lsof \
-    sysstat \
-    iproute2 \
-    && apt-get clean \
-    && rm -rf /var/lib/apt/lists/*
-
 WORKDIR /app
 
-# STEP 1: CREATE BACKUP HIERARCHY
-RUN for backup in main backup1 backup2 backup3 backup4 rescue emergency last_resort ultrabackup; do \
-        mkdir -p "/app/$backup/src/simpleguardhome" && \
-        mkdir -p "/app/$backup/logs" && \
-        mkdir -p "/app/$backup/monitor" && \
-        chmod -R 755 "/app/$backup" && \
-        echo "Created $backup hierarchy"; \
-    done && \
-    mkdir -p /app/monitor
+# Install essential system packages
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+    curl && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
 
-# STEP 2: Install Python packages with verification
+# Install Python packages
 COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt && \
-    pip install --no-cache-dir \
-        debugpy \
-        psutil \
-        requests \
-        watchdog \
-        prometheus_client \
-        checksumdir \
-        && \
-    pip freeze > /app/requirements.frozen.txt && \
-    echo "⚡ Installed and verified packages:" && \
-    pip list
+RUN pip install --no-cache-dir -r requirements.txt
 
-# STEP 3: Copy source with CHECKSUM verification and create symlink
-COPY src/simpleguardhome /app/main/src/simpleguardhome/
-RUN mkdir -p /app/src && \
-    ln -s /app/main/src /app/src && \
-    echo "Creating verified backups..." && \
-    for backup in backup1 backup2 backup3 backup4 rescue emergency last_resort ultrabackup; do \
-        cp -r /app/main/src/simpleguardhome/* "/app/$backup/src/simpleguardhome/" && \
-        find "/app/$backup/src/simpleguardhome" -type f -exec md5sum {} \; > "/app/$backup/checksums.md5" && \
-        echo "✓ Created and verified $backup"; \
-    done
+# Copy source code
+COPY src/simpleguardhome /app/src/simpleguardhome/
 
-# STEP 4: Set up monitoring
-COPY monitor.py /app/monitor/
-RUN chmod +x /app/monitor/monitor.py && \
-    echo "✓ Installed monitoring system"
-
-# STEP 5: Set up health check script
+# Set up health check
 COPY healthcheck.py /usr/local/bin/
 RUN chmod +x /usr/local/bin/healthcheck.py
 
-# Add health check
 HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
     CMD python3 /usr/local/bin/healthcheck.py
 
-# Set up environment with ALL backup paths
-ENV PYTHONPATH=/app/main/src:/app/backup1/src:/app/backup2/src:/app/backup3/src:/app/backup4/src:/app/rescue/src:/app/emergency/src:/app/last_resort/src:/app/ultrabackup/src \
-    PYTHONBREAKPOINT=debugpy.breakpoint
+# Environment setup
+ENV PYTHONPATH=/app/src \
+    ADGUARD_HOST="http://localhost" \
+    ADGUARD_PORT=3000
 
-# Environment variables with ALL recovery modes
-ENV ADGUARD_HOST="http://localhost" \
-    ADGUARD_PORT=3000 \
-    RESCUE_MODE=0 \
-    EMERGENCY_MODE=0 \
-    LAST_RESORT_MODE=0 \
-    ULTRA_SAFE_MODE=0 \
-    BACKUP_MONITOR=1
+# Expose application port
+EXPOSE 8000
 
-# Expose ports (including debug and monitoring)
-EXPOSE 8000 5678 9090
-
-# Set up backup volume hierarchy
-RUN for backup in rules_backup rules_backup.1 rules_backup.2 rules_backup.3 rules_backup.4 rules_backup.emergency; do \
-        mkdir -p "/app/$backup" && \
-        chmod 777 "/app/$backup" && \
-        echo "Created and verified: /app/$backup"; \
-    done
-
-# ULTRA FINAL VERIFICATION
-RUN echo "=== 🚀 ULTRA FINAL VERIFICATION ===" && \
-    for backup in main backup1 backup2 backup3 backup4 rescue emergency last_resort ultrabackup; do \
-        echo "Verifying $backup:" && \
-        tree "/app/$backup" && \
-        echo "Testing import from $backup:" && \
-        export BACKUP_NAME="$backup" && \
-        PYTHONPATH="/app/$backup/src" python3 -c "import os; from simpleguardhome.main import app; print(f'Import from {os.environ[\"BACKUP_NAME\"]} successful')" && \
-        echo "Verifying checksums for $backup:" && \
-        cd "/app/$backup" && md5sum -c checksums.md5; \
-    done && \
-    echo "Testing monitoring system:" && \
-    python3 -c "import psutil; print('Monitoring system ready')" && \
-    echo "✅ EVERYTHING IS VERIFIED, BACKED UP, AND MONITORED!"
-
-# Copy entrypoint script
+# Copy and set up entrypoint
 COPY docker-entrypoint.sh /usr/local/bin/
 RUN chmod +x /usr/local/bin/docker-entrypoint.sh
 
-# Start monitoring and application
 ENTRYPOINT ["docker-entrypoint.sh"]
\ No newline at end of file
diff --git a/docker-entrypoint.sh b/docker-entrypoint.sh
index 7d64124..ede9560 100644
--- a/docker-entrypoint.sh
+++ b/docker-entrypoint.sh
@@ -1,266 +1,13 @@
 #!/bin/bash
+set -e
 
-# ULTIMATE SAFETY CONTROL SYSTEM V9000
+echo "[$(date '+%Y-%m-%d %H:%M:%S')] Starting SimpleGuardHome..."
 
-# If we're not in ANY recovery mode, exit on ANY error
-if [[ "$RESCUE_MODE" != "1" && "$EMERGENCY_MODE" != "1" && "$LAST_RESORT_MODE" != "1" && "$ULTRA_SAFE_MODE" != "1" ]]; then
-    set -e
+# Verify the package is importable
+if ! python3 -c "from simpleguardhome.main import app"; then
+    echo "Error: Failed to import SimpleGuardHome package"
+    exit 1
 fi
 
-# Colors for ALL THE WARNINGS
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-PURPLE='\033[0;35m'
-CYAN='\033[0;36m'
-NC='\033[0m'
-
-# Logging with timestamps, colors, and BACKUP LOGGING
-log() {
-    local msg="$1"
-    local color="${2:-$NC}"
-    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
-    echo -e "${color}[${timestamp}] $msg${NC}"
-    
-    # Write to ALL log files for redundancy!
-    for backup in main backup1 backup2 backup3 backup4 rescue emergency last_resort ultrabackup; do
-        echo "[${timestamp}] $msg" >> "/app/$backup/logs/system.log"
-    done
-}
-
-# ULTRA monitoring of EVERYTHING
-monitor_everything() {
-    while true; do
-        # Monitor the process
-        if [ -n "$1" ]; then
-            cpu_usage=$(ps -p $1 -o %cpu | tail -1)
-            mem_usage=$(ps -p $1 -o %mem | tail -1)
-            if (( $(echo "$cpu_usage > 90" | bc -l) )) || (( $(echo "$mem_usage > 90" | bc -l) )); then
-                log "⚠️ HIGH RESOURCE USAGE - CPU: ${cpu_usage}%, MEM: ${mem_usage}%" $YELLOW
-            fi
-        fi
-
-        # Monitor the monitoring system
-        if ! pgrep -f "/app/monitor/monitor.py" > /dev/null; then
-            log "🚨 MONITOR SYSTEM DOWN - RESTARTING!" $RED
-            python3 /app/monitor/monitor.py &
-        fi
-
-        # Verify ALL backups
-        for backup in main backup1 backup2 backup3 backup4 rescue emergency last_resort ultrabackup; do
-            if [ ! -d "/app/$backup/src/simpleguardhome" ]; then
-                log "💥 BACKUP MISSING: $backup - INITIATING RECOVERY!" $RED
-                # Try to restore from another backup
-                for source in main backup1 backup2 backup3 backup4 rescue emergency last_resort ultrabackup; do
-                    if [ "$source" != "$backup" ] && [ -d "/app/$source/src/simpleguardhome" ]; then
-                        cp -r "/app/$source/src/simpleguardhome" "/app/$backup/src/"
-                        log "🔄 Restored $backup from $source" $GREEN
-                        break
-                    fi
-                done
-            fi
-        done
-
-        # Verify checksums
-        for backup in main backup1 backup2 backup3 backup4 rescue emergency last_resort ultrabackup; do
-            if [ -f "/app/$backup/checksums.md5" ]; then
-                if ! (cd "/app/$backup" && md5sum -c --quiet checksums.md5 2>/dev/null); then
-                    log "🚨 CHECKSUM FAILURE IN $backup - INITIATING REPAIR!" $RED
-                    repair_backup "$backup"
-                fi
-            fi
-        done
-
-        sleep 5
-    done
-}
-
-# EMERGENCY debug with EVERYTHING
-emergency_debug() {
-    log "🚨 ULTRA EMERGENCY DEBUG ACTIVATED 🚨" $RED
-    
-    # System state
-    log "System Status:" $YELLOW
-    uptime
-    log "Memory Usage:" $YELLOW
-    free -h
-    log "Disk Usage:" $YELLOW
-    df -h
-    log "Process Tree:" $YELLOW
-    pstree -p
-    log "Network Status:" $YELLOW
-    netstat -tulpn
-    log "File Systems:" $YELLOW
-    lsof
-    
-    # Backup verification
-    log "Backup Status:" $YELLOW
-    for backup in main backup1 backup2 backup3 backup4 rescue emergency last_resort ultrabackup; do
-        log "Checking $backup:" $BLUE
-        tree "/app/$backup"
-        if [ -f "/app/$backup/checksums.md5" ]; then
-            (cd "/app/$backup" && md5sum -c checksums.md5) || log "❌ Checksum verification failed for $backup" $RED
-        fi
-    done
-    
-    # Monitor status
-    log "Monitor Status:" $YELLOW
-    if [ -f "/app/monitor/stats.json" ]; then
-        cat "/app/monitor/stats.json"
-    fi
-}
-
-# Repair backup from ANY valid source
-repair_backup() {
-    local broken_backup=$1
-    log "🔧 Attempting to repair $broken_backup..." $YELLOW
-    
-    for source in main backup1 backup2 backup3 backup4 rescue emergency last_resort ultrabackup; do
-        if [ "$source" != "$broken_backup" ] && [ -d "/app/$source/src/simpleguardhome" ]; then
-            if (cd "/app/$source" && md5sum -c --quiet checksums.md5 2>/dev/null); then
-                log "Found valid source: $source" $GREEN
-                cp -r "/app/$source/src/simpleguardhome"/* "/app/$broken_backup/src/simpleguardhome/"
-                cp "/app/$source/checksums.md5" "/app/$broken_backup/"
-                log "✅ Repaired $broken_backup from $source" $GREEN
-                return 0
-            fi
-        fi
-    done
-    
-    log "💥 CRITICAL: Could not repair $broken_backup from any source!" $RED
-    return 1
-}
-
-# Verify EVERYTHING
-verify_everything() {
-    local error_count=0
-    local repair_count=0
-    
-    log "=== 🔍 ULTRA VERIFICATION SYSTEM STARTING ===" $BLUE
-    
-    # 1. Verify ALL backup directories
-    for backup in main backup1 backup2 backup3 backup4 rescue emergency last_resort ultrabackup; do
-        if [ ! -d "/app/$backup/src/simpleguardhome" ]; then
-            log "Missing $backup directory - attempting repair..." $RED
-            if ! repair_backup "$backup"; then
-                error_count=$((error_count + 1))
-            else
-                repair_count=$((repair_count + 1))
-            fi
-        fi
-    done
-    
-    # 2. Verify ALL files in ALL backups
-    local required_files=(
-        "__init__.py"
-        "main.py"
-        "adguard.py"
-        "config.py"
-        "templates/index.html"
-        "favicon.ico"
-    )
-
-    for backup in main backup1 backup2 backup3 backup4 rescue emergency last_resort ultrabackup; do
-        for file in "${required_files[@]}"; do
-            if [ ! -f "/app/$backup/src/simpleguardhome/$file" ]; then
-                log "Missing $file in $backup - attempting repair..." $RED
-                if ! repair_backup "$backup"; then
-                    error_count=$((error_count + 1))
-                else
-                    repair_count=$((repair_count + 1))
-                fi
-                break
-            fi
-        done
-    done
-    
-    # 3. Verify ALL checksums
-    for backup in main backup1 backup2 backup3 backup4 rescue emergency last_resort ultrabackup; do
-        if ! (cd "/app/$backup" && md5sum -c --quiet checksums.md5 2>/dev/null); then
-            log "Checksum verification failed for $backup - attempting repair..." $RED
-            if ! repair_backup "$backup"; then
-                error_count=$((error_count + 1))
-            else
-                repair_count=$((repair_count + 1))
-            fi
-        fi
-    done
-    
-    # 4. Verify Python imports from ALL backups
-    for backup in main backup1 backup2 backup3 backup4 rescue emergency last_resort ultrabackup; do
-        if ! PYTHONPATH="/app/$backup/src" python3 -c "
-import sys
-import simpleguardhome
-from simpleguardhome.main import app
-print(f'Successfully imported from {sys.path[0]}')
-"; then
-            log "Import verification failed for $backup" $RED
-            error_count=$((error_count + 1))
-        fi
-    done
-
-    # Final verdict with ALL safety modes
-    if [ $error_count -gt 0 ]; then
-        if [ "$ULTRA_SAFE_MODE" = "1" ]; then
-            log "⚠️ ULTRA SAFE MODE: Continuing with $error_count errors" $PURPLE
-            return 0
-        elif [ "$LAST_RESORT_MODE" = "1" ]; then
-            log "⚠️ LAST RESORT MODE: Continuing with $error_count errors" $RED
-            return 0
-        elif [ "$EMERGENCY_MODE" = "1" ]; then
-            log "⚠️ EMERGENCY MODE: $error_count errors remain" $RED
-            return 0
-        elif [ "$RESCUE_MODE" = "1" ]; then
-            log "⚠️ RESCUE MODE: $error_count errors remain" $YELLOW
-            return 0
-        else
-            log "💥 FATAL: Found $error_count errors!" $RED
-            log "Try: RESCUE_MODE=1, EMERGENCY_MODE=1, LAST_RESORT_MODE=1, or ULTRA_SAFE_MODE=1" $YELLOW
-            return 1
-        fi
-    fi
-
-    log "✅ ULTRA VERIFICATION PASSED! ($repair_count repairs performed)" $GREEN
-    return 0
-}
-
-# Start monitoring system
-python3 /app/monitor/monitor.py &
-
-# Run verification with ALL safety modes
-if ! verify_everything; then
-    if [[ "$RESCUE_MODE" != "1" && "$EMERGENCY_MODE" != "1" && "$LAST_RESORT_MODE" != "1" && "$ULTRA_SAFE_MODE" != "1" ]]; then
-        log "💥 FATAL: System verification failed!" $RED
-        log "Available recovery modes:" $YELLOW
-        log "  1. RESCUE_MODE=1 (Basic recovery)" $YELLOW
-        log "  2. EMERGENCY_MODE=1 (Aggressive recovery)" $RED
-        log "  3. LAST_RESORT_MODE=1 (Maximum tolerance)" $PURPLE
-        log "  4. ULTRA_SAFE_MODE=1 (Nothing can stop it)" $CYAN
-        exit 1
-    fi
-fi
-
-log "🚀 Starting SimpleGuardHome with ULTRA SAFETY..." $GREEN
-
-# Start with ALL safety features
-if [ "$ULTRA_SAFE_MODE" = "1" ]; then
-    log "👾 ULTRA SAFE MODE ACTIVATED" $PURPLE
-    python3 -m debugpy --listen 0.0.0.0:5678 -m uvicorn simpleguardhome.main:app --host 0.0.0.0 --port 8000 &
-elif [ "$RESCUE_MODE" = "1" ]; then
-    log "🛠️ RESCUE MODE with debugger on port 5678" $YELLOW
-    python3 -m debugpy --listen 0.0.0.0:5678 -m uvicorn simpleguardhome.main:app --host 0.0.0.0 --port 8000 &
-elif [ "$EMERGENCY_MODE" = "1" ]; then
-    log "🚨 EMERGENCY MODE with full monitoring" $RED
-    python3 -m uvicorn simpleguardhome.main:app --host 0.0.0.0 --port 8000 &
-else
-    python3 -m uvicorn simpleguardhome.main:app --host 0.0.0.0 --port 8000 &
-fi
-
-# Get server PID and monitor EVERYTHING
-server_pid=$!
-monitor_everything $server_pid &
-monitor_pid=$!
-
-# Wait for server while monitoring the monitors
-wait $server_pid
\ No newline at end of file
+# Start the application
+exec python3 -m uvicorn simpleguardhome.main:app --host 0.0.0.0 --port 8000
\ No newline at end of file