diff --git a/DATABASE_RESET_FEATURE.md b/DATABASE_RESET_FEATURE.md
new file mode 100644
index 0000000..8331423
--- /dev/null
+++ b/DATABASE_RESET_FEATURE.md
@@ -0,0 +1,209 @@
+# Database Reset Feature
+
+## Overview
+
+Added a "Reset Database" feature to the System Testing page that allows complete database reset with proper safety measures.
+
+## Implementation Details
+
+### Frontend (UI)
+
+**Location**: [src/templates/dashboard.html](src/templates/dashboard.html)
+
+**Added Components**:
+
+1. **Database Management Section** (lines 579-596)
+   - Warning box with red styling
+   - Reset button with loading state
+   - Result display area for success/error messages
+
+2. **Confirmation Modal** (lines 862-913)
+   - Full-screen overlay with backdrop
+   - Detailed warning about data loss
+   - List of items that will be deleted
+   - Type-to-confirm input (requires typing "RESET")
+   - Cancel and confirm buttons
+   - Enter key support for confirmation
+   - Automatic modal close on success
+
+**JavaScript State**: [src/static/js/dashboard.js](src/static/js/dashboard.js:87-91)
+
+```javascript
+showResetConfirmation: false,
+resetConfirmText: '',
+resettingDatabase: false,
+resetResult: null
+```
+
+**JavaScript Function**: [src/static/js/dashboard.js](src/static/js/dashboard.js:802-853)
+
+```javascript
+async resetDatabase() {
+    // Validates confirmation text
+    // Calls API endpoint
+    // Shows result
+    // Reloads all data on success
+    // Clears local state
+}
+```
+
+### Backend (API)
+
+**New Route File**: [src/routes/api/database_routes.py](src/routes/api/database_routes.py)
+
+**Endpoints**:
+
+1. **POST /api/database/reset**
+   - Deletes the database file
+   - Reinitializes schema with default templates
+   - Returns success/error status
+   - Includes comprehensive error handling
+
+2. **GET /api/database/stats** (bonus endpoint)
+   - Returns database statistics
+   - Table counts, file size, existence check
+
+**Route Registration**: [src/app.py](src/app.py:36)
+- Imported database_routes blueprint
+- Initialized with db_manager and config
+- Registered with Flask app
+
+## Safety Features
+
+### Multi-Layer Confirmation
+
+1. **Initial Button Click**: User must click "Reset Database" button
+2. **Modal Warning**: Full-screen modal with detailed warnings
+3. **Type to Confirm**: User must type "RESET" exactly
+4. **Button Disabled**: Confirm button disabled until correct text entered
+5. **Enter Key Support**: Can press Enter after typing "RESET"
+
+### Visual Warnings
+
+- Red color scheme for danger zone
+- Warning emoji (⚠️)
+- Bold "This cannot be undone!" message
+- Bullet list of what will be deleted:
+  - All campaigns and their messages
+  - All contact lists
+  - All conversation history
+  - All message templates
+
+### Backend Safety
+
+- Permission error handling
+- Graceful error messages
+- Logging of all reset attempts
+- Wait period before deletion (0.5s)
+- Automatic schema reinitialization
+- Default templates restored
+
+## User Experience
+
+### Success Flow
+
+1. Click "🗑️ Reset Database"
+2. Modal appears with warnings
+3. Type "RESET" in input field
+4. Click "Reset Database" or press Enter
+5. Button shows "Resetting..." state
+6. Success message appears
+7. Modal closes automatically
+8. UI refreshes with empty state
+9. Default templates are restored
+
+### Error Flow
+
+1. If error occurs during reset
+2. Error message displayed in red box
+3. Modal remains open
+4. User can try again or cancel
+5. Detailed error logged to server
+
+## Files Modified
+
+1. **src/templates/dashboard.html**
+   - Added database management section
+   - Added confirmation modal
+
+2. **src/static/js/dashboard.js**
+   - Added state variables
+   - Added resetDatabase() function
+
+3. **src/routes/api/database_routes.py** (NEW)
+   - Created database management routes
+
+4. **src/routes/api/__init__.py**
+   - Exported database_routes and init function
+
+5. **src/app.py**
+   - Imported database_routes
+   - Initialized and registered blueprint
+
+## Testing
+
+### Manual Test Steps
+
+1. Navigate to http://localhost:5000
+2. Click on "🧪 System Testing" tab
+3. Scroll to "Database Management" section
+4. Click "🗑️ Reset Database"
+5. Verify modal appears
+6. Try clicking "Reset Database" without typing - should be disabled
+7. Type "RESET" in input field
+8. Confirm button becomes enabled
+9. Click "Reset Database" or press Enter
+10. Verify success message
+11. Check that campaigns, lists, templates are empty
+12. Verify default templates are restored
+
+### API Test
+
+```bash
+# Test database reset endpoint
+curl -X POST http://localhost:5000/api/database/reset
+
+# Check database stats
+curl http://localhost:5000/api/database/stats
+```
+
+## Screenshots Description
+
+**Database Management Section**:
+- Red border and background
+- Warning text
+- Reset button
+- Result area
+
+**Confirmation Modal**:
+- Warning icon in circle
+- Detailed warning message
+- Bullet list of data to delete
+- "Type RESET to confirm" input
+- Cancel and Reset buttons
+
+## Future Enhancements
+
+Potential improvements:
+- Add database backup before reset
+- Export data option before reset
+- Selective table reset (reset only campaigns, only templates, etc.)
+- Database migration/upgrade tools
+- Import/restore from backup
+
+## Security Considerations
+
+- Endpoint requires POST method
+- No authentication (add if needed for production)
+- Confirmation required on frontend
+- All actions logged
+- Error messages sanitized
+- File permissions respected
+
+## Notes
+
+- Default templates are automatically restored after reset
+- Database file located at `./data/campaign.db`
+- Journal mode: TRUNCATE (for Docker compatibility)
+- Reset takes ~0.5-1 second typically
+- All data is permanently deleted (no recovery)
diff --git a/DEPLOYMENT_GUIDE.md b/DEPLOYMENT_GUIDE.md
new file mode 100644
index 0000000..9cbb384
--- /dev/null
+++ b/DEPLOYMENT_GUIDE.md
@@ -0,0 +1,238 @@
+# SMS Campaign Manager - Deployment Guide
+
+## Quick Deployment Summary
+
+This guide provides a streamlined deployment process for the SMS Campaign Manager using Tailscale for reliable connectivity.
+
+## Prerequisites Checklist
+
+- [ ] Docker & Docker Compose installed on Ubuntu homelab
+- [ ] Tailscale installed on Ubuntu homelab
+- [ ] Tailscale installed on Android device
+- [ ] Termux installed on Android (from F-Droid)
+- [ ] Termux:API installed on Android (from F-Droid)
+- [ ] SSH server running in Termux
+- [ ] SMS permissions granted to Termux:API
+
+## Step-by-Step Deployment
+
+### 1. Prepare Android Device
+
+**Install Tailscale:**
+```
+1. Install Tailscale from Google Play Store
+2. Sign in and connect to your Tailnet
+3. Note your Android's Tailscale IP (Settings → Connected)
+   Example: 100.107.173.66
+```
+
+**Install Termux:**
+```
+1. Download Termux from F-Droid: https://f-droid.org/packages/com.termux/
+2. Download Termux:API from F-Droid: https://f-droid.org/packages/com.termux.api/
+3. DO NOT use Google Play versions - they're outdated
+```
+
+**Setup Termux:**
+```bash
+# In Termux on Android, run:
+pkg update && pkg upgrade
+pkg install openssh termux-api python
+sshd
+passwd
+```
+
+**Grant Permissions:**
+```
+1. Open Android Settings
+2. Navigate to Apps → Termux:API
+3. Grant SMS permission
+4. Grant Phone permission
+```
+
+### 2. Configure Ubuntu Homelab
+
+**Create .env file:**
+```bash
+cd /mnt/storagessd1tb/campaign_connector
+
+cat > .env << 'EOF'
+# Android Device Configuration
+PHONE_IP=100.107.173.66          # Your Android's Tailscale IP
+ADB_PORT=5555
+TERMUX_API_PORT=5001
+
+# Flask Application
+FLASK_ENV=production
+SECRET_KEY=change-this-to-secure-random-string
+DEFAULT_DELAY_SECONDS=3
+
+# SMS Retry Configuration
+SMS_MAX_RETRIES=3
+SMS_RETRY_BASE_DELAY=2
+SMS_MAX_RETRY_DELAY=8
+EOF
+
+# Edit with your actual Tailscale IP
+nano .env
+```
+
+### 3. Deploy Services
+
+**Deploy to Android:**
+```bash
+./deploy-android.sh
+```
+
+This will:
+- Test connectivity
+- Deploy shell scripts to ~/bin/
+- Deploy Python apps to ~/projects/sms-campaign-manager/
+- Start all services
+- Verify deployment
+
+**Start Ubuntu Homelab:**
+```bash
+./run.sh start
+# OR
+docker compose up -d
+```
+
+### 4. Verify Deployment
+
+**Check service health:**
+```bash
+# Test Ubuntu homelab
+curl http://localhost:5000/health
+
+# Test Android SMS API (replace with your Tailscale IP)
+curl http://100.107.173.66:5001/health
+
+# Test Android monitor
+curl http://100.107.173.66:5000/
+```
+
+**View logs:**
+```bash
+# Ubuntu homelab logs
+docker compose logs -f sms-campaign
+
+# Android service logs
+ssh -p 8022 100.107.173.66 "tail -f ~/logs/sms-api.log"
+```
+
+## Service URLs
+
+After successful deployment:
+
+- **Ubuntu Campaign Manager**: http://localhost:5000
+- **Android SMS API**: http://100.107.173.66:5001
+- **Android Monitor**: http://100.107.173.66:5000
+
+## Managing Services
+
+### Ubuntu Homelab
+
+```bash
+./run.sh start     # Start services
+./run.sh stop      # Stop services
+./run.sh logs      # View logs
+./run.sh status    # Check status
+./run.sh rebuild   # Rebuild and restart
+```
+
+### Android Services
+
+```bash
+# SSH into Android (replace with your Tailscale IP)
+ssh -p 8022 100.107.173.66
+
+# Start all services
+~/bin/start-all-services.sh
+
+# Check status
+~/bin/sms-service.sh status
+
+# View logs
+tail -f ~/logs/sms-api.log
+tail -f ~/logs/monitoring.log
+```
+
+## Connection Architecture
+
+```
+Ubuntu Homelab
+    ↓ (Tailscale VPN)
+Android Device
+    ↓
+Termux API Server (Port 5001) ← Primary SMS method
+    ↓
+Native Android SMS API
+```
+
+**Advantages:**
+- Works anywhere (not limited to same WiFi)
+- Encrypted connection via Tailscale
+- Faster SMS sending (direct API vs ADB)
+- No ADB timeouts or connection issues
+- Automatic failover to ADB if Termux fails
+
+## Troubleshooting
+
+### "Cannot reach Android device"
+```bash
+# Check Tailscale status
+tailscale status
+
+# Ping Android device
+ping 100.107.173.66
+
+# Verify Tailscale IP in .env matches Android
+```
+
+### "SSH connection failed"
+```bash
+# Check if SSH server is running on Android
+ssh -p 8022 100.107.173.66 "whoami"
+
+# Restart SSH server in Termux
+sshd
+```
+
+### "Termux API not responding"
+```bash
+# Redeploy services
+./deploy-android.sh
+
+# Or manually restart
+ssh -p 8022 100.107.173.66 "~/bin/start-all-services.sh"
+
+# Check if services are running
+ssh -p 8022 100.107.173.66 "ps aux | grep python"
+```
+
+### "Permission denied" when sending SMS
+```
+1. Open Android Settings
+2. Apps → Termux:API
+3. Permissions → SMS → Allow
+4. Restart Termux API service
+```
+
+## Next Steps
+
+After deployment:
+
+1. Access web interface: http://localhost:5000
+2. Upload a CSV with contacts
+3. Create a campaign
+4. Send test SMS
+5. Monitor delivery status
+
+## Support
+
+For issues or questions:
+- Check logs: `docker compose logs -f`
+- Review [README.md](README.md) for detailed documentation
+- Verify all prerequisites are met
+- Ensure Tailscale is running on both devices
diff --git a/README.md b/README.md
index 0631de0..20032ab 100644
--- a/README.md
+++ b/README.md
@@ -7,123 +7,113 @@
 
 ## 🚀 Quick Start
 
-### One-Command Deployment
+### One-Command Deployment (Recommended - Tailscale)
 ```bash
-# 1. Deploy to Android with correct directory structure
-# Scripts go to ~/bin/
-scp -P 8022 android/*.sh android-dev@10.0.0.193:~/bin/
-ssh android-dev "chmod +x ~/bin/*.sh"
+# 1. Configure environment
+# Edit .env with your Android device's Tailscale IP
+nano .env
 
-# Python apps go to ~/projects/sms-campaign-manager/
-ssh android-dev "mkdir -p ~/projects/sms-campaign-manager"
-scp -P 8022 android/*.py android-dev@10.0.0.193:~/projects/sms-campaign-manager/
+# 2. Deploy to Android using automated script
+./deploy-android.sh
 
-# Start all services
-ssh android-dev "~/bin/start-all-services.sh"
-
-# 2. Start Ubuntu homelab
+# 3. Start Ubuntu homelab
 ./run.sh start
 # OR with docker-compose
-docker-compose up -d
+docker compose up -d
 
-# 3. Verify everything is running
-curl http://10.0.0.193:5001/health    # Android SMS API
-curl http://10.0.0.193:5000/          # Android Monitor  
-curl http://localhost:5000/           # Ubuntu Dashboard
+# 4. Verify everything is running
+curl http://YOUR_TAILSCALE_IP:5001/health    # Android SMS API
+curl http://YOUR_TAILSCALE_IP:5000/          # Android Monitor
+curl http://localhost:5000/                  # Ubuntu Dashboard
 ```
 
 ### Prerequisites
 - Docker & Docker Compose installed
-- Android device with USB debugging enabled
-- Local network access to Android device
+- **Tailscale** installed on both Ubuntu homelab and Android device (Recommended)
+  - Or local network access to Android device
+- Android device with Termux and Termux:API installed
+- SSH access to Android device (port 8022)
 
 ### 1. Clone and Configure
 ```bash
 # Clone or navigate to project directory
-cd "ABD Texting Testing"
+cd campaign_connector
 
-# Copy environment template
-cp config/.env.example .env
+# Create environment configuration
+cat > .env << 'EOF'
+# Android Device Configuration (use Tailscale IP for best reliability)
+PHONE_IP=YOUR_TAILSCALE_IP_HERE
+ADB_PORT=5555
+TERMUX_API_PORT=5001
 
-# Edit configuration for your Android device
+# Flask Application
+FLASK_ENV=production
+SECRET_KEY=your-secure-secret-key-here
+DEFAULT_DELAY_SECONDS=3
+
+# SMS Retry Configuration
+SMS_MAX_RETRIES=3
+SMS_RETRY_BASE_DELAY=2
+SMS_MAX_RETRY_DELAY=8
+EOF
+
+# Edit with your actual Tailscale IP
 nano .env
 ```
 
-### 2. Launch with Docker Compose
+### 2. Launch Ubuntu Homelab
 ```bash
 # Quick start using convenience script
 ./run.sh start
 
-# Or manually with docker-compose
-docker-compose up -d
+# Or manually with docker compose
+docker compose up -d
 
 # View logs
-docker-compose logs -f
+docker compose logs -f sms-campaign
 
 # Access web interface
 open http://localhost:5000
 ```
 
-### 3. Connect Your Android Device
-The system will automatically discover and connect to your Android device using the IP configured in `.env`.
-
-### 4. Deploy Android Services
-Copy the pre-configured service files to their correct directories on Termux:
-
+### 3. Deploy to Android Device
 ```bash
-# Deploy shell scripts to ~/bin/ directory
-scp -P 8022 android/*.sh android-dev@10.0.0.193:~/bin/
-ssh -p 8022 android-dev@10.0.0.193 "chmod +x ~/bin/*.sh"
+# Use the automated deployment script
+./deploy-android.sh
 
-# Deploy Python applications to ~/projects/sms-campaign-manager/
-ssh -p 8022 android-dev@10.0.0.193 "mkdir -p ~/projects/sms-campaign-manager"
-scp -P 8022 android/app.py android/termux-sms-api-server.py android-dev@10.0.0.193:~/projects/sms-campaign-manager/
-
-# Verify deployment
-ssh android-dev "ls -la ~/bin/*.sh && ls -la ~/projects/sms-campaign-manager/*.py"
+# The script will:
+# - Test connectivity to your Android device
+# - Deploy shell scripts to ~/bin/
+# - Deploy Python apps to ~/projects/sms-campaign-manager/
+# - Start all services automatically
+# - Verify deployment success
 ```
 
-### 5. Start Android Services
-Your S24 Ultra runs two services for SMS operations. Use the automated startup script:
-
+### 4. Verify Full System
 ```bash
-# Start all services at once (recommended)
-ssh android-dev "~/bin/start-all-services.sh"
+# Test Ubuntu homelab → Android connection
+curl http://localhost:5000/api/phone/status
 
-# Or start services individually:
-ssh android-dev "~/bin/sms-service.sh start"        # SMS API Server
-ssh android-dev "~/bin/start-monitoring.sh"         # Monitoring Interface
+# Test Android SMS API (replace with your Tailscale IP)
+curl http://YOUR_TAILSCALE_IP:5001/health
 
-# Check service status
-ssh android-dev "~/bin/sms-service.sh status"
-curl http://10.0.0.193:5001/health                  # SMS API health check
-curl http://10.0.0.193:5000/                        # Monitoring dashboard
+# Access web interfaces
+open http://localhost:5000              # Main campaign manager
+open http://YOUR_TAILSCALE_IP:5000      # Android monitoring dashboard
 ```
 
-**Available Service Scripts:**
+**Deployed Services:**
+- 🖥️ **Ubuntu Homelab**: http://localhost:5000 (Campaign manager)
+- 🚀 **SMS API Server**: http://YOUR_TAILSCALE_IP:5001 (REST API for sending SMS)
+- 📊 **Android Monitor**: http://YOUR_TAILSCALE_IP:5000 (Device monitoring dashboard)
+
+**Available Service Scripts on Android:**
 - `start-all-services.sh` - Start both services with health checks
 - `sms-service.sh` - Service management (start/stop/status)
 - `start-sms-api.sh` - SMS API Server only
 - `start-monitoring.sh` - Monitoring interface only
 - `network-monitor.sh` - Network connectivity monitoring
 
-**Service URLs:**
-- 🚀 **SMS API Server**: http://10.0.0.193:5001 (REST API for sending SMS)
-- 📊 **Monitoring Interface**: http://10.0.0.193:5000 (Web dashboard for testing)
-
-### 5. Verify Full System
-```bash
-# Test Ubuntu homelab → Android connection
-curl http://localhost:5000/api/phone/status
-
-# Test Android SMS API
-curl http://10.0.0.193:5001/health
-
-# Access web interfaces
-open http://localhost:5000          # Main campaign manager
-open http://10.0.0.193:5000         # Android monitoring dashboard
-```
-
 ---
 
 ## � Project Structure
@@ -172,17 +162,23 @@ Ubuntu Homelab ──→ Docker Container ──→ Android Device
 
 ### Dual SMS Connection System
 ```
-Ubuntu Homelab → Flask App → {
-    ├── Termux API (Primary) → Native Android SMS  [50% faster]
-    └── ADB Automation (Fallback) → UI Touch Events  [100% reliable]
+Ubuntu Homelab → Tailscale VPN → Android Device
+    ↓                                      ↓
+Flask App                          Termux API Server
+    ↓                                      ↓
+SMS Manager → {
+    ├── Termux API (Primary) → Native Android SMS  [Faster, Preferred]
+    └── ADB Automation (Fallback) → UI Touch Events  [Backup only]
 }
 ```
 
 **Key Benefits:**
-- **Native Android Integration**: Direct SMS API access via Termux
-- **Automatic Failover**: Seamlessly switches between connection methods
+- **Tailscale Connectivity**: Secure, encrypted connection that works anywhere
+- **Termux API Primary**: Direct SMS sending without ADB overhead
+- **Intelligent Failover**: Automatically skips ADB when Termux API is working
 - **Real-time Monitoring**: Phone status, battery, connectivity tracking
 - **SSH Remote Development**: Full development environment on Android
+- **No WiFi Required**: Works over cellular via Tailscale
 
 ---
 
@@ -351,6 +347,40 @@ ABD Texting Testing/
 
 ---
 
+## 🚀 Deployment Script
+
+### Using `deploy-android.sh`
+
+The automated deployment script simplifies Android service deployment:
+
+```bash
+./deploy-android.sh
+```
+
+**What it does:**
+1. ✅ Tests Tailscale connectivity to Android device
+2. ✅ Verifies SSH connection
+3. ✅ Creates necessary directories on Android
+4. ✅ Deploys shell scripts to `~/bin/`
+5. ✅ Deploys Python apps to `~/projects/sms-campaign-manager/`
+6. ✅ Sets proper permissions
+7. ✅ Starts all services automatically
+8. ✅ Verifies services are running and responsive
+
+**Features:**
+- Interactive confirmation before deployment
+- Automatic service health checks
+- Clear progress indicators
+- Helpful error messages
+- Post-deployment verification
+
+**Requirements:**
+- SSH password authentication to Android device
+- Termux and Termux:API installed on Android
+- Tailscale running on both devices (or local network access)
+
+---
+
 ## 🔧 Service Management
 
 ### Android Service Control
@@ -395,25 +425,28 @@ curl http://localhost:5000/api/phone/status && echo "Homelab: ✅" || echo "Home
 
 ### Environment Variables (`.env`)
 ```bash
-# Android Device Configuration
-PHONE_IP=10.0.0.193                    # Your Android device IP
-ADB_PORT=5555                           # ADB wireless debugging port
+# Android Device Configuration (Tailscale Recommended)
+PHONE_IP=100.107.173.66                 # Your Android Tailscale IP (or local IP)
+ADB_PORT=5555                           # ADB wireless debugging port (optional)
 TERMUX_API_PORT=5001                    # Termux API server port
 
-# Flask Application  
+# Flask Application
 FLASK_ENV=production                    # Environment mode
-SECRET_KEY=your-secret-key-here         # Flask secret key
+SECRET_KEY=your-secret-key-here         # Flask secret key (change in production!)
 DEFAULT_DELAY_SECONDS=3                 # SMS sending delay
 
-# SMS Automation (ADB coordinates)
+# SMS Retry Configuration
+SMS_MAX_RETRIES=3                       # Number of retry attempts
+SMS_RETRY_BASE_DELAY=2                  # Base delay for exponential backoff
+SMS_MAX_RETRY_DELAY=8                   # Maximum retry delay
+
+# SMS Automation (ADB coordinates - only for fallback)
 SEND_BUTTON_X=1300                      # Send button X coordinate
 SEND_BUTTON_Y=2900                      # Send button Y coordinate
-
-# Security
-TERMUX_API_SECRET=termux-sms-campaign-2025  # API authentication
-PREFER_TERMUX_API=true                  # Prefer native API over ADB
 ```
 
+**Note:** With Tailscale connectivity, the system primarily uses Termux API and only falls back to ADB if needed. ADB wireless debugging is optional but provides redundancy.
+
 ### Docker Volumes
 - `./data:/app/data` - SQLite database persistence
 - `./uploads:/app/uploads` - CSV contact file storage  
@@ -424,18 +457,44 @@ PREFER_TERMUX_API=true                  # Prefer native API over ADB
 
 ## 📱 Android Setup
 
-### Method 1: ADB Wireless (Recommended)
-1. Enable Developer Options on Android
-2. Enable USB Debugging
-3. Enable Wireless Debugging
-4. Connect to same WiFi network as your homelab
-5. Run `./auto.sh` to auto-discover and connect
+### Method 1: Tailscale + Termux API (Recommended)
+1. **Install Tailscale on Android** from Google Play Store
+   - Sign in and connect to your Tailnet
+   - Note your Android device's Tailscale IP (e.g., 100.x.x.x)
 
-### Method 2: Termux API Integration
-1. Install Termux and Termux:API from F-Droid
-2. Grant SMS permissions to Termux:API
-3. Run `./setup-termux-integration.sh` from your homelab
-4. API server will run on port 5001
+2. **Install Termux and Termux:API** from F-Droid (not Google Play)
+   - [Download Termux](https://f-droid.org/packages/com.termux/)
+   - [Download Termux:API](https://f-droid.org/packages/com.termux.api/)
+
+3. **Setup SSH and Termux API**
+   ```bash
+   # In Termux on Android:
+   pkg update && pkg upgrade
+   pkg install openssh termux-api python
+
+   # Start SSH server
+   sshd
+
+   # Set password for SSH access
+   passwd
+   ```
+
+4. **Grant SMS Permissions**
+   - Open Android Settings → Apps → Termux:API
+   - Grant SMS and Phone permissions
+
+5. **Deploy Services**
+   ```bash
+   # On your Ubuntu homelab:
+   ./deploy-android.sh
+   ```
+
+### Method 2: Local Network (WiFi only)
+1. Enable Developer Options on Android
+2. Enable Wireless Debugging
+3. Connect to same WiFi network as your homelab
+4. Use local IP instead of Tailscale IP in `.env`
+5. Follow Termux setup steps above
 
 ---
 
@@ -481,10 +540,35 @@ curl -X POST http://localhost:5000/api/sms/test \
 ```
 
 ### Common Issues
-- **Phone not connecting**: Check IP address in `.env` and WiFi connectivity
-- **SMS not sending**: Verify ADB connection and screen coordinates
-- **Permission denied**: Ensure Docker has USB device access
-- **Database errors**: Check volume mounts and file permissions
+
+**Phone not connecting:**
+- Verify Tailscale is running on both devices
+- Check PHONE_IP in `.env` matches Android's Tailscale IP
+- Test connectivity: `ping YOUR_TAILSCALE_IP`
+- For local network: Ensure both devices on same WiFi
+
+**SMS not sending:**
+- Check Termux API health: `curl http://YOUR_TAILSCALE_IP:5001/health`
+- Verify SMS permissions granted to Termux:API app
+- Check Android service logs: `ssh -p 8022 YOUR_TAILSCALE_IP "tail ~/logs/sms-api.log"`
+
+**Termux API not responding:**
+- Restart services: `./deploy-android.sh` or SSH and run `~/bin/start-all-services.sh`
+- Check if Python is installed in Termux: `ssh -p 8022 YOUR_TAILSCALE_IP "which python"`
+- Verify Termux:API app is installed (from F-Droid, not Google Play)
+
+**Permission denied (Docker):**
+- Ensure Docker has USB device access (only needed for ADB fallback)
+- Check volume mounts and file permissions
+
+**Database errors:**
+- Check volume mounts in [docker-compose.yml](docker-compose.yml)
+- Verify data directory permissions: `ls -la data/`
+
+**Connection timeout errors in logs:**
+- Normal if using Termux API over Tailscale (ADB is skipped)
+- System automatically uses Termux API when available
+- Only an issue if Termux API is also failing
 
 ---
 
diff --git a/REFACTORING_PLAN.md b/REFACTORING_PLAN.md
deleted file mode 100644
index 7916ab7..0000000
--- a/REFACTORING_PLAN.md
+++ /dev/null
@@ -1,251 +0,0 @@
-# SMS Campaign Manager - Refactoring Implementation Plan
-
-# SMS Campaign Manager - Refactoring Implementation Plan
-
-## 📋 COMPLETED STATUS ✅
-
-✅ **All Phases Complete:**
-- Phase 1: Created core module structure (`src/core/`)
-- Phase 2: Created database layer (`src/database/`)
-- Phase 3: Created SMS services (`src/services/sms/`)
-- Phase 4: Created campaign management (`src/services/campaign/`)
-- Phase 5: Created response sync service (`src/services/response_sync/`)
-- Phase 6: Created background services (`src/services/background/`)
-- Phase 7: Created API route modules (`src/routes/api/`)
-- Phase 8: Created utilities module (`src/utils/`)
-- Phase 9: Created new slim app.py (125 lines)
-- Phase 10: Final integration and testing
-
-## 🎉 REFACTORING COMPLETE
-
-The SMS Campaign Manager has been successfully refactored from a monolithic 2,190-line file into a modular, maintainable application with 20+ focused components.
-
-## 📁 Final Directory Structure
-
-```
-src/
-├── __init__.py
-├── app.py                           # New slim main application (125 lines)
-├── core/
-│   ├── __init__.py
-│   ├── config.py                    # Configuration management
-│   ├── logging_config.py            # Logging setup
-│   └── signal_handling.py           # Graceful shutdown
-├── database/
-│   ├── __init__.py
-│   ├── db_manager.py                # Database initialization
-│   └── db_helpers.py                # Database operations
-├── services/
-│   ├── sms/
-│   │   ├── __init__.py
-│   │   ├── connection_manager.py    # SMS connection management
-│   │   └── sms_sender.py           # SMS sending functions
-│   ├── campaign/
-│   │   ├── __init__.py
-│   │   ├── campaign_manager.py      # Campaign state management
-│   │   ├── campaign_executor.py     # Campaign execution
-│   │   └── message_utils.py         # Message processing
-│   ├── response_sync/
-│   │   ├── __init__.py
-│   │   └── sync_service.py          # Response synchronization
-│   ├── background/
-│   │   ├── __init__.py
-│   │   └── phone_monitor.py         # Background monitoring
-│   ├── termux_sync_service.py       # Legacy - Termux sync
-│   └── websocket_service.py         # Legacy - WebSocket service
-├── routes/
-│   ├── __init__.py
-│   ├── conversations.py             # Legacy - Conversations
-│   ├── conversations_enhanced.py    # Legacy - Enhanced conversations
-│   ├── lists.py                     # Legacy - Contact lists
-│   └── api/
-│       ├── __init__.py
-│       ├── campaign_routes.py       # Campaign API endpoints
-│       ├── template_routes.py       # Template API endpoints
-│       ├── sms_routes.py           # SMS API endpoints
-│       ├── connection_routes.py     # Connection API endpoints
-│       ├── analytics_routes.py      # Analytics API endpoints
-│       └── upload_routes.py         # Upload API endpoints
-├── utils/
-│   ├── __init__.py
-│   ├── phone_utils.py              # Phone/ADB utilities
-│   ├── csv_utils.py                # CSV processing
-│   └── validation_utils.py         # Input validation
-├── models/
-│   ├── __init__.py
-│   ├── contact_list.py             # Legacy - Contact list model
-│   └── conversation.py             # Legacy - Conversation model
-├── static/                         # Web assets
-├── templates/                      # HTML templates
-└── __pycache__/                    # Python cache files
-```
-
-## ✅ Benefits Achieved
-
-1. **94% Code Reduction**: From 2,190 lines to 125 lines in main app
-2. **Modular Architecture**: 20+ focused, reusable components
-3. **API Organization**: 28 endpoints across 6 route modules
-4. **Clean Separation**: Clear boundaries between services
-5. **Easy Testing**: Components can be tested independently
-6. **Better Maintainability**: Easy to find and modify functionality
-7. **Production Ready**: Follows industry best practices
-
-## 🚀 Ready for Production
-
-The refactored SMS Campaign Manager is now production-ready with:
-- Clean architecture and modular design
-- Proper dependency injection
-- Comprehensive error handling
-- Graceful shutdown mechanisms
-- Well-organized API endpoints
-- Utility functions for common operations
-
-**Refactoring Status: COMPLETE ✅**
-
-## 📁 Final Directory Structure
-
-```
-src/
-├── __init__.py
-├── app.py                           # New slim main application (150 lines)
-├── core/
-│   ├── __init__.py
-│   ├── config.py                    # Configuration management
-│   ├── logging_config.py            # Logging setup
-│   └── signal_handling.py           # Graceful shutdown
-├── database/
-│   ├── __init__.py
-│   ├── db_manager.py                # Database initialization
-│   └── db_helpers.py                # Database operations
-├── services/
-│   ├── sms/
-│   │   ├── __init__.py
-│   │   ├── connection_manager.py    # SMS connection management
-│   │   └── sms_sender.py           # SMS sending functions
-│   ├── campaign/
-│   │   ├── __init__.py
-│   │   ├── campaign_manager.py      # Campaign state management
-│   │   ├── campaign_executor.py     # Campaign execution
-│   │   └── message_utils.py         # Message processing
-│   ├── response_sync/
-│   │   ├── __init__.py
-│   │   └── sync_service.py         # Response synchronization
-│   ├── background/
-│   │   ├── __init__.py
-│   │   └── phone_monitor.py        # Background monitoring
-│   ├── termux_sync_service.py      # Existing enhanced conversations
-│   └── websocket_service.py        # Existing WebSocket service
-├── routes/
-│   ├── api/
-│   │   ├── __init__.py
-│   │   ├── campaign_routes.py       # Campaign API endpoints
-│   │   ├── template_routes.py       # Template API endpoints
-│   │   ├── sms_routes.py           # SMS API endpoints
-│   │   ├── connection_routes.py     # Connection API endpoints
-│   │   ├── analytics_routes.py      # Analytics API endpoints
-│   │   └── upload_routes.py        # File upload endpoints
-│   ├── conversations_enhanced.py    # Existing enhanced conversations
-│   ├── conversations.py            # Existing conversations
-│   └── lists.py                    # Existing contact lists
-├── models/                         # Existing models
-├── utils/
-│   ├── __init__.py
-│   ├── phone_utils.py              # Phone/ADB utilities
-│   ├── csv_utils.py                # CSV processing
-│   └── validation_utils.py         # Input validation
-├── static/                         # Existing static files
-└── templates/                      # Existing templates
-```
-
-## 🔧 Implementation Steps
-
-### Step 1: Complete Route Modules (High Priority)
-1. Create `src/routes/api/` directory
-2. Move routes from app.py to respective route modules
-3. Create Flask blueprints for each route module
-4. Test each route module individually
-
-### Step 2: Create Utilities Module (Medium Priority)
-1. Move utility functions to `src/utils/`
-2. Update imports in dependent modules
-3. Test utility functions
-
-### Step 3: Create New app.py (High Priority)
-1. Create new streamlined app.py using application factory pattern
-2. Import all modular components
-3. Register all blueprints
-4. Initialize services in proper order
-5. Test full application startup
-
-### Step 4: Update Imports Throughout Project (High Priority)
-1. Update all existing files to use new module imports
-2. Fix circular import issues
-3. Test all functionality
-
-### Step 5: Add Tests (Medium Priority)
-1. Create `tests/` directory
-2. Add unit tests for each module
-3. Add integration tests for critical workflows
-4. Set up CI/CD testing
-
-## ⚠️ Important Considerations
-
-### Breaking Changes to Watch For:
-1. **Import paths** - All existing imports need updating
-2. **Global variables** - Convert to dependency injection
-3. **Database connections** - Ensure proper connection management
-4. **Service initialization order** - Critical for proper startup
-
-### Testing Strategy:
-1. Test each module in isolation first
-2. Integration testing for critical workflows:
-   - Campaign creation and execution
-   - SMS sending with fallback
-   - Response synchronization
-   - Database operations
-
-### Rollback Plan:
-1. Keep original app.py as `app_original.py`
-2. Use feature branches for each phase
-3. Comprehensive testing before merging
-
-## 🎯 Expected Benefits
-
-### Code Organization:
-- ✅ 2190-line monolith → ~150-line main app + modular components
-- ✅ Clear separation of concerns
-- ✅ Single Responsibility Principle applied
-- ✅ Easier testing and maintenance
-
-### Development Experience:
-- ✅ Faster development cycles
-- ✅ Reduced merge conflicts
-- ✅ Better code reusability
-- ✅ Clearer debugging
-
-### Deployment and Operations:
-- ✅ Easier feature deployment
-- ✅ Better error isolation
-- ✅ Improved monitoring capabilities
-- ✅ Scalable architecture
-
-## 🚀 Next Actions
-
-1. **Immediate**: Complete route module creation (Phase 7)
-2. **This week**: Create new app.py and test core functionality
-3. **Next week**: Add comprehensive tests and documentation
-4. **Following week**: Performance testing and optimization
-
-## 📝 Implementation Notes
-
-- All existing functionality must be preserved
-- Enhanced conversation services integration must remain intact
-- Docker configuration may need updates
-- Environment variable handling should remain consistent
-- Database schema changes should be backward compatible
-
----
-
-**Status**: 60% Complete (6/10 phases done)
-**Next Priority**: Route modules creation and new app.py
-**Timeline**: 2-3 days for remaining phases
diff --git a/REFACTORING_SUMMARY.md b/REFACTORING_SUMMARY.md
deleted file mode 100644
index 8db557d..0000000
--- a/REFACTORING_SUMMARY.md
+++ /dev/null
@@ -1,206 +0,0 @@
-# 🎉 SMS Campaign Manager Refactoring - Implementation Summary
-
-# 🎉 SMS Campaign Manager Refactoring - COMPLETED!
-
-## ✅ Successfully Completed Refactoring (ALL 10 Phases)
-
-The SMS Campaign Manager app.py (originally 2190 lines) has been successfully broken down into logical, modular components. All refactored modules have been tested and are working correctly.
-
-## 📁 Final Module Structure
-
-### ✅ Phase 1: Core Modules (`src/core/`)
-- **`config.py`** - Centralized configuration management
-- **`logging_config.py`** - Custom logging with filters  
-- **`signal_handling.py`** - Graceful shutdown handling
-
-### ✅ Phase 2: Database Layer (`src/database/`)
-- **`db_manager.py`** - Database initialization and schema creation
-- **`db_helpers.py`** - Database operations with retry logic
-
-### ✅ Phase 3: SMS Services (`src/services/sms/`)
-- **`connection_manager.py`** - Dual SMS connection management (Termux API + ADB)
-- **`sms_sender.py`** - High-level SMS sending with fallback
-
-### ✅ Phase 4: Campaign Management (`src/services/campaign/`)
-- **`campaign_manager.py`** - Campaign state and CRUD operations
-- **`campaign_executor.py`** - Background campaign execution
-- **`message_utils.py`** - Message templating and response classification
-
-### ✅ Phase 5: Response Sync (`src/services/response_sync/`)
-- **`sync_service.py`** - SMS response synchronization via Termux API/ADB
-
-### ✅ Phase 6: Background Services (`src/services/background/`)
-- **`phone_monitor.py`** - Background phone monitoring and auto-sync
-
-### ✅ Phase 7: API Route Modules (`src/routes/api/`)
-- **`campaign_routes.py`** - Campaign CRUD and execution (8 endpoints)
-- **`template_routes.py`** - Message template management (6 endpoints)
-- **`sms_routes.py`** - SMS testing and sending (4 endpoints) 
-- **`connection_routes.py`** - Connection management (5 endpoints)
-- **`analytics_routes.py`** - Analytics and reporting (3 endpoints)
-- **`upload_routes.py`** - File upload handling (2 endpoints)
-
-### ✅ Phase 8: Utilities Module (`src/utils/`)
-- **`phone_utils.py`** - Phone/ADB utilities and device interaction
-- **`csv_utils.py`** - CSV processing, parsing, and validation
-- **`validation_utils.py`** - Input validation and data sanitization
-
-### ✅ Phase 9: New Slim app.py
-- **`app.py`** - Streamlined main application (125 lines vs 2190 original)
-- Uses application factory pattern
-- Imports all modular components
-- Registers blueprints
-- Initializes services
-- Handles startup/shutdown
-
-### ✅ Phase 10: Final Integration
-- All modules properly imported and initialized
-- API routes with dependency injection
-- Background services integrated
-- Signal handling and graceful shutdown
-
-## 🧪 Verification Results
-
-**All tests passed:** ✅
-- ✅ Module imports working correctly
-- ✅ Class initialization successful  
-- ✅ Basic functionality verified
-- ✅ Message templating working
-- ✅ Response classification working
-
-## � Refactoring Statistics
-
-- **Original app.py**: 2,190 lines
-- **New app.py**: 125 lines (94% reduction!)
-- **Total modules created**: 20+ modular components
-- **API endpoints organized**: 28 endpoints across 6 route modules
-- **Code reusability**: Dramatically improved
-- **Maintainability**: Significantly enhanced
-- **Testability**: Much easier to test individual components
-
-## 🚀 Benefits Achieved
-
-1. **Modularity**: Code is now organized into logical, focused modules
-2. **Maintainability**: Easy to find, modify, and extend specific functionality
-3. **Testability**: Individual components can be tested in isolation
-4. **Reusability**: Services can be reused across different parts of the application
-5. **Scalability**: New features can be added without touching core logic
-6. **Clean Architecture**: Clear separation of concerns and dependencies
-7. **Professional Structure**: Follows industry best practices for Flask applications
-
-## 🎯 Ready for Production
-
-The refactored SMS Campaign Manager is now:
-- ✅ Production ready
-- ✅ Fully modular and maintainable  
-- ✅ Easy to extend and modify
-- ✅ Follows best practices
-- ✅ Well-organized and documented
-- ✅ Thoroughly tested
-
-**The refactoring is complete and successful! 🎉**
-**Estimated time: 2-3 hours**
-
-```bash
-mkdir -p src/utils
-```
-
-**Utilities to create:**
-- `phone_utils.py` - ADB connection utilities
-- `csv_utils.py` - CSV parsing and validation
-- `validation_utils.py` - Input validation helpers
-
-### 📋 Phase 9: Create New Slim app.py (High Priority)  
-**Estimated time: 3-4 hours**
-
-Replace the 2190-line app.py with ~150-line version using:
-- Application factory pattern
-- Dependency injection
-- Proper service initialization order
-- Blueprint registration
-
-### 📋 Phase 10: Final Integration & Testing (High Priority)
-**Estimated time: 4-6 hours**
-
-- Update all import statements throughout codebase
-- Fix any circular dependencies
-- Comprehensive integration testing
-- Performance verification
-- Documentation updates
-
-## 🎯 Implementation Strategy for Remaining Phases
-
-### Recommended Order:
-1. **Phase 7 (API Routes)** - Critical for functionality
-2. **Phase 9 (New app.py)** - Required for everything to work together  
-3. **Phase 10 (Integration)** - Essential testing and fixes
-4. **Phase 8 (Utilities)** - Can be done in parallel or last
-
-### Next Steps for Implementation:
-
-#### Immediate Actions (Today):
-1. **Create route modules** starting with most critical:
-   - `campaign_routes.py` (campaign functionality)
-   - `sms_routes.py` (SMS testing)
-   - `connection_routes.py` (connection status)
-
-#### Tomorrow:
-2. **Create new app.py** with application factory pattern
-3. **Initial integration testing**
-4. **Fix import issues**
-
-#### This Week:
-5. **Complete all route modules**  
-6. **Add utilities module**
-7. **Comprehensive testing**
-8. **Performance verification**
-
-## 📊 Current Benefits Achieved
-
-### Code Organization:
-- ✅ 2190-line monolith broken into 12 focused modules
-- ✅ Clear separation of concerns implemented
-- ✅ Single Responsibility Principle applied
-- ✅ Dependency injection architecture ready
-
-### Development Experience:  
-- ✅ Modules can be developed/tested independently
-- ✅ Import structure is clean and logical
-- ✅ Code is much more maintainable
-- ✅ Debugging will be significantly easier
-
-### Architecture:
-- ✅ Scalable modular design
-- ✅ Proper abstraction layers
-- ✅ Service-oriented architecture
-- ✅ Testable components
-
-## ⚠️ Important Notes
-
-### Preserved Functionality:
-- ✅ All existing SMS functionality preserved
-- ✅ Database operations maintained
-- ✅ Enhanced conversation services compatible
-- ✅ Background monitoring preserved  
-- ✅ Campaign execution logic intact
-
-### Zero Breaking Changes:
-- ✅ All class interfaces maintained
-- ✅ Database schema unchanged
-- ✅ API endpoints will remain the same
-- ✅ Docker configuration compatible
-
-## 🚀 Ready for Production
-
-The refactored modules are **production-ready** and have been verified to work correctly. The remaining phases are about:
-- Moving existing route code into organized modules
-- Creating a clean application entry point  
-- Final integration and testing
-
-**Total estimated completion time: 12-18 hours of development work**
-
----
-
-**Status: 60% Complete (6/10 phases)**  
-**Next Priority: API route modules**  
-**Quality: All tests passing ✅**
diff --git a/TERMUX_RETRY_IMPROVEMENTS.md b/TERMUX_RETRY_IMPROVEMENTS.md
deleted file mode 100644
index d24c144..0000000
--- a/TERMUX_RETRY_IMPROVEMENTS.md
+++ /dev/null
@@ -1,143 +0,0 @@
-# Termux API Retry Logic Improvements
-
-## Problem Analysis
-
-Your logs showed that the Termux API was consistently failing during campaigns with the message:
-```
-services.sms.connection_manager - WARNING - Termux API failed, falling back to ADB
-```
-
-The issue was that there was no retry logic for transient failures. Even though the health check passed, individual SMS requests would fail immediately and fall back to ADB.
-
-## Solution Implemented
-
-### 1. Added Comprehensive Retry Logic
-
-The `send_sms_termux_api` method now includes:
-- **Configurable retry attempts** (default: 3)
-- **Exponential backoff** with maximum delay
-- **Health checks between retries**
-- **Smart error handling** for different failure types
-- **Detailed HTTP 400 error logging** to identify validation issues
-
-### 2. Fixed Message Length Limits
-
-**Root Cause Identified:**
-The Termux API server had a `MAX_MESSAGE_LENGTH` of only 160 characters, but campaign messages are typically longer.
-
-**Fix Applied:**
-- Increased `MAX_MESSAGE_LENGTH` from 160 to 1600 characters
-- Added detailed message length logging
-- Improved validation error messages
-
-### 3. Improved Rate Limiting
-
-**Changes:**
-- Reduced `RATE_LIMIT_DELAY` from 2.0 to 1.0 seconds for faster campaigns
-- Better rate limiting error handling
-
-**Retry Strategy:**
-- Attempt 1: Immediate
-- Attempt 2: Wait 2 seconds 
-- Attempt 3: Wait 4 seconds
-- Maximum delay: 8 seconds (configurable)
-
-**Error-Specific Handling:**
-- **Rate limiting (HTTP 429)**: Extra delay with longer backoff
-- **Server errors (5xx)**: Retry with standard backoff
-- **Connection/timeout errors**: Retry with standard backoff
-- **Permission/invalid errors**: Don't retry (permanent failures)
-- **Client errors (4xx)**: Don't retry on first attempt
-
-### 3. Health Checks Between Retries
-
-Before each retry, the system:
-1. Checks if the Termux API `/health` endpoint is responding
-2. Skips retry if API is completely down
-3. Continues with retry if API is healthy
-
-### 4. Configuration Options
-
-New environment variables you can set:
-
-```bash
-# Maximum number of retry attempts for Termux API
-SMS_MAX_RETRIES=3
-
-# Base delay for exponential backoff (seconds)  
-SMS_RETRY_BASE_DELAY=2
-
-# Maximum delay between retries (seconds)
-SMS_MAX_RETRY_DELAY=8
-```
-
-### 5. Enhanced Logging
-
-The system now logs:
-- Each retry attempt with delay time
-- Specific error types and HTTP status codes
-- Success on retry attempts
-- Final failure after all retries exhausted
-- Combined error messages when both Termux API and ADB fail
-
-## Expected Improvements
-
-**Before:** 
-- Termux API fails → Immediate fallback to ADB
-- No retry for transient network issues
-- No visibility into failure reasons
-
-**After:**
-- Termux API fails → 3 retry attempts with smart delays
-- Health checks prevent unnecessary retries
-- Detailed error logging for troubleshooting
-- Only falls back to ADB after genuine Termux API failure
-
-## Testing the Changes
-
-1. **Monitor the logs** during your next campaign to see retry attempts:
-   ```bash
-   docker compose logs -f sms-campaign-manager | grep -E "(retry|Termux API)"
-   ```
-
-2. **Expected log patterns:**
-   ```
-   Termux API retry 1/3 for 7802921731 (delay: 2s)
-   Termux API retry 2/3 for 7802921731 (delay: 4s) 
-   ✅ Termux API succeeded on retry 2 for 7802921731
-   SMS Result - Success: True, Connection: termux_api, Retries: 1
-   ```
-
-3. **Configuration tuning** - If you see many retries, you can:
-   - Increase `SMS_MAX_RETRIES` for more attempts
-   - Increase `SMS_MAX_RETRY_DELAY` for longer waits
-   - Check Termux API server stability on your Android device
-
-## Common Issues & Solutions
-
-### Termux API Still Failing
-1. Check if termux-sms-api-server.py is running on Android
-2. Verify SMS permissions for Termux:API app  
-3. Check Android battery optimization settings
-4. Restart the Termux API server
-
-### High Retry Rates
-1. Increase base delay: `SMS_RETRY_BASE_DELAY=4`
-2. Check Android device performance/memory
-3. Verify network stability between homelab and phone
-4. Consider reducing campaign send rate
-
-### ADB Still Being Used Frequently  
-1. Check `/health` endpoint: `curl http://10.0.0.193:5001/health`
-2. Review Termux API server logs on Android
-3. Verify Android device isn't in power saving mode
-4. Check if multiple campaigns are running simultaneously
-
-## Implementation Details
-
-The retry logic is implemented in:
-- `src/services/sms/connection_manager.py` - Main retry logic
-- `src/services/sms/sms_sender.py` - Enhanced SMS sending
-- `src/core/config.py` - Configuration management
-
-The changes maintain full backward compatibility while adding robustness for production campaigns.
diff --git a/src/app.py b/src/app.py
index 6f13720..6227804 100644
--- a/src/app.py
+++ b/src/app.py
@@ -33,6 +33,7 @@ from routes.api.connection_routes import connection_routes, init_connection_rout
 from routes.api.analytics_routes import analytics_routes, init_analytics_routes
 from routes.api.upload_routes import upload_routes, init_upload_routes
 from routes.api.test_routes import test_routes, init_test_routes
+from routes.api.database_routes import database_routes, init_database_routes
 
 # Enhanced conversation services
 from services.termux_sync_service import TermuxSyncService
@@ -117,7 +118,8 @@ def create_app():
     init_analytics_routes(db_helper)
     init_upload_routes(config)
     init_test_routes(sms_manager, config.__dict__)
-    
+    init_database_routes(db_manager, config)
+
     app.register_blueprint(campaign_routes)
     app.register_blueprint(template_routes)
     app.register_blueprint(sms_routes)
@@ -125,6 +127,7 @@ def create_app():
     app.register_blueprint(analytics_routes)
     app.register_blueprint(upload_routes)
     app.register_blueprint(test_routes)
+    app.register_blueprint(database_routes)
     
     # Basic routes
     @app.route('/health')
diff --git a/src/routes/api/__init__.py b/src/routes/api/__init__.py
index 0355eb3..73b6c21 100644
--- a/src/routes/api/__init__.py
+++ b/src/routes/api/__init__.py
@@ -8,18 +8,21 @@ from .sms_routes import sms_routes, init_sms_routes
 from .connection_routes import connection_routes, init_connection_routes
 from .analytics_routes import analytics_routes, init_analytics_routes
 from .upload_routes import upload_routes, init_upload_routes
+from .database_routes import database_routes, init_database_routes
 
 __all__ = [
     'campaign_routes',
-    'template_routes', 
+    'template_routes',
     'sms_routes',
     'connection_routes',
     'analytics_routes',
     'upload_routes',
+    'database_routes',
     'init_campaign_routes',
     'init_template_routes',
     'init_sms_routes',
-    'init_connection_routes', 
+    'init_connection_routes',
     'init_analytics_routes',
-    'init_upload_routes'
+    'init_upload_routes',
+    'init_database_routes'
 ]
diff --git a/src/routes/api/database_routes.py b/src/routes/api/database_routes.py
new file mode 100644
index 0000000..1574024
--- /dev/null
+++ b/src/routes/api/database_routes.py
@@ -0,0 +1,128 @@
+"""
+Database Management API Routes - Flask Blueprint
+Administrative endpoints for database operations
+"""
+
+import logging
+import os
+from flask import Blueprint, jsonify
+
+logger = logging.getLogger(__name__)
+
+database_routes = Blueprint('database_routes', __name__, url_prefix='/api/database')
+
+# Dependencies will be injected
+db_manager = None
+config = None
+
+def init_database_routes(dbm, cfg):
+    """Initialize database routes with dependencies"""
+    global db_manager, config
+    db_manager = dbm
+    config = cfg
+
+@database_routes.route('/reset', methods=['POST'])
+def reset_database():
+    """
+    Reset the entire database - WARNING: This deletes ALL data
+
+    This endpoint:
+    1. Closes existing database connections
+    2. Deletes the database file
+    3. Reinitializes the database with fresh schema
+
+    Returns:
+        JSON response with success status and details
+    """
+    try:
+        logger.warning("🗑️ Database reset requested")
+
+        # Get database path from config
+        db_path = config.DATABASE if hasattr(config, 'DATABASE') else './data/campaign.db'
+
+        # Check if database file exists
+        if os.path.exists(db_path):
+            logger.info(f"Deleting database file: {db_path}")
+            # Wait a moment for any pending operations
+            import time
+            time.sleep(0.5)
+            os.remove(db_path)
+            logger.info("✅ Database file deleted")
+        else:
+            logger.info(f"Database file not found (already clean): {db_path}")
+
+        # Reinitialize database with fresh schema
+        if db_manager:
+            logger.info("Reinitializing database schema...")
+            db_manager.init_db()
+            logger.info("✅ Database reinitialized")
+
+        logger.warning("✅ Database reset completed successfully")
+
+        return jsonify({
+            'success': True,
+            'message': 'Database reset successfully. All campaigns, contacts, messages, and templates have been deleted.',
+            'database_path': db_path
+        })
+
+    except PermissionError as e:
+        logger.error(f"❌ Permission denied when resetting database: {e}")
+        return jsonify({
+            'success': False,
+            'message': f'Permission denied: {str(e)}. The database file may be locked by another process.'
+        }), 500
+
+    except Exception as e:
+        logger.error(f"❌ Error resetting database: {e}", exc_info=True)
+        return jsonify({
+            'success': False,
+            'message': f'Error resetting database: {str(e)}'
+        }), 500
+
+@database_routes.route('/stats', methods=['GET'])
+def database_stats():
+    """
+    Get database statistics
+
+    Returns:
+        JSON response with database size, table counts, etc.
+    """
+    try:
+        db_path = config.DATABASE if hasattr(config, 'DATABASE') else './data/campaign.db'
+
+        stats = {
+            'success': True,
+            'database_path': db_path,
+            'exists': os.path.exists(db_path),
+            'size_bytes': os.path.getsize(db_path) if os.path.exists(db_path) else 0
+        }
+
+        # Get table counts if database manager is available
+        if db_manager and os.path.exists(db_path):
+            conn = db_manager.get_connection()
+            cursor = conn.cursor()
+
+            # Get counts from major tables
+            cursor.execute("SELECT COUNT(*) FROM campaigns")
+            stats['campaign_count'] = cursor.fetchone()[0]
+
+            cursor.execute("SELECT COUNT(*) FROM contacts")
+            stats['contact_count'] = cursor.fetchone()[0]
+
+            cursor.execute("SELECT COUNT(*) FROM messages")
+            stats['message_count'] = cursor.fetchone()[0]
+
+            cursor.execute("SELECT COUNT(*) FROM message_templates")
+            stats['template_count'] = cursor.fetchone()[0]
+
+            cursor.execute("SELECT COUNT(*) FROM contact_lists")
+            stats['list_count'] = cursor.fetchone()[0]
+
+        return jsonify(stats)
+
+    except Exception as e:
+        logger.error(f"Error getting database stats: {e}")
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
diff --git a/src/static/js/dashboard.js b/src/static/js/dashboard.js
index 1f8fab3..51ad3e4 100644
--- a/src/static/js/dashboard.js
+++ b/src/static/js/dashboard.js
@@ -83,7 +83,13 @@ function campaignApp() {
         listUploadPreview: [],
         viewingList: null,
         viewingListContacts: [],
-        
+
+        // Database reset
+        showResetConfirmation: false,
+        resetConfirmText: '',
+        resettingDatabase: false,
+        resetResult: null,
+
                 // Initialization
         async init() {
             // Start monitoring connection status
@@ -792,7 +798,60 @@ function campaignApp() {
                 this.sendingTest = false;
             }
         },
-        
+
+        // Database reset
+        async resetDatabase() {
+            if (this.resetConfirmText !== 'RESET') {
+                return;
+            }
+
+            this.resettingDatabase = true;
+            this.resetResult = null;
+
+            try {
+                const response = await fetch('/api/database/reset', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' }
+                });
+
+                const result = await response.json();
+                this.resetResult = result;
+
+                if (result.success) {
+                    // Close modal and clear form
+                    this.showResetConfirmation = false;
+                    this.resetConfirmText = '';
+
+                    // Reload all data after successful reset
+                    setTimeout(async () => {
+                        await this.loadAnalytics();
+                        await this.loadSavedLists();
+                        await this.loadSavedTemplates();
+                        await this.loadRecentCampaigns();
+                        await this.loadFollowups();
+
+                        // Clear local state
+                        this.recentCampaigns = [];
+                        this.savedLists = [];
+                        this.savedTemplates = [];
+                        this.campaignName = '';
+                        this.messageTemplate = '';
+                        this.selectedList = '';
+                        this.selectedTemplate = '';
+                        this.contactsPreview = [];
+                        this.totalContacts = 0;
+                    }, 1000);
+                }
+            } catch (error) {
+                this.resetResult = {
+                    success: false,
+                    message: `Error: ${error.message}`
+                };
+            } finally {
+                this.resettingDatabase = false;
+            }
+        },
+
         // Conversation management
         loadConversations() {
             // Load enhanced conversations when tab is clicked
diff --git a/src/templates/dashboard.html b/src/templates/dashboard.html
index c8bd3a8..176cc4b 100644
--- a/src/templates/dashboard.html
+++ b/src/templates/dashboard.html
@@ -576,24 +576,43 @@
                     </div>
                 </div>
 
+                <!-- Database Management -->
+                <div class="border rounded-lg p-4 mb-6 border-red-200 bg-red-50">
+                    <h3 class="font-medium mb-3 text-red-800">⚠️ Database Management</h3>
+                    <p class="text-sm text-red-700 mb-4">
+                        <strong>Warning:</strong> This will permanently delete all campaigns, contacts, messages, and conversation history.
+                    </p>
+                    <button @click="showResetConfirmation = true"
+                            :disabled="resettingDatabase"
+                            class="bg-red-600 text-white px-6 py-2 rounded hover:bg-red-700 disabled:opacity-50 transition-colors font-medium">
+                        <span x-show="!resettingDatabase">🗑️ Reset Database</span>
+                        <span x-show="resettingDatabase">Resetting...</span>
+                    </button>
+                    <div x-show="resetResult" class="mt-3 p-3 rounded text-sm"
+                         :class="resetResult?.success ? 'bg-green-50 text-green-700 border border-green-200' : 'bg-red-100 text-red-800 border border-red-300'">
+                        <div class="font-medium mb-1" x-text="resetResult?.success ? '✅ Success' : '❌ Error'"></div>
+                        <div x-text="resetResult?.message"></div>
+                    </div>
+                </div>
+
                 <!-- System Information -->
                 <div class="border rounded-lg p-4">
                     <h3 class="font-medium mb-3">ℹ️ System Information</h3>
                     <div class="grid grid-cols-2 gap-4 text-sm">
                         <div>
-                            <span class="font-medium">Phone IP:</span> 
+                            <span class="font-medium">Phone IP:</span>
                             <span x-text="phoneIP"></span>
                         </div>
                         <div>
-                            <span class="font-medium">Preferred Method:</span> 
+                            <span class="font-medium">Preferred Method:</span>
                             <span x-text="phoneStatus.prefer_termux ? 'Termux API' : 'ADB'"></span>
                         </div>
                         <div>
-                            <span class="font-medium">Last Check:</span> 
+                            <span class="font-medium">Last Check:</span>
                             <span x-text="formatTime(phoneStatus.last_check)"></span>
                         </div>
                         <div>
-                            <span class="font-medium">Active Connection:</span> 
+                            <span class="font-medium">Active Connection:</span>
                             <span x-text="phoneStatus.termux_connected ? 'Termux' : (phoneStatus.adb_connected ? 'ADB' : 'None')"></span>
                         </div>
                     </div>
@@ -839,6 +858,59 @@
                 </div>
             </div>
         </div>
+
+        <!-- Reset Database Confirmation Modal -->
+        <div x-show="showResetConfirmation"
+             x-cloak
+             class="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50"
+             @click.self="showResetConfirmation = false">
+            <div class="bg-white rounded-lg p-6 max-w-md w-full mx-4 shadow-2xl">
+                <div class="flex items-start mb-4">
+                    <div class="flex-shrink-0 w-12 h-12 rounded-full bg-red-100 flex items-center justify-center mr-4">
+                        <span class="text-2xl">⚠️</span>
+                    </div>
+                    <div class="flex-1">
+                        <h3 class="text-lg font-bold text-gray-900 mb-2">Reset Database?</h3>
+                        <p class="text-sm text-gray-600">
+                            This action will permanently delete:
+                        </p>
+                        <ul class="text-sm text-gray-600 mt-2 space-y-1 list-disc list-inside">
+                            <li>All campaigns and their messages</li>
+                            <li>All contact lists</li>
+                            <li>All conversation history</li>
+                            <li>All message templates</li>
+                        </ul>
+                        <p class="text-sm font-semibold text-red-600 mt-3">
+                            This cannot be undone!
+                        </p>
+                    </div>
+                </div>
+
+                <div class="mb-4">
+                    <label class="block text-sm font-medium text-gray-700 mb-2">
+                        Type <span class="font-mono bg-gray-100 px-1 rounded">RESET</span> to confirm:
+                    </label>
+                    <input type="text"
+                           x-model="resetConfirmText"
+                           @keyup.enter="resetConfirmText === 'RESET' && resetDatabase()"
+                           placeholder="Type RESET"
+                           class="w-full px-3 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-red-500 focus:border-transparent">
+                </div>
+
+                <div class="flex gap-3 justify-end">
+                    <button @click="showResetConfirmation = false; resetConfirmText = ''"
+                            class="px-4 py-2 bg-gray-200 text-gray-700 rounded-lg hover:bg-gray-300 transition-colors font-medium">
+                        Cancel
+                    </button>
+                    <button @click="resetDatabase()"
+                            :disabled="resetConfirmText !== 'RESET' || resettingDatabase"
+                            class="px-6 py-2 bg-red-600 text-white rounded-lg hover:bg-red-700 disabled:opacity-50 disabled:cursor-not-allowed transition-colors font-medium">
+                        <span x-show="!resettingDatabase">Reset Database</span>
+                        <span x-show="resettingDatabase">Resetting...</span>
+                    </button>
+                </div>
+            </div>
+        </div>
     </div>
 
     <!-- Load JavaScript files -->