diff --git a/index.html b/index.html
index 836d44d..a26556b 100644
--- a/index.html
+++ b/index.html
@@ -7,6 +7,7 @@
 </head>
 <body>
     <h1>Hello...</h1>
+    <h1></h1>
     <p>This is a test page for the URL watcher.</p>
     <p>Last updated: <span id="timestamp"></span></p>
     <script>
diff --git a/readme.md b/readme.md
index b106e31..7a94b1a 100644
--- a/readme.md
+++ b/readme.md
@@ -5,7 +5,7 @@
 [![Coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)](https://github.com/smarks/watcher)
 [![Tests](https://img.shields.io/badge/tests-passing-green)](https://github.com/smarks/watcher/actions)
 [![Python](https://img.shields.io/badge/python-3.9+-blue)](https://python.org)
-[![AWS](https://img.shields.io/badge/aws-sns-orange)](https://aws.amazon.com/sns/)
+[![Twilio](https://img.shields.io/badge/twilio-sms-red)](https://twilio.com/sms) [![AWS](https://img.shields.io/badge/aws-sns-orange)](https://aws.amazon.com/sns/)
 
 **Perfect for beginners!** Monitor website changes, get SMS alerts, and learn Python automation. Written mostly by Claude AI under the careful direction of Spencer.
 
@@ -18,7 +18,7 @@ URL Watcher is like having a personal assistant that:
 - 📱 **Sends you SMS alerts** when something changes
 - 🔍 **Shows you exactly** what changed with before/after comparisons
 - ⏰ **Works 24/7** checking sites automatically
-- 🆓 **Costs almost nothing** to run (AWS SMS: ~$0.006 per message)
+- 🆓 **Costs almost nothing** to run (Twilio SMS: ~$0.0075 per message, AWS SMS: ~$0.006 per message)
 
 ## 🚀 5-Minute Quick Start
 
@@ -216,37 +216,39 @@ You'll see the change detection in Terminal 2! 🎉
 
 ## 📱 SMS Notifications Setup
 
-Get instant text message alerts when websites change!
+Get instant text message alerts when websites change! Choose between Twilio (recommended) or AWS SNS.
 
-### Option A: Quick Setup (Recommended for beginners)
+### Option A: Twilio Setup (Recommended - Easier)
 
-1. **Deploy AWS infrastructure automatically:**
-   ```bash
-   cd cloudformation
-   ./deploy.sh -p "+1234567890"  # Use your real phone number
-   ```
+1. **Create a Twilio account:**
+   - Go to [twilio.com](https://twilio.com) and sign up (free trial available)
+   - Verify your phone number during signup
 
-2. **The script will output configuration commands like:**
+2. **Get your Twilio credentials:**
+   - In Twilio Console, find your Account SID and Auth Token
+   - Purchase a Twilio phone number (or use trial number)
+
+3. **Set environment variables:**
    ```bash
-   export AWS_ACCESS_KEY_ID="AKIAEXAMPLE123"
-   export AWS_SECRET_ACCESS_KEY="secretkey123"
-   export SNS_TOPIC_ARN="arn:aws:sns:us-east-1:123456789012:url-watcher-topic"
-   export AWS_REGION="us-east-1"
+   export TWILIO_ACCOUNT_SID="ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+   export TWILIO_AUTH_TOKEN="your_auth_token"
+   export TWILIO_FROM_PHONE="+15551234567"  # Your Twilio number
+   export TWILIO_TO_PHONE="+19876543210"    # Your personal number
    ```
 
-3. **Copy and run those export commands, then test:**
+4. **Test configuration:**
    ```bash
-   python -c "from sms_notifier import create_notifier_from_env; n=create_notifier_from_env(); print('✅ SMS working!' if n.test_notification()['success'] else '❌ SMS failed')"
+   python twilio_notifier.py
    ```
 
-4. **Use monitoring with SMS:**
+5. **Use monitoring with SMS:**
    ```bash
    python url_watcher.py https://example.com --sms --continuous
    ```
 
-### Option B: Manual AWS Setup
+### Option B: AWS SNS Setup (Legacy)
 
-If you prefer manual control or the script doesn't work:
+For users who prefer AWS or already have AWS infrastructure:
 
 1. **Create SNS Topic in AWS Console:**
    - Go to AWS SNS Console
diff --git a/requirements.txt b/requirements.txt
index fb6c476..7561805 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,9 +1,11 @@
 requests>=2.28.0
-boto3>=1.26.0
-botocore>=1.29.0
+twilio>=9.0.0
 pytest>=8.0.0
 pytest-cov>=6.0.0
 # Dev dependencies
 flake8>=6.0.0
 black>=23.0.0
-bandit>=1.7.0
\ No newline at end of file
+bandit>=1.7.0
+# Legacy AWS dependencies (keeping for backward compatibility)
+boto3>=1.26.0
+botocore>=1.29.0
\ No newline at end of file
diff --git a/test_twilio_notifier.py b/test_twilio_notifier.py
new file mode 100644
index 0000000..1859bdc
--- /dev/null
+++ b/test_twilio_notifier.py
@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+"""
+Test suite for Twilio SMS notification functionality
+"""
+
+import os
+import pytest
+from unittest.mock import Mock, patch, MagicMock
+from twilio_notifier import TwilioNotifier, create_notifier_from_env
+
+
+class TestTwilioNotifier:
+    """Test the TwilioNotifier class functionality"""
+
+    def test_init_without_credentials(self):
+        """Test initializing without credentials"""
+        notifier = TwilioNotifier()
+        assert notifier.account_sid is None
+        assert notifier.auth_token is None
+        assert notifier.from_phone is None
+        assert notifier.to_phone is None
+        assert not notifier.is_configured()
+
+    @patch("twilio_notifier.TWILIO_AVAILABLE", True)
+    @patch("twilio_notifier.Client")
+    def test_init_with_credentials(self, mock_client):
+        """Test initializing with credentials"""
+        notifier = TwilioNotifier(
+            account_sid="ACtest123",
+            auth_token="token123",
+            from_phone="+15551234567",
+            to_phone="+19876543210",
+        )
+
+        assert notifier.account_sid == "ACtest123"
+        assert notifier.auth_token == "token123"
+        assert notifier.from_phone == "+15551234567"
+        assert notifier.to_phone == "+19876543210"
+        mock_client.assert_called_once_with("ACtest123", "token123")
+
+    def test_is_configured_false_cases(self):
+        """Test is_configured returns False for incomplete configuration"""
+        # No credentials
+        notifier = TwilioNotifier()
+        assert not notifier.is_configured()
+
+        # Missing phone numbers
+        notifier = TwilioNotifier(account_sid="test", auth_token="test")
+        assert not notifier.is_configured()
+
+        # Missing auth token
+        notifier = TwilioNotifier(
+            account_sid="test", from_phone="+1234567890", to_phone="+1987654321"
+        )
+        assert not notifier.is_configured()
+
+    @patch("twilio_notifier.TWILIO_AVAILABLE", True)
+    @patch("twilio_notifier.Client")
+    def test_is_configured_true(self, mock_client):
+        """Test is_configured returns True for complete configuration"""
+        mock_client.return_value = Mock()
+
+        notifier = TwilioNotifier(
+            account_sid="ACtest123",
+            auth_token="token123",
+            from_phone="+15551234567",
+            to_phone="+19876543210",
+        )
+
+        assert notifier.is_configured()
+
+    @patch("twilio_notifier.TWILIO_AVAILABLE", False)
+    def test_is_configured_false_when_twilio_unavailable(self):
+        """Test is_configured returns False when Twilio package unavailable"""
+        notifier = TwilioNotifier(
+            account_sid="ACtest123",
+            auth_token="token123",
+            from_phone="+15551234567",
+            to_phone="+19876543210",
+        )
+
+        assert not notifier.is_configured()
+
+    @patch("twilio_notifier.TWILIO_AVAILABLE", True)
+    @patch("twilio_notifier.Client")
+    def test_send_notification_success(self, mock_client):
+        """Test successful SMS notification sending"""
+        # Setup mocks
+        mock_message = Mock()
+        mock_message.sid = "SMtest123"
+        mock_client.return_value.messages.create.return_value = mock_message
+
+        notifier = TwilioNotifier(
+            account_sid="ACtest123",
+            auth_token="token123",
+            from_phone="+15551234567",
+            to_phone="+19876543210",
+        )
+
+        # Send notification
+        result = notifier.send_notification(
+            url="https://example.com", message="Test change detected"
+        )
+
+        assert result is True
+        mock_client.return_value.messages.create.assert_called_once()
+
+        # Check the call arguments
+        call_args = mock_client.return_value.messages.create.call_args
+        assert call_args[1]["from_"] == "+15551234567"
+        assert call_args[1]["to"] == "+19876543210"
+        assert "URL CHANGE DETECTED" in call_args[1]["body"]
+        assert "https://example.com" in call_args[1]["body"]
+
+    def test_send_notification_not_configured(self):
+        """Test send_notification fails when not configured"""
+        notifier = TwilioNotifier()
+
+        result = notifier.send_notification(url="https://example.com", message="Test message")
+
+        assert result is False
+
+    @patch("twilio_notifier.TWILIO_AVAILABLE", True)
+    @patch("twilio_notifier.Client")
+    def test_send_notification_twilio_exception(self, mock_client):
+        """Test send_notification handles Twilio exceptions"""
+        # Create a mock exception that inherits from Exception
+        mock_exception = Exception("Test Twilio error")
+        mock_client.return_value.messages.create.side_effect = mock_exception
+
+        notifier = TwilioNotifier(
+            account_sid="ACtest123",
+            auth_token="token123",
+            from_phone="+15551234567",
+            to_phone="+19876543210",
+        )
+
+        result = notifier.send_notification(url="https://example.com", message="Test message")
+
+        assert result is False
+
+    def test_format_message(self):
+        """Test message formatting"""
+        notifier = TwilioNotifier()
+
+        message = notifier._format_message(
+            url="https://example.com", content="Line changed from A to B"
+        )
+
+        assert "URL CHANGE DETECTED" in message
+        assert "https://example.com" in message
+        assert "Line changed from A to B" in message
+        assert "Powered by URL Watcher + Twilio" in message
+
+    def test_format_message_truncation(self):
+        """Test message truncation for long content"""
+        notifier = TwilioNotifier()
+
+        # Create very long content
+        long_content = "A" * 1500
+
+        message = notifier._format_message(url="https://example.com", content=long_content)
+
+        # Should be truncated and have "..." at the end
+        assert len(message) < 1600  # Under SMS limit
+        assert message.count("A") < 1500  # Content was truncated
+        assert "..." in message
+
+    @patch("twilio_notifier.TWILIO_AVAILABLE", True)
+    @patch("twilio_notifier.Client")
+    def test_test_notification_success(self, mock_client):
+        """Test successful test notification"""
+        mock_message = Mock()
+        mock_message.sid = "SMtest123"
+        mock_message.status = "sent"
+        mock_client.return_value.messages.create.return_value = mock_message
+
+        notifier = TwilioNotifier(
+            account_sid="ACtest123",
+            auth_token="token123",
+            from_phone="+15551234567",
+            to_phone="+19876543210",
+        )
+
+        result = notifier.test_notification()
+
+        assert result["success"] is True
+        assert result["message_id"] == "SMtest123"
+        assert result["status"] == "sent"
+
+    @patch("twilio_notifier.TWILIO_AVAILABLE", True)
+    @patch("twilio_notifier.Client")
+    def test_test_notification_not_configured(self, mock_client):
+        """Test test notification when not configured"""
+        notifier = TwilioNotifier()  # No credentials provided
+
+        result = notifier.test_notification()
+
+        assert result["success"] is False
+        assert "not configured" in result["message"]
+        assert "Missing:" in result["error"]
+
+    @patch("twilio_notifier.TWILIO_AVAILABLE", False)
+    def test_test_notification_twilio_unavailable(self):
+        """Test test notification when Twilio package unavailable"""
+        notifier = TwilioNotifier()
+
+        result = notifier.test_notification()
+
+        assert result["success"] is False
+        assert "not installed" in result["message"]
+
+
+class TestCreateNotifierFromEnv:
+    """Test the create_notifier_from_env function"""
+
+    @patch("twilio_notifier.TWILIO_AVAILABLE", True)
+    @patch.dict(
+        os.environ,
+        {
+            "TWILIO_ACCOUNT_SID": "ACtest123",
+            "TWILIO_AUTH_TOKEN": "token123",
+            "TWILIO_FROM_PHONE": "+15551234567",
+            "TWILIO_TO_PHONE": "+19876543210",
+        },
+    )
+    @patch("twilio_notifier.Client")
+    def test_create_from_env_success(self, mock_client):
+        """Test creating notifier from environment variables"""
+        notifier = create_notifier_from_env()
+
+        assert notifier.account_sid == "ACtest123"
+        assert notifier.auth_token == "token123"
+        assert notifier.from_phone == "+15551234567"
+        assert notifier.to_phone == "+19876543210"
+
+    @patch.dict(os.environ, {}, clear=True)
+    def test_create_from_env_no_vars(self):
+        """Test creating notifier with no environment variables"""
+        notifier = create_notifier_from_env()
+
+        assert notifier.account_sid is None
+        assert notifier.auth_token is None
+        assert notifier.from_phone is None
+        assert notifier.to_phone is None
+        assert not notifier.is_configured()
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])
diff --git a/test_url_watcher.py b/test_url_watcher.py
index 989b90b..add0c96 100644
--- a/test_url_watcher.py
+++ b/test_url_watcher.py
@@ -403,21 +403,15 @@ def test_main_with_sms_not_configured(self, mock_print):
         """Test main with SMS but not configured"""
         from url_watcher import main
 
-        with patch("url_watcher.create_notifier_from_env") as mock_create_notifier:
-            mock_notifier = Mock()
-            mock_notifier.is_configured.return_value = False
-            mock_create_notifier.return_value = mock_notifier
-
-            with patch("url_watcher.URLWatcher") as mock_watcher_class:
-                mock_watcher = Mock()
-                mock_watcher.check_url.return_value = (False, "")
-                mock_watcher_class.return_value = mock_watcher
+        with patch("url_watcher.URLWatcher") as mock_watcher_class:
+            mock_watcher = Mock()
+            mock_watcher.check_url.return_value = (False, "")
+            mock_watcher_class.return_value = mock_watcher
 
-                main()
+            main()
 
-                mock_print.assert_any_call(
-                    "⚠️  SMS notifications requested but not properly configured"
-                )
+            # Check that URLWatcher was created with auto notification service
+            mock_watcher_class.assert_called_with(notification_service="auto")
 
     @patch("sys.argv", ["url_watcher.py", "http://example.com", "--sms"])
     @patch("builtins.print")
@@ -425,19 +419,15 @@ def test_main_with_sms_configured(self, mock_print):
         """Test main with SMS properly configured"""
         from url_watcher import main
 
-        with patch("url_watcher.create_notifier_from_env") as mock_create_notifier:
-            mock_notifier = Mock()
-            mock_notifier.is_configured.return_value = True
-            mock_create_notifier.return_value = mock_notifier
-
-            with patch("url_watcher.URLWatcher") as mock_watcher_class:
-                mock_watcher = Mock()
-                mock_watcher.check_url.return_value = (False, "")
-                mock_watcher_class.return_value = mock_watcher
+        with patch("url_watcher.URLWatcher") as mock_watcher_class:
+            mock_watcher = Mock()
+            mock_watcher.check_url.return_value = (False, "")
+            mock_watcher_class.return_value = mock_watcher
 
-                main()
+            main()
 
-                mock_print.assert_any_call("📱 SMS notifications enabled")
+            # Check that URLWatcher was created with auto notification service
+            mock_watcher_class.assert_called_with(notification_service="auto")
 
     @patch("sys.argv", ["url_watcher.py", "http://example.com"])
     @patch("builtins.print")
diff --git a/twilio_notifier.py b/twilio_notifier.py
new file mode 100644
index 0000000..1af87b6
--- /dev/null
+++ b/twilio_notifier.py
@@ -0,0 +1,262 @@
+#!/usr/bin/env python3
+"""
+Twilio SMS notification system for URL Watcher
+
+This module provides SMS notification functionality using Twilio's API
+as an alternative to AWS SNS.
+"""
+
+import os
+import logging
+from datetime import datetime
+from typing import Dict, Optional, Any
+
+try:
+    from twilio.rest import Client
+    from twilio.base.exceptions import TwilioException
+
+    TWILIO_AVAILABLE = True
+except ImportError:
+    TWILIO_AVAILABLE = False
+    Client = None
+    TwilioException = Exception
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+class TwilioNotifier:
+    """
+    Handles SMS notifications using Twilio API
+
+    This class provides a simple interface for sending SMS notifications
+    when URL content changes are detected.
+    """
+
+    def __init__(
+        self,
+        account_sid: Optional[str] = None,
+        auth_token: Optional[str] = None,
+        from_phone: Optional[str] = None,
+        to_phone: Optional[str] = None,
+    ):
+        """
+        Initialize the Twilio SMS notifier
+
+        Args:
+            account_sid (str, optional): Twilio Account SID
+            auth_token (str, optional): Twilio Auth Token
+            from_phone (str, optional): Twilio phone number (sender)
+            to_phone (str, optional): Recipient phone number
+        """
+        self.account_sid = account_sid
+        self.auth_token = auth_token
+        self.from_phone = from_phone
+        self.to_phone = to_phone
+        self.client = None
+
+        if not TWILIO_AVAILABLE:
+            logger.warning("Twilio package not installed. Install with: pip install twilio")
+            return
+
+        # Initialize Twilio client if credentials provided
+        if self.account_sid and self.auth_token:
+            try:
+                self.client = Client(self.account_sid, self.auth_token)
+                logger.info("Twilio client initialized successfully")
+            except Exception as e:
+                logger.error(f"Failed to initialize Twilio client: {e}")
+                self.client = None
+
+    def is_configured(self) -> bool:
+        """
+        Check if Twilio notifications are properly configured
+
+        Returns:
+            bool: True if configured and ready to send SMS, False otherwise
+        """
+        if not TWILIO_AVAILABLE:
+            return False
+
+        return (
+            self.client is not None
+            and self.account_sid is not None
+            and self.auth_token is not None
+            and self.from_phone is not None
+            and self.to_phone is not None
+        )
+
+    def send_notification(self, url: str, message: str, subject: Optional[str] = None) -> bool:
+        """
+        Send SMS notification about URL change
+
+        Args:
+            url (str): The URL that changed
+            message (str): The change description/diff
+            subject (str, optional): Message subject (not used in SMS)
+
+        Returns:
+            bool: True if SMS sent successfully, False otherwise
+        """
+        if not self.is_configured():
+            logger.warning("Twilio notifier not configured - cannot send SMS")
+            return False
+
+        try:
+            # Format SMS message
+            sms_body = self._format_message(url, message, subject)
+
+            # Send SMS via Twilio
+            message = self.client.messages.create(
+                body=sms_body, from_=self.from_phone, to=self.to_phone
+            )
+
+            logger.info(f"SMS sent successfully - Message SID: {message.sid}")
+            return True
+
+        except TwilioException as e:
+            logger.error(f"Twilio API error: {e}")
+            return False
+        except Exception as e:
+            logger.error(f"Failed to send SMS notification: {e}")
+            return False
+
+    def _format_message(self, url: str, content: str, subject: Optional[str] = None) -> str:
+        """
+        Format the SMS message content
+
+        Args:
+            url (str): The URL that changed
+            content (str): The change description
+            subject (str, optional): Message subject
+
+        Returns:
+            str: Formatted SMS message
+        """
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+        # Twilio SMS has 1600 character limit, so we need to truncate
+        max_content_length = 1200  # Leave room for other text
+
+        if len(content) > max_content_length:
+            content = content[:max_content_length] + "..."
+
+        message_parts = [
+            "🚨 URL CHANGE DETECTED",
+            f"Time: {timestamp}",
+            f"URL: {url}",
+            "",
+            "Changes detected:",
+            content,
+            "",
+            "Powered by URL Watcher + Twilio",
+        ]
+
+        return "\n".join(message_parts)
+
+    def test_notification(self) -> Dict[str, Any]:
+        """
+        Send a test SMS to verify configuration
+
+        Returns:
+            dict: Test results with success status and details
+        """
+        if not TWILIO_AVAILABLE:
+            return {
+                "success": False,
+                "message": "Twilio package not installed",
+                "error": "Install with: pip install twilio",
+            }
+
+        if not self.is_configured():
+            missing = []
+            if not self.account_sid:
+                missing.append("account_sid")
+            if not self.auth_token:
+                missing.append("auth_token")
+            if not self.from_phone:
+                missing.append("from_phone")
+            if not self.to_phone:
+                missing.append("to_phone")
+
+            return {
+                "success": False,
+                "message": "Twilio not configured",
+                "error": f"Missing: {', '.join(missing)}",
+            }
+
+        try:
+            # Send test message
+            test_message = (
+                "✅ URL Watcher Test Message\n\n"
+                f"Sent at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"
+                "If you receive this, Twilio SMS is working correctly!\n\n"
+                "Powered by URL Watcher + Twilio"
+            )
+
+            message = self.client.messages.create(
+                body=test_message, from_=self.from_phone, to=self.to_phone
+            )
+
+            return {
+                "success": True,
+                "message": "Test SMS sent successfully",
+                "message_id": message.sid,
+                "status": message.status,
+            }
+
+        except TwilioException as e:
+            return {"success": False, "message": "Twilio API error", "error": str(e)}
+        except Exception as e:
+            return {"success": False, "message": "Failed to send test SMS", "error": str(e)}
+
+
+def create_notifier_from_env() -> TwilioNotifier:
+    """
+    Create a TwilioNotifier using environment variables
+
+    Expected environment variables:
+    - TWILIO_ACCOUNT_SID: Your Twilio Account SID
+    - TWILIO_AUTH_TOKEN: Your Twilio Auth Token
+    - TWILIO_FROM_PHONE: Your Twilio phone number (e.g., +1234567890)
+    - TWILIO_TO_PHONE: Recipient phone number (e.g., +1987654321)
+
+    Returns:
+        TwilioNotifier: Configured SMS notifier instance
+    """
+    return TwilioNotifier(
+        account_sid=os.environ.get("TWILIO_ACCOUNT_SID"),
+        auth_token=os.environ.get("TWILIO_AUTH_TOKEN"),
+        from_phone=os.environ.get("TWILIO_FROM_PHONE"),
+        to_phone=os.environ.get("TWILIO_TO_PHONE"),
+    )
+
+
+# For backward compatibility, also provide AWS-style function name
+def create_twilio_notifier_from_env() -> TwilioNotifier:
+    """Alias for create_notifier_from_env() for clarity"""
+    return create_notifier_from_env()
+
+
+if __name__ == "__main__":
+    # Quick test when run directly
+    print("🔍 Testing Twilio SMS Notifier...")
+
+    notifier = create_notifier_from_env()
+
+    if not notifier.is_configured():
+        print("❌ Twilio not configured. Set these environment variables:")
+        print("   export TWILIO_ACCOUNT_SID='your_account_sid'")
+        print("   export TWILIO_AUTH_TOKEN='your_auth_token'")
+        print("   export TWILIO_FROM_PHONE='+1234567890'")
+        print("   export TWILIO_TO_PHONE='+1987654321'")
+    else:
+        print("✅ Twilio configured! Sending test message...")
+        result = notifier.test_notification()
+
+        if result["success"]:
+            print(f"✅ Test SMS sent! Message ID: {result['message_id']}")
+        else:
+            print(f"❌ Test failed: {result['message']}")
+            if "error" in result:
+                print(f"   Error: {result['error']}")
diff --git a/url_watcher.py b/url_watcher.py
index 9d6fdba..32172ae 100644
--- a/url_watcher.py
+++ b/url_watcher.py
@@ -15,14 +15,43 @@
 from datetime import datetime
 from difflib import unified_diff
 from typing import Optional
-from sms_notifier import SMSNotifier, create_notifier_from_env
+
+# Support both AWS SNS and Twilio SMS notifications
+try:
+    from sms_notifier import SMSNotifier, create_notifier_from_env as create_aws_notifier
+
+    AWS_AVAILABLE = True
+except ImportError:
+    AWS_AVAILABLE = False
+    SMSNotifier = None
+    create_aws_notifier = None
+
+try:
+    from twilio_notifier import TwilioNotifier, create_notifier_from_env as create_twilio_notifier
+
+    TWILIO_AVAILABLE = True
+except ImportError:
+    TWILIO_AVAILABLE = False
+    TwilioNotifier = None
+    create_twilio_notifier = None
 
 
 class URLWatcher:
-    def __init__(self, storage_file="url_cache.json", sms_notifier: Optional[SMSNotifier] = None):
+    def __init__(
+        self,
+        storage_file="url_cache.json",
+        sms_notifier=None,  # Can be SMSNotifier (AWS) or TwilioNotifier
+        notification_service="auto",  # "auto", "aws", "twilio", or "none"
+    ):
         self.storage_file = storage_file
         self.cache = self._load_cache()
-        self.sms_notifier = sms_notifier
+        self.notification_service = notification_service
+
+        # Auto-detect notification service if not explicitly provided
+        if sms_notifier is None and notification_service == "auto":
+            self.sms_notifier = self._auto_detect_notification_service()
+        else:
+            self.sms_notifier = sms_notifier
 
     def _load_cache(self):
         """Load previous URL content cache from file"""
@@ -34,6 +63,35 @@ def _load_cache(self):
                 return {}
         return {}
 
+    def _auto_detect_notification_service(self):
+        """Auto-detect available notification service based on environment variables"""
+        # Check for Twilio environment variables first (since we're prioritizing it)
+        twilio_vars = [
+            os.environ.get("TWILIO_ACCOUNT_SID"),
+            os.environ.get("TWILIO_AUTH_TOKEN"),
+            os.environ.get("TWILIO_FROM_PHONE"),
+            os.environ.get("TWILIO_TO_PHONE"),
+        ]
+
+        if TWILIO_AVAILABLE and all(twilio_vars):
+            print("📱 Auto-detected: Using Twilio SMS notifications")
+            return create_twilio_notifier()
+
+        # Fallback to AWS SNS if available
+        aws_vars = [
+            os.environ.get("SNS_TOPIC_ARN"),
+            os.environ.get("AWS_ACCESS_KEY_ID"),
+            os.environ.get("AWS_SECRET_ACCESS_KEY"),
+        ]
+
+        if AWS_AVAILABLE and all(aws_vars):
+            print("☁️  Auto-detected: Using AWS SNS notifications")
+            return create_aws_notifier()
+
+        # No notification service detected
+        print("📵 No SMS service configured (set TWILIO_* or AWS_* environment variables)")
+        return None
+
     def _save_cache(self):
         """Save URL content cache to file"""
         with open(self.storage_file, "w") as f:
@@ -172,26 +230,18 @@ def main():
         print("  With SMS:     python url_watcher.py <URL> --sms")
         print("  Both:         python url_watcher.py <URL> --continuous --sms")
         print("\nFor SMS notifications, set these environment variables:")
-        print("  SNS_TOPIC_ARN, AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY")
+        print(
+            "  Twilio (preferred): TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, TWILIO_FROM_PHONE, TWILIO_TO_PHONE"
+        )
+        print("  AWS SNS (legacy):   SNS_TOPIC_ARN, AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY")
         sys.exit(1)
 
     url = sys.argv[1]
     continuous = "--continuous" in sys.argv[2:]
     enable_sms = "--sms" in sys.argv[2:]
 
-    # Initialize SMS notifier if requested
-    sms_notifier = None
-    if enable_sms:
-        sms_notifier = create_notifier_from_env()
-        if not sms_notifier.is_configured():
-            print("⚠️  SMS notifications requested but not properly configured")
-            print(
-                "Set SNS_TOPIC_ARN, AWS_ACCESS_KEY_ID, and AWS_SECRET_ACCESS_KEY environment variables"
-            )
-        else:
-            print("📱 SMS notifications enabled")
-
-    watcher = URLWatcher(sms_notifier=sms_notifier)
+    # Initialize SMS notifier if requested (auto-detects Twilio vs AWS)
+    watcher = URLWatcher(notification_service="auto" if enable_sms else "none")
 
     try:
         if continuous:
