diff --git a/.env.example b/.env.example
index ae3ccd6a..c12cc885 100644
--- a/.env.example
+++ b/.env.example
@@ -57,6 +57,12 @@ TWILIO_PHONE_NUMBER=+1234567890
 # SMS Log Aggregation
 LOG_AGGREGATION_URL=https://your-log-aggregation-endpoint.com/logs
 NEXT_PUBLIC_LOG_AGGREGATION_URL=https://your-log-aggregation-endpoint.com/logs
+
+# Error Tracking Configuration
+# External error tracking service endpoint (e.g., Sentry, DataDog, LogRocket)
+ERROR_TRACKING_URL=https://your-error-tracking-service.com/api/errors
+ERROR_TRACKING_API_KEY=your_api_key_here
+
 # Discord OAuth Configuration
 DISCORD_CLIENT_ID=your_discord_client_id
 DISCORD_CLIENT_SECRET=your_discord_client_secret
diff --git a/docs/ERROR_TRACKING.md b/docs/ERROR_TRACKING.md
new file mode 100644
index 00000000..5d1fb96e
--- /dev/null
+++ b/docs/ERROR_TRACKING.md
@@ -0,0 +1,370 @@
+# Error Tracking Documentation
+
+## Overview
+
+The teachLink web application uses a comprehensive error tracking system that combines structured logging with external error monitoring services. This ensures all errors are properly captured, categorized, and reported for debugging and monitoring purposes.
+
+## Architecture
+
+### Components
+
+1. **Error Reporting Service** (`src/services/errorReporting.ts`)
+   - Client-side error collection and reporting
+   - Session tracking with unique session IDs
+   - Breadcrumb collection for user action tracing
+   - Automatic error classification
+
+2. **Error API Endpoint** (`src/app/api/errors/report/route.ts`)
+   - Server-side error reception
+   - Integration with external error tracking services
+   - Structured logging of all error reports
+
+3. **Structured Logging** (`src/lib/logging/`)
+   - Pino-based logging system
+   - Automatic redaction of sensitive data
+   - Multiple transport support (in-memory, HTTP, aggregation)
+   - Context-aware logging with request/correlation IDs
+
+4. **Error Utilities** (`src/utils/errorUtils.ts`)
+   - Error classification (network, validation, auth, etc.)
+   - User-friendly error messages
+   - Retry logic with exponential backoff
+
+## Configuration
+
+### Environment Variables
+
+Add the following to your `.env` file:
+
+```bash
+# Error Tracking Configuration
+# External error tracking service endpoint (e.g., Sentry, DataDog, LogRocket)
+ERROR_TRACKING_URL=https://your-error-tracking-service.com/api/errors
+ERROR_TRACKING_API_KEY=your_api_key_here
+```
+
+### Logging Configuration
+
+```bash
+# Log Level (debug | info | warn | error)
+LOG_LEVEL=info
+NEXT_PUBLIC_LOG_LEVEL=info
+
+# Log Aggregation Endpoint
+LOG_AGGREGATION_URL=https://your-log-aggregation-endpoint.com/logs
+NEXT_PUBLIC_LOG_AGGREGATION_URL=https://your-log-aggregation-endpoint.com/logs
+```
+
+## Usage
+
+### Client-Side Error Reporting
+
+```typescript
+import { errorReportingService } from '@/services/errorReporting';
+
+// Report an error with context
+try {
+  await someAsyncOperation();
+} catch (error) {
+  await errorReportingService.reportError(error, {
+    action: 'user_submit_form',
+    userId: 'user-123',
+    additionalContext: { formData: data },
+  });
+}
+
+// Set user context for error tracking
+errorReportingService.setUserId('user-123');
+
+// Add breadcrumbs for user actions
+errorReportingService.reportUserAction('button_click', {
+  buttonId: 'submit-form',
+  page: '/editor',
+});
+
+// Clear user context on logout
+errorReportingService.clearUserId();
+```
+
+### Using the Error Handling Hook
+
+```typescript
+import { useErrorHandling } from '@/hooks/useErrorHandling';
+
+function MyComponent() {
+  const { execute, error, isLoading } = useErrorHandling({
+    maxAttempts: 3,
+    reportErrors: true,
+  });
+
+  const handleSubmit = async () => {
+    const result = await execute(() => apiCall());
+    if (result) {
+      // Success
+    }
+  };
+
+  return <button onClick={handleSubmit}>Submit</button>;
+}
+```
+
+### Server-Side Error Logging
+
+```typescript
+import { createLogger } from '@/lib/logging';
+
+const logger = createLogger('myModule');
+
+// Log errors with context
+logger.error('Operation failed', {
+  context: { userId, operation: 'data_fetch' },
+  error: new Error('Database connection failed'),
+});
+
+// Log warnings
+logger.warn('Deprecated API usage', {
+  context: { endpoint: '/api/v1/old' },
+});
+
+// Log info
+logger.info('User action completed', {
+  context: { action: 'login', userId },
+});
+```
+
+## Error Classification
+
+The system automatically classifies errors into the following types:
+
+- **NETWORK**: Network connectivity issues
+- **VALIDATION**: Input validation errors
+- **AUTHENTICATION**: Authentication failures
+- **AUTHORIZATION**: Permission errors
+- **NOT_FOUND**: Resource not found
+- **SERVER**: Server-side errors (5xx)
+- **TIMEOUT**: Request timeouts
+- **OFFLINE**: Application offline
+- **RATE_LIMIT**: API rate limiting
+- **UNKNOWN**: Unclassified errors
+
+Each classification includes:
+- User-friendly message
+- Action suggestion
+- Retryability flag
+- HTTP status code (if applicable)
+
+## External Service Integration
+
+### Supported Services
+
+The error tracking endpoint supports integration with various external services:
+
+1. **Sentry**
+   ```bash
+   ERROR_TRACKING_URL=https://sentry.io/api/PROJECT_ID/envelope/
+   ERROR_TRACKING_API_KEY=your_sentry_dsn
+   ```
+
+2. **DataDog**
+   ```bash
+   ERROR_TRACKING_URL=https://http-intake.logs.datadoghq.com/api/v2/logs
+   ERROR_TRACKING_API_KEY=your_datadog_api_key
+   ```
+
+3. **LogRocket**
+   ```bash
+   ERROR_TRACKING_URL=https://api.logrocket.com/logs
+   ERROR_TRACKING_API_KEY=your_logrocket_api_key
+   ```
+
+4. **Custom Endpoint**
+   ```bash
+   ERROR_TRACKING_URL=https://your-custom-endpoint.com/errors
+   ERROR_TRACKING_API_KEY=your_api_key
+   ```
+
+### Integration Behavior
+
+- Errors are sent asynchronously without blocking the response
+- Failed sends are logged but don't affect the application
+- Each error report includes:
+  - Error details (type, message, stack trace)
+  - Session and user information
+  - Breadcrumbs (user actions leading to error)
+  - Environment and URL information
+  - Source identifier (`teachLink-web`)
+
+## Testing Error Tracking
+
+### Manual Testing
+
+```typescript
+// Test error reporting
+await errorReportingService.reportError(new Error('Test error'), {
+  test: true,
+});
+
+// Test breadcrumb tracking
+errorReportingService.reportUserAction('test_action', { test: true });
+```
+
+### Verification
+
+1. Check browser console for error logs
+2. Verify logs appear in your log aggregation service
+3. Confirm errors appear in external tracking service (if configured)
+4. Check server logs for `/api/errors/report` endpoint activity
+
+## Best Practices
+
+### 1. Always Report Errors
+
+```typescript
+// Good
+try {
+  await operation();
+} catch (error) {
+  await errorReportingService.reportError(error, { context });
+}
+
+// Bad - silent failures
+try {
+  await operation();
+} catch (error) {
+  console.error(error); // Only console logging
+}
+```
+
+### 2. Provide Context
+
+```typescript
+// Good - rich context
+await errorReportingService.reportError(error, {
+  action: 'submit_form',
+  formId: 'contact-form',
+  userId: currentUser.id,
+  formData: { email, subject },
+});
+
+// Bad - minimal context
+await errorReportingService.reportError(error);
+```
+
+### 3. Set User Context
+
+```typescript
+// On login
+errorReportingService.setUserId(user.id);
+
+// On logout
+errorReportingService.clearUserId();
+```
+
+### 4. Add Breadcrumbs
+
+```typescript
+// Track important user actions
+errorReportingService.reportUserAction('navigation', {
+  from: '/dashboard',
+  to: '/editor',
+});
+
+errorReportingService.reportUserAction('form_submit', {
+  formId: 'contact-form',
+  fields: ['email', 'message'],
+});
+```
+
+### 5. Use Appropriate Log Levels
+
+```typescript
+// Debug - detailed information for debugging
+logger.debug('Function called', { context: { params } });
+
+// Info - general informational messages
+logger.info('User logged in', { context: { userId } });
+
+// Warn - warning messages for potential issues
+logger.warn('Deprecated API used', { context: { endpoint } });
+
+// Error - error messages
+logger.error('Operation failed', { context, error });
+```
+
+## Troubleshooting
+
+### Errors Not Appearing in External Service
+
+1. Verify `ERROR_TRACKING_URL` is set correctly
+2. Check `ERROR_TRACKING_API_KEY` is valid
+3. Review server logs for send failures
+4. Ensure the external service is accessible from your server
+
+### Sensitive Data in Logs
+
+The logging system automatically redacts common sensitive data:
+- Passwords
+- API keys
+- Tokens
+- Email addresses
+- Phone numbers
+- Credit card numbers
+
+If you need additional redaction rules, modify `SENSITIVE_KEYS` in `src/lib/logging/index.ts`.
+
+### High Error Volume
+
+If you're receiving too many error reports:
+
+1. Review error classification to filter expected errors
+2. Add error filtering in `sendToExternalService` function
+3. Adjust sampling rates in external service configuration
+4. Implement error deduplication
+
+## Security Considerations
+
+1. **API Keys**: Never commit API keys to version control
+2. **Sensitive Data**: The logging system automatically redacts sensitive data
+3. **User Privacy**: Avoid logging PII beyond what's necessary for debugging
+4. **Access Control**: Ensure error tracking endpoints are protected
+5. **Data Retention**: Configure appropriate data retention policies in external services
+
+## Monitoring and Alerts
+
+Set up monitoring for:
+
+1. Error rate spikes
+2. New error types appearing
+3. High-frequency errors from specific users
+4. External service send failures
+
+Example monitoring queries:
+- Error rate by type
+- Errors by user ID
+- Errors by URL path
+- External service send success rate
+
+## Migration from console.error
+
+The application has been migrated from `console.error` to structured logging:
+
+**Before:**
+```typescript
+console.error('Error occurred:', error);
+```
+
+**After:**
+```typescript
+logger.error('Error occurred', { error, context: { additionalInfo } });
+```
+
+All existing `console.error` calls in error reporting have been replaced with structured logging using the Pino-based logger.
+
+## Support
+
+For issues or questions about error tracking:
+
+1. Check this documentation
+2. Review error logs in your aggregation service
+3. Consult external service documentation (Sentry, DataDog, etc.)
+4. Open an issue in the project repository
diff --git a/src/app/api/errors/report/route.ts b/src/app/api/errors/report/route.ts
index 0cdc1467..b1aa2618 100644
--- a/src/app/api/errors/report/route.ts
+++ b/src/app/api/errors/report/route.ts
@@ -3,6 +3,59 @@ import { createLogger } from '@/lib/logging';
 
 const logger = createLogger('errors.report');
 
+// External error tracking service configuration
+const ERROR_TRACKING_URL = process.env.ERROR_TRACKING_URL;
+const ERROR_TRACKING_API_KEY = process.env.ERROR_TRACKING_API_KEY;
+
+/**
+ * Send error to external tracking service (e.g., Sentry, LogRocket, DataDog)
+ */
+async function sendToExternalService(report: any): Promise<void> {
+  if (!ERROR_TRACKING_URL) {
+    return;
+  }
+
+  try {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    };
+
+    if (ERROR_TRACKING_API_KEY) {
+      headers['Authorization'] = `Bearer ${ERROR_TRACKING_API_KEY}`;
+      headers['X-API-Key'] = ERROR_TRACKING_API_KEY;
+    }
+
+    const response = await fetch(ERROR_TRACKING_URL, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({
+        ...report,
+        source: 'teachLink-web',
+        timestamp: new Date().toISOString(),
+      }),
+    });
+
+    if (!response.ok) {
+      logger.warn('Failed to send error to external service', {
+        context: {
+          status: response.status,
+          statusText: response.statusText,
+          service: ERROR_TRACKING_URL,
+        },
+      });
+    } else {
+      logger.info('Error sent to external service successfully', {
+        context: { reportId: report.id, service: ERROR_TRACKING_URL },
+      });
+    }
+  } catch (error) {
+    logger.error('Error sending to external tracking service', {
+      error,
+      context: { service: ERROR_TRACKING_URL },
+    });
+  }
+}
+
 export async function POST(request: NextRequest): Promise<NextResponse> {
   try {
     const report = await request.json();
@@ -25,6 +78,12 @@ export async function POST(request: NextRequest): Promise<NextResponse> {
       error: clientError,
     });
 
+    // Send to external error tracking service if configured
+    if (ERROR_TRACKING_URL) {
+      // Send asynchronously without waiting
+      void sendToExternalService(report);
+    }
+
     return NextResponse.json({ ok: true }, { status: 200 });
   } catch (err) {
     logger.warn('Failed to process error report', { error: err });
diff --git a/src/components/cms/ContentEditor.tsx b/src/components/cms/ContentEditor.tsx
index 10e0975e..a2c1bcd5 100644
--- a/src/components/cms/ContentEditor.tsx
+++ b/src/components/cms/ContentEditor.tsx
@@ -1,6 +1,6 @@
 'use client';
 
-import React from 'react';
+import React, { useState, useEffect } from 'react';
 import { RichContentEditor } from '../editor/RichContentEditor';
 import { useCMS } from '@/hooks/useCMS';
 
@@ -15,40 +15,87 @@ interface ContentEditorProps {
  */
 export const ContentEditor: React.FC<ContentEditorProps> = ({ moduleId, lessonId }) => {
   const { course, updateLessonContent } = useCMS();
+  const [lastSaved, setLastSaved] = useState<Date | null>(null);
+  const [saveStatus, setSaveStatus] = useState<'idle' | 'saving' | 'saved' | 'error'>('idle');
 
   // Find the lesson in the course structure
   const currentModule = course.modules.find((m) => m.id === moduleId);
   const lesson = currentModule?.lessons.find((l) => l.id === lessonId);
 
   const handleUpdate = (content: string) => {
+    setSaveStatus('saving');
     updateLessonContent(moduleId, lessonId, content);
+    
+    // Simulate save completion
+    setTimeout(() => {
+      setLastSaved(new Date());
+      setSaveStatus('saved');
+      
+      // Reset to idle after 2 seconds
+      setTimeout(() => {
+        setSaveStatus('idle');
+      }, 2000);
+    }, 500);
   };
 
   if (!lesson) {
     return (
-      <div className="flex items-center justify-center h-full text-gray-500">
+      <div className="flex items-center justify-center h-full text-gray-500" role="status">
         Select a lesson to start editing.
       </div>
     );
   }
 
+  const getStatusText = () => {
+    switch (saveStatus) {
+      case 'saving':
+        return 'Saving...';
+      case 'saved':
+        return 'Saved';
+      case 'error':
+        return 'Save failed';
+      default:
+        return lastSaved ? `Last saved: ${lastSaved.toLocaleTimeString()}` : 'Ready';
+    }
+  };
+
+  const getStatusColor = () => {
+    switch (saveStatus) {
+      case 'saving':
+        return 'bg-yellow-500';
+      case 'saved':
+        return 'bg-green-500';
+      case 'error':
+        return 'bg-red-500';
+      default:
+        return 'bg-gray-400';
+    }
+  };
+
   return (
     <div className="flex flex-col h-full space-y-4">
-      <div className="flex items-center justify-between px-4 py-2 bg-gray-50 dark:bg-gray-900 border-b border-gray-200 dark:border-gray-700">
+      <header className="flex items-center justify-between px-4 py-2 bg-gray-50 dark:bg-gray-900 border-b border-gray-200 dark:border-gray-700">
         <h2 className="text-lg font-semibold text-gray-800 dark:text-white">
           Editing: <span className="text-blue-500">{lesson.title}</span>
         </h2>
         <div className="flex items-center space-x-2">
-          <span className="text-xs text-gray-400">
-            Last saved: {new Date().toLocaleTimeString()}
+          <span 
+            aria-live="polite" 
+            aria-atomic="true"
+            className="text-xs text-gray-400"
+          >
+            {getStatusText()}
           </span>
-          <div className="w-2 h-2 bg-green-500 rounded-full animate-pulse" />
+          <div 
+            className={`w-2 h-2 rounded-full ${getStatusColor()} ${saveStatus === 'saving' ? 'animate-pulse' : ''}`}
+            aria-hidden="true"
+          />
         </div>
-      </div>
+      </header>
 
-      <div className="flex-1 overflow-hidden">
+      <main className="flex-1 overflow-hidden">
         <RichContentEditor initialContent={lesson.content} onUpdate={handleUpdate} />
-      </div>
+      </main>
     </div>
   );
 };
diff --git a/src/components/editor/CollaborativeEditingTools.tsx b/src/components/editor/CollaborativeEditingTools.tsx
index 123c7f72..dfe9d22b 100644
--- a/src/components/editor/CollaborativeEditingTools.tsx
+++ b/src/components/editor/CollaborativeEditingTools.tsx
@@ -8,23 +8,31 @@ const COLLABORATORS = [
 ];
 
 export const CollaborativeEditingTools: React.FC = () => {
+  const collaboratorNames = COLLABORATORS.map(c => c.name).join(', ');
+
   return (
-    <div className="flex items-center gap-2">
-      <div className="flex -space-x-2" role="list" aria-label="Active collaborators">
-        {COLLABORATORS.map((user) => (
+    <div className="flex items-center gap-2" role="group" aria-label="Collaborative editing">
+      <div 
+        className="flex -space-x-2" 
+        role="list" 
+        aria-label={`Active collaborators: ${collaboratorNames}`}
+      >
+        {COLLABORATORS.map((user, index) => (
           // eslint-disable-next-line @next/next/no-img-element
           <img
             key={user.id}
             role="listitem"
             src={user.avatar}
-            alt={`${user.name} is editing`}
-            title={`${user.name} is editing`}
-            className="w-8 h-8 rounded-full border-2 border-white dark:border-gray-800"
+            alt={`${user.name}, collaborator ${index + 1} of ${COLLABORATORS.length}`}
+            title={user.name}
+            className="w-8 h-8 rounded-full border-2 border-white dark:border-gray-800 focus:outline-none focus:ring-2 focus:ring-blue-500"
+            tabIndex={0}
           />
         ))}
       </div>
       <span
-        aria-label={`${COLLABORATORS.length} active collaborators`}
+        role="status"
+        aria-live="polite"
         className="text-xs text-green-500 font-medium px-2 py-1 bg-green-100 dark:bg-green-900 rounded-full"
       >
         {COLLABORATORS.length} active
diff --git a/src/components/editor/ContentTemplateLibrary.tsx b/src/components/editor/ContentTemplateLibrary.tsx
index 53929e89..7e08227c 100644
--- a/src/components/editor/ContentTemplateLibrary.tsx
+++ b/src/components/editor/ContentTemplateLibrary.tsx
@@ -13,44 +13,47 @@ export const ContentTemplateLibrary: React.FC<ContentTemplateLibraryProps> = ({
   const getIcon = (id: string) => {
     switch (id) {
       case 'lesson-header':
-        return <BookOpen className="w-4 h-4" />;
+        return <BookOpen className="w-4 h-4" aria-hidden="true" />;
       case 'code-block':
-        return <Layout className="w-4 h-4" />;
+        return <Layout className="w-4 h-4" aria-hidden="true" />;
       case 'quiz-block':
-        return <ListChecks className="w-4 h-4" />;
+        return <ListChecks className="w-4 h-4" aria-hidden="true" />;
       case 'video-placeholder':
-        return <FileVideo className="w-4 h-4" />;
+        return <FileVideo className="w-4 h-4" aria-hidden="true" />;
       default:
-        return <Layout className="w-4 h-4" />;
+        return <Layout className="w-4 h-4" aria-hidden="true" />;
     }
   };
 
   return (
     <aside
-      aria-label="Content templates"
+      aria-label="Content templates sidebar"
       className="p-4 bg-gray-50 dark:bg-gray-900 border-l border-gray-200 dark:border-gray-700 h-full w-64 hidden lg:block"
     >
-      <h3 className="font-semibold text-sm text-gray-500 uppercase mb-4 tracking-wider">
+      <h2 className="font-semibold text-sm text-gray-500 uppercase mb-4 tracking-wider">
         Templates
-      </h3>
-      <div className="space-y-2">
-        {TEMPLATES.map((template) => (
-          <button
-            key={template.id}
-            onClick={() => insertTemplate(editor, template.id)}
-            aria-label={`Insert ${template.name} template: ${template.description}`}
-            className="w-full flex items-center gap-3 p-3 text-left rounded-lg bg-white dark:bg-gray-800 hover:bg-blue-50 dark:hover:bg-gray-700 border border-gray-200 dark:border-gray-700 transition-colors group"
-          >
-            <div className="text-gray-500 group-hover:text-blue-500" aria-hidden="true">
-              {getIcon(template.id)}
-            </div>
-            <div>
-              <div className="font-medium text-sm">{template.name}</div>
-              <div className="text-xs text-gray-400 truncate w-32">{template.description}</div>
-            </div>
-          </button>
-        ))}
-      </div>
+      </h2>
+      <nav aria-label="Template selection">
+        <ul className="space-y-2" role="list">
+          {TEMPLATES.map((template) => (
+            <li key={template.id}>
+              <button
+                onClick={() => insertTemplate(editor, template.id)}
+                aria-label={`Insert ${template.name} template: ${template.description}`}
+                className="w-full flex items-center gap-3 p-3 text-left rounded-lg bg-white dark:bg-gray-800 hover:bg-blue-50 dark:hover:bg-gray-700 border border-gray-200 dark:border-gray-700 transition-colors group focus:outline-none focus:ring-2 focus:ring-blue-500"
+              >
+                <div className="text-gray-500 group-hover:text-blue-500">
+                  {getIcon(template.id)}
+                </div>
+                <div>
+                  <div className="font-medium text-sm">{template.name}</div>
+                  <div className="text-xs text-gray-400 truncate w-32">{template.description}</div>
+                </div>
+              </button>
+            </li>
+          ))}
+        </ul>
+      </nav>
     </aside>
   );
 };
diff --git a/src/components/editor/MediaEmbedder.tsx b/src/components/editor/MediaEmbedder.tsx
index d64e1239..c3fba171 100644
--- a/src/components/editor/MediaEmbedder.tsx
+++ b/src/components/editor/MediaEmbedder.tsx
@@ -1,4 +1,4 @@
-import React, { useState } from 'react';
+import React, { useState, useEffect, useRef } from 'react';
 import { Image as ImageIcon, Youtube as YoutubeIcon } from 'lucide-react';
 import { sanitizeUrl } from '@/utils/sanitize';
 
@@ -14,6 +14,63 @@ export const MediaEmbedder: React.FC<MediaEmbedderProps> = ({ onAddImage, onAddY
   const [urlError, setUrlError] = useState('');
   const dialogTitleId = 'media-embedder-title';
   const errorId = 'media-embedder-error';
+  const dialogRef = useRef<HTMLDivElement>(null);
+  const triggerButtonRef = useRef<HTMLButtonElement>(null);
+
+  // Focus trap implementation
+  useEffect(() => {
+    if (!isOpen) return;
+
+    const dialog = dialogRef.current;
+    if (!dialog) return;
+
+    const focusableElements = dialog.querySelectorAll(
+      'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])'
+    );
+    const firstElement = focusableElements[0] as HTMLElement;
+    const lastElement = focusableElements[focusableElements.length - 1] as HTMLElement;
+
+    // Focus first element when dialog opens
+    firstElement?.focus();
+
+    const handleTab = (e: KeyboardEvent) => {
+      if (e.key !== 'Tab') return;
+
+      if (e.shiftKey) {
+        if (document.activeElement === firstElement) {
+          e.preventDefault();
+          lastElement?.focus();
+        }
+      } else {
+        if (document.activeElement === lastElement) {
+          e.preventDefault();
+          firstElement?.focus();
+        }
+      }
+    };
+
+    const handleEscape = (e: KeyboardEvent) => {
+      if (e.key === 'Escape') {
+        setIsOpen(false);
+        triggerButtonRef.current?.focus();
+      }
+    };
+
+    document.addEventListener('keydown', handleTab);
+    document.addEventListener('keydown', handleEscape);
+
+    return () => {
+      document.removeEventListener('keydown', handleTab);
+      document.removeEventListener('keydown', handleEscape);
+    };
+  }, [isOpen]);
+
+  // Return focus to trigger button when dialog closes
+  useEffect(() => {
+    if (!isOpen && triggerButtonRef.current) {
+      triggerButtonRef.current.focus();
+    }
+  }, [isOpen]);
 
   const handleSubmit = (e: React.FormEvent) => {
     e.preventDefault();
@@ -32,10 +89,17 @@ export const MediaEmbedder: React.FC<MediaEmbedderProps> = ({ onAddImage, onAddY
     setIsOpen(false);
   };
 
+  const handleCancel = () => {
+    setUrl('');
+    setUrlError('');
+    setIsOpen(false);
+  };
+
   if (!isOpen) {
     return (
       <div className="flex gap-2">
         <button
+          ref={triggerButtonRef}
           onClick={() => {
             setType('image');
             setIsOpen(true);
@@ -68,7 +132,7 @@ export const MediaEmbedder: React.FC<MediaEmbedderProps> = ({ onAddImage, onAddY
       aria-labelledby={dialogTitleId}
       className="fixed inset-0 z-50 flex items-center justify-center bg-black/50"
     >
-      <div className="bg-white dark:bg-gray-800 p-6 rounded-lg shadow-lg w-96">
+      <div ref={dialogRef} className="bg-white dark:bg-gray-800 p-6 rounded-lg shadow-lg w-96">
         <h3 id={dialogTitleId} className="text-lg font-bold mb-4">
           Add {type === 'image' ? 'Image' : 'YouTube Video'}
         </h3>
@@ -87,6 +151,7 @@ export const MediaEmbedder: React.FC<MediaEmbedderProps> = ({ onAddImage, onAddY
             placeholder={`Enter ${type} URL...`}
             className="w-full p-2 border rounded mb-1 dark:bg-gray-700 dark:border-gray-600"
             aria-describedby={errorId}
+            aria-invalid={!!urlError}
             required
           />
           <p
@@ -100,7 +165,7 @@ export const MediaEmbedder: React.FC<MediaEmbedderProps> = ({ onAddImage, onAddY
           <div className="flex justify-end gap-2">
             <button
               type="button"
-              onClick={() => setIsOpen(false)}
+              onClick={handleCancel}
               className="px-4 py-2 text-gray-600 hover:bg-gray-100 rounded"
             >
               Cancel
diff --git a/src/components/editor/RichContentEditor.tsx b/src/components/editor/RichContentEditor.tsx
index 7c39e679..7ef3f0b2 100644
--- a/src/components/editor/RichContentEditor.tsx
+++ b/src/components/editor/RichContentEditor.tsx
@@ -1,4 +1,4 @@
-import React from 'react';
+import React, { useEffect } from 'react';
 import { EditorContent } from '@tiptap/react';
 import {
   Bold,
@@ -12,6 +12,7 @@ import {
   Redo,
   Heading1,
   Heading2,
+  Keyboard,
 } from 'lucide-react';
 import { useContentEditor } from '@/hooks/useContentEditor';
 import { MediaEmbedder } from './MediaEmbedder';
@@ -32,6 +33,66 @@ export const RichContentEditor: React.FC<RichContentEditorProps> = ({
     onUpdate,
   });
 
+  // Keyboard shortcuts
+  useEffect(() => {
+    if (!editor) return;
+
+    const handleKeyDown = (e: KeyboardEvent) => {
+      // Don't trigger shortcuts when typing in input fields
+      if (
+        e.target instanceof HTMLInputElement ||
+        e.target instanceof HTMLTextAreaElement
+      ) {
+        return;
+      }
+
+      // Ctrl/Cmd + B: Bold
+      if ((e.ctrlKey || e.metaKey) && e.key === 'b') {
+        e.preventDefault();
+        editor.chain().focus().toggleBold().run();
+      }
+
+      // Ctrl/Cmd + I: Italic
+      if ((e.ctrlKey || e.metaKey) && e.key === 'i') {
+        e.preventDefault();
+        editor.chain().focus().toggleItalic().run();
+      }
+
+      // Ctrl/Cmd + U: Underline (if supported)
+      if ((e.ctrlKey || e.metaKey) && e.key === 'u') {
+        e.preventDefault();
+        editor.chain().focus().toggleStrike().run();
+      }
+
+      // Ctrl/Cmd + K: Insert link (placeholder)
+     if ((e.ctrlKey || e.metaKey) && e.key === 'k') {
+        e.preventDefault();
+        // Future: Add link insertion dialog
+      }
+
+      // Ctrl/Cmd + Z: Undo
+      if ((e.ctrlKey || e.metaKey) && e.key === 'z' && !e.shiftKey) {
+        e.preventDefault();
+        editor.chain().focus().undo().run();
+      }
+
+      // Ctrl/Cmd + Shift + Z: Redo
+      if ((e.ctrlKey || e.metaKey) && e.shiftKey && e.key === 'z') {
+        e.preventDefault();
+        editor.chain().focus().redo().run();
+      }
+
+      // Ctrl/Cmd + Y: Redo (alternative)
+      if ((e.ctrlKey || e.metaKey) && e.key === 'y') {
+        e.preventDefault();
+        editor.chain().focus().redo().run();
+      }
+    };
+
+    document.addEventListener('keydown', handleKeyDown);
+    return () => document.removeEventListener('keydown', handleKeyDown);
+  }, [editor]);
+
   if (!editor) {
     return null;
   }
@@ -66,33 +127,40 @@ export const RichContentEditor: React.FC<RichContentEditorProps> = ({
   return (
     <div className="flex h-[calc(100vh-100px)] bg-white dark:bg-gray-800 rounded-xl shadow-sm border border-gray-200 dark:border-gray-700 overflow-hidden">
       <div className="flex flex-col flex-1 w-full min-w-0">
+        {/* Skip to editor link */}
+        <a
+          href="#editor-content"
+          className="sr-only focus:not-sr-only focus:absolute focus:top-2 focus:left-2 focus:z-50 focus:bg-blue-600 focus:text-white focus:px-4 focus:py-2 focus:rounded"
+        >
+          Skip to editor content
+        </a>
+
         {/* Toolbar */}
-        <div
-          role="toolbar"
-          aria-label="Text formatting"
+        <nav
+          aria-label="Text formatting toolbar"
           className="flex items-center justify-between p-2 border-b border-gray-200 dark:border-gray-700 bg-gray-50 dark:bg-gray-900 overflow-x-auto"
         >
           <div className="flex items-center gap-1">
             <ToolbarButton
               onClick={() => editor.chain().focus().toggleBold().run()}
               isActive={editor.isActive('bold')}
-              title="Bold"
+              title="Bold (Ctrl+B)"
             >
-              <Bold className="w-4 h-4" />
+              <Bold className="w-4 h-4" aria-hidden="true" />
             </ToolbarButton>
             <ToolbarButton
               onClick={() => editor.chain().focus().toggleItalic().run()}
               isActive={editor.isActive('italic')}
-              title="Italic"
+              title="Italic (Ctrl+I)"
             >
-              <Italic className="w-4 h-4" />
+              <Italic className="w-4 h-4" aria-hidden="true" />
             </ToolbarButton>
             <ToolbarButton
               onClick={() => editor.chain().focus().toggleStrike().run()}
               isActive={editor.isActive('strike')}
-              title="Strike"
+              title="Strikethrough (Ctrl+U)"
             >
-              <Strikethrough className="w-4 h-4" />
+              <Strikethrough className="w-4 h-4" aria-hidden="true" />
             </ToolbarButton>
             <div className="w-px h-6 bg-gray-300 dark:bg-gray-700 mx-1" aria-hidden="true" />
             <ToolbarButton
@@ -100,14 +168,14 @@ export const RichContentEditor: React.FC<RichContentEditorProps> = ({
               isActive={editor.isActive('heading', { level: 1 })}
               title="Heading 1"
             >
-              <Heading1 className="w-4 h-4" />
+              <Heading1 className="w-4 h-4" aria-hidden="true" />
             </ToolbarButton>
             <ToolbarButton
               onClick={() => editor.chain().focus().toggleHeading({ level: 2 }).run()}
               isActive={editor.isActive('heading', { level: 2 })}
               title="Heading 2"
             >
-              <Heading2 className="w-4 h-4" />
+              <Heading2 className="w-4 h-4" aria-hidden="true" />
             </ToolbarButton>
             <div className="w-px h-6 bg-gray-300 dark:bg-gray-700 mx-1" aria-hidden="true" />
             <ToolbarButton
@@ -115,14 +183,14 @@ export const RichContentEditor: React.FC<RichContentEditorProps> = ({
               isActive={editor.isActive('bulletList')}
               title="Bullet List"
             >
-              <List className="w-4 h-4" />
+              <List className="w-4 h-4" aria-hidden="true" />
             </ToolbarButton>
             <ToolbarButton
               onClick={() => editor.chain().focus().toggleOrderedList().run()}
               isActive={editor.isActive('orderedList')}
               title="Ordered List"
             >
-              <ListOrdered className="w-4 h-4" />
+              <ListOrdered className="w-4 h-4" aria-hidden="true" />
             </ToolbarButton>
             <div className="w-px h-6 bg-gray-300 dark:bg-gray-700 mx-1" aria-hidden="true" />
             <ToolbarButton
@@ -130,14 +198,14 @@ export const RichContentEditor: React.FC<RichContentEditorProps> = ({
               isActive={editor.isActive('codeBlock')}
               title="Code Block"
             >
-              <CodeIcon className="w-4 h-4" />
+              <CodeIcon className="w-4 h-4" aria-hidden="true" />
             </ToolbarButton>
             <ToolbarButton
               onClick={() => editor.chain().focus().toggleBlockquote().run()}
               isActive={editor.isActive('blockquote')}
-              title="Quote"
+              title="Blockquote"
             >
-              <Quote className="w-4 h-4" />
+              <Quote className="w-4 h-4" aria-hidden="true" />
             </ToolbarButton>
             <div className="w-px h-6 bg-gray-300 dark:bg-gray-700 mx-1" aria-hidden="true" />
             <MediaEmbedder onAddImage={addImage} onAddYoutube={addYoutubeVideo} />
@@ -145,28 +213,31 @@ export const RichContentEditor: React.FC<RichContentEditorProps> = ({
             <ToolbarButton
               onClick={() => editor.chain().focus().undo().run()}
               disabled={!editor.can().undo()}
-              title="Undo"
+              title="Undo (Ctrl+Z)"
             >
-              <Undo className="w-4 h-4" />
+              <Undo className="w-4 h-4" aria-hidden="true" />
             </ToolbarButton>
             <ToolbarButton
               onClick={() => editor.chain().focus().redo().run()}
               disabled={!editor.can().redo()}
-              title="Redo"
+              title="Redo (Ctrl+Y)"
             >
-              <Redo className="w-4 h-4" />
+              <Redo className="w-4 h-4" aria-hidden="true" />
             </ToolbarButton>
           </div>
 
-          <div className="ml-4">
+          <div className="ml-4 flex items-center gap-2">
             <CollaborativeEditingTools />
           </div>
-        </div>
+        </nav>
 
         {/* Editor Content */}
         <div
-          className="flex-1 overflow-y-auto bg-white dark:bg-gray-800"
+          id="editor-content"
+          role="region"
           aria-label="Post content editor"
+          tabIndex={-1}
+          className="flex-1 overflow-y-auto bg-white dark:bg-gray-800"
         >
           <EditorContent editor={editor} className="h-full p-8" />
         </div>
diff --git a/src/services/errorReporting.ts b/src/services/errorReporting.ts
index e08b2f52..11b00a0d 100644
--- a/src/services/errorReporting.ts
+++ b/src/services/errorReporting.ts
@@ -4,6 +4,9 @@
  */
 
 import { formatErrorForLogging } from '@/utils/errorUtils';
+import { createLogger } from '@/lib/logging';
+
+const logger = createLogger('errorReporting');
 
 export interface ErrorReport {
   id: string;
@@ -34,6 +37,9 @@ class ErrorReportingService {
     this.sessionId = this.generateSessionId();
     this.isProduction = typeof process !== 'undefined' && process.env?.NODE_ENV === 'production';
     this.setupGlobalErrorHandlers();
+    logger.info('ErrorReportingService initialized', {
+      context: { sessionId: this.sessionId, isProduction: this.isProduction },
+    });
   }
 
   /**
@@ -93,10 +99,18 @@ class ErrorReportingService {
   async reportError(error: any, context?: Record<string, any>): Promise<ErrorReport> {
     const report = this.createErrorReport(error, context);
 
-    // Log to console in development
-    if (!this.isProduction) {
-      console.error('Error Report:', report);
-    }
+    // Log to structured logger
+    logger.error('Error reported', {
+      context: {
+        reportId: report.id,
+        errorType: report.errorData.type,
+        errorMessage: report.errorData.message,
+        userId: report.userId,
+        sessionId: report.sessionId,
+        ...context,
+      },
+      error,
+    });
 
     // Send to error tracking service (e.g., Sentry, LogRocket)
     if (this.isProduction) {
@@ -142,10 +156,12 @@ class ErrorReportingService {
       });
 
       if (!response.ok) {
-        console.error('Failed to send error report:', response.statusText);
+        logger.warn('Failed to send error report', {
+          context: { status: response.status, statusText: response.statusText },
+        });
       }
     } catch (err) {
-      console.error('Error sending error report:', err);
+      logger.error('Error sending error report', { error: err });
     }
   }
 
diff --git a/src/workers/__tests__/sms-cluster-worker.test.ts b/src/workers/__tests__/sms-cluster-worker.test.ts
index 8a1adc96..a4340225 100644
--- a/src/workers/__tests__/sms-cluster-worker.test.ts
+++ b/src/workers/__tests__/sms-cluster-worker.test.ts
@@ -1,5 +1,11 @@
 import cluster from 'cluster';
-import { startSMSClusterWorker } from '../sms-cluster-worker';
+import { 
+  startSMSClusterWorker, 
+  sanitizeAndValidateSMS, 
+  getSecurityEvents,
+  getQueueSize,
+  getRateLimitStatus 
+} from '../sms-cluster-worker';
 
 jest.mock('cluster', () => ({
   isPrimary: true,
@@ -14,41 +20,172 @@ jest.mock('os', () => ({
 describe('SMS Cluster Worker', () => {
   beforeEach(() => {
     jest.clearAllMocks();
+    // Clear security events before each test
+    const events = getSecurityEvents();
+    events.length = 0;
   });
 
-  it('should fork a worker for each CPU if primary', () => {
-    // Override cluster.isPrimary just in case
-    Object.defineProperty(cluster, 'isPrimary', { value: true, configurable: true });
+  describe('Cluster Management', () => {
+    it('should fork a worker for each CPU if primary', () => {
+      Object.defineProperty(cluster, 'isPrimary', { value: true, configurable: true });
 
-    const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
 
-    startSMSClusterWorker();
+      startSMSClusterWorker();
 
-    expect(cluster.fork).toHaveBeenCalledTimes(4);
-    expect(consoleSpy).toHaveBeenCalledWith(
-      expect.stringContaining('Setting up cluster with 4 workers'),
-    );
+      expect(cluster.fork).toHaveBeenCalledTimes(4);
+      expect(consoleSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Setting up cluster with 4 workers'),
+      );
 
-    consoleSpy.mockRestore();
+      consoleSpy.mockRestore();
+    });
+
+    it('should bind an exit handler to auto-heal workers', () => {
+      Object.defineProperty(cluster, 'isPrimary', { value: true, configurable: true });
+
+      startSMSClusterWorker();
+
+      expect(cluster.on).toHaveBeenCalledWith('exit', expect.any(Function));
+    });
+
+    it('should execute worker logic if not primary', () => {
+      Object.defineProperty(cluster, 'isPrimary', { value: false, configurable: true });
+      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+
+      startSMSClusterWorker();
+
+      expect(cluster.fork).not.toHaveBeenCalled();
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Worker'));
+
+      consoleSpy.mockRestore();
+    });
+
+    it('should set worker resource limits', () => {
+      Object.defineProperty(cluster, 'isPrimary', { value: true, configurable: true });
+
+      startSMSClusterWorker();
+
+      expect(cluster.fork).toHaveBeenCalledWith(
+        expect.objectContaining({
+          WORKER_ID: expect.any(Number),
+          NODE_OPTIONS: expect.stringContaining('--max-old-space-size=512'),
+        })
+      );
+    });
   });
 
-  it('should bind an exit handler to auto-heal workers', () => {
-    Object.defineProperty(cluster, 'isPrimary', { value: true, configurable: true });
+  describe('Input Validation', () => {
+    it('should validate correct phone numbers', () => {
+      const result = sanitizeAndValidateSMS('+15551234567', 'Test message');
+      expect(result.valid).toBe(true);
+      expect(result.sanitized).toBeDefined();
+    });
+
+    it('should reject invalid phone number format', () => {
+      const result = sanitizeAndValidateSMS('5551234567', 'Test message');
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain('Invalid phone number format');
+    });
 
-    startSMSClusterWorker();
+    it('should reject phone numbers that are too long', () => {
+      const result = sanitizeAndValidateSMS('+155512345678901234567', 'Test message');
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain('too long');
+    });
 
-    expect(cluster.on).toHaveBeenCalledWith('exit', expect.any(Function));
+    it('should reject non-string phone numbers', () => {
+      const result = sanitizeAndValidateSMS(1234567890 as any, 'Test message');
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain('must be a string');
+    });
+
+    it('should reject empty messages', () => {
+      const result = sanitizeAndValidateSMS('+15551234567', '');
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain('cannot be empty');
+    });
+
+    it('should reject messages that are too long', () => {
+      const longMessage = 'a'.repeat(2000);
+      const result = sanitizeAndValidateSMS('+15551234567', longMessage);
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain('too long');
+    });
+
+    it('should sanitize message content', () => {
+      const result = sanitizeAndValidateSMS('+15551234567', '<script>alert("xss")</script>');
+      expect(result.valid).toBe(true);
+      expect(result.sanitized?.message).not.toContain('<script>');
+    });
+  });
+
+  describe('Rate Limiting', () => {
+    it('should allow messages within rate limit', () => {
+      for (let i = 0; i < 50; i++) {
+        const result = sanitizeAndValidateSMS('+15551234567', `Test message ${i}`);
+        expect(result.valid).toBe(true);
+      }
+    });
+
+    it('should enforce rate limit after threshold', () => {
+      // Send 100 messages (should hit the limit)
+      for (let i = 0; i < 100; i++) {
+        sanitizeAndValidateSMS('+15551234567', `Test message ${i}`);
+      }
+
+      // 101st message should be rate limited
+      const result = sanitizeAndValidateSMS('+15551234567', 'Test message 100');
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain('Rate limit exceeded');
+    });
+
+    it('should track rate limit status correctly', () => {
+      for (let i = 0; i < 50; i++) {
+        sanitizeAndValidateSMS('+15551234567', `Test message ${i}`);
+      }
+
+      const status = getRateLimitStatus('+15551234567');
+      expect(status.remaining).toBeLessThanOrEqual(50);
+      expect(status.resetTime).toBeGreaterThan(Date.now());
+    });
   });
 
-  it('should execute worker logic if not primary', () => {
-    Object.defineProperty(cluster, 'isPrimary', { value: false, configurable: true });
-    const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+  describe('Security Event Logging', () => {
+    it('should log validation failures', () => {
+      sanitizeAndValidateSMS('invalid', 'Test message');
+      const events = getSecurityEvents();
+      
+      expect(events.length).toBeGreaterThan(0);
+      expect(events[events.length - 1].type).toBe('validation_failure');
+    });
 
-    startSMSClusterWorker();
+    it('should log rate limit exceeded events', () => {
+      for (let i = 0; i < 101; i++) {
+        sanitizeAndValidateSMS('+15551234567', `Test message ${i}`);
+      }
+      
+      const events = getSecurityEvents();
+      const rateLimitEvents = events.filter(e => e.type === 'rate_limit_exceeded');
+      expect(rateLimitEvents.length).toBeGreaterThan(0);
+    });
 
-    expect(cluster.fork).not.toHaveBeenCalled();
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Worker'));
+    it('should limit security event history size', () => {
+      // Generate more than 1000 events
+      for (let i = 0; i < 1100; i++) {
+        sanitizeAndValidateSMS(`+155512345${i % 100}`, `Test message ${i}`);
+      }
+      
+      const events = getSecurityEvents();
+      expect(events.length).toBeLessThanOrEqual(1000);
+    });
+  });
 
-    consoleSpy.mockRestore();
+  describe('Queue Management', () => {
+    it('should return current queue size', () => {
+      const size = getQueueSize();
+      expect(typeof size).toBe('number');
+      expect(size).toBeGreaterThanOrEqual(0);
+    });
   });
 });
diff --git a/src/workers/sms-cluster-worker.ts b/src/workers/sms-cluster-worker.ts
index c6c789dc..b3534d59 100644
--- a/src/workers/sms-cluster-worker.ts
+++ b/src/workers/sms-cluster-worker.ts
@@ -1,15 +1,60 @@
 import cluster from 'cluster';
 import os from 'os';
 import { sendSMS } from '../utils/notificationUtils'; // Assuming we have this or we'll mock it
+import { sanitizeString } from '../lib/security';
 
 const numCPUs = os.cpus().length;
 
-// Mock Queue implementation
+// Security Configuration
+const SECURITY_CONFIG = {
+  MAX_QUEUE_SIZE: 1000,
+  MAX_MESSAGE_LENGTH: 1600,
+  MAX_PHONE_NUMBER_LENGTH: 20,
+  RATE_LIMIT_WINDOW_MS: 60000, // 1 minute
+  RATE_LIMIT_MAX_PER_WINDOW: 100,
+  WORKER_MAX_MEMORY_MB: 512,
+  WORKER_TIMEOUT_MS: 30000,
+};
+
+// Phone number validation regex (E.164 format)
+const PHONE_NUMBER_REGEX = /^\+[1-9]\d{1,14}$/;
+
+// Rate limiting tracker
+const rateLimitTracker = new Map<string, number[]>();
+
+// Security event logger
+interface SecurityEvent {
+  type: 'validation_failure' | 'rate_limit_exceeded' | 'queue_full' | 'worker_timeout';
+  timestamp: number;
+  details: string;
+  workerId?: number;
+}
+
+const securityEvents: SecurityEvent[] = [];
+
+function logSecurityEvent(event: SecurityEvent) {
+  securityEvents.push(event);
+  console.error(`[SECURITY] ${event.type}: ${event.details}`);
+  if (securityEvents.length > 1000) {
+    securityEvents.shift(); // Keep only last 1000 events
+  }
+}
+
+// Mock Queue implementation with security controls
 class SMSQueue {
-  private messages: { to: string; message: string }[] = [];
+  private messages: { to: string; message: string; timestamp: number }[] = [];
 
-  enqueue(to: string, message: string) {
-    this.messages.push({ to, message });
+  enqueue(to: string, message: string): boolean {
+    if (this.messages.length >= SECURITY_CONFIG.MAX_QUEUE_SIZE) {
+      logSecurityEvent({
+        type: 'queue_full',
+        timestamp: Date.now(),
+        details: `Queue rejected message. Current size: ${this.messages.length}`,
+      });
+      return false;
+    }
+    this.messages.push({ to, message, timestamp: Date.now() });
+    return true;
   }
 
   dequeue() {
@@ -23,43 +68,175 @@ class SMSQueue {
 
 const smsQueue = new SMSQueue();
 
-// Seed queue for demonstration
+// Input validation and sanitization
+function validatePhoneNumber(phone: string): { valid: boolean; reason?: string } {
+  if (typeof phone !== 'string') {
+    return { valid: false, reason: 'Phone number must be a string' };
+  }
+  if (phone.length > SECURITY_CONFIG.MAX_PHONE_NUMBER_LENGTH) {
+    return { valid: false, reason: 'Phone number too long' };
+  }
+  if (!PHONE_NUMBER_REGEX.test(phone)) {
+    return { valid: false, reason: 'Invalid phone number format (must be E.164)' };
+  }
+  return { valid: true };
+}
+
+function validateMessage(message: string): { valid: boolean; reason?: string } {
+  if (typeof message !== 'string') {
+    return { valid: false, reason: 'Message must be a string' };
+  }
+  if (message.length > SECURITY_CONFIG.MAX_MESSAGE_LENGTH) {
+    return { valid: false, reason: 'Message too long' };
+  }
+  if (message.trim().length === 0) {
+    return { valid: false, reason: 'Message cannot be empty' };
+  }
+  return { valid: true };
+}
+
+function checkRateLimit(phoneNumber: string): boolean {
+  const now = Date.now();
+  const timestamps = rateLimitTracker.get(phoneNumber) || [];
+  
+  // Remove timestamps outside the rate limit window
+  const validTimestamps = timestamps.filter(t => now - t < SECURITY_CONFIG.RATE_LIMIT_WINDOW_MS);
+  
+  if (validTimestamps.length >= SECURITY_CONFIG.RATE_LIMIT_MAX_PER_WINDOW) {
+    logSecurityEvent({
+      type: 'rate_limit_exceeded',
+      timestamp: now,
+      details: `Rate limit exceeded for ${phoneNumber}: ${validTimestamps.length} requests in window`,
+    });
+    return false;
+  }
+  
+  validTimestamps.push(now);
+  rateLimitTracker.set(phoneNumber, validTimestamps);
+  return true;
+}
+
+function sanitizeAndValidateSMS(to: string, message: string): { valid: boolean; sanitized?: { to: string; message: string }; reason?: string } {
+  const phoneValidation = validatePhoneNumber(to);
+  if (!phoneValidation.valid) {
+    logSecurityEvent({
+      type: 'validation_failure',
+      timestamp: Date.now(),
+      details: `Phone validation failed: ${phoneValidation.reason}`,
+    });
+    return { valid: false, reason: phoneValidation.reason };
+  }
+
+  const messageValidation = validateMessage(message);
+  if (!messageValidation.valid) {
+    logSecurityEvent({
+      type: 'validation_failure',
+      timestamp: Date.now(),
+      details: `Message validation failed: ${messageValidation.reason}`,
+    });
+    return { valid: false, reason: messageValidation.reason };
+  }
+
+  if (!checkRateLimit(to)) {
+    return { valid: false, reason: 'Rate limit exceeded' };
+  }
+
+  // Sanitize message content
+  const sanitizedMessage = sanitizeString(message);
+
+  return {
+    valid: true,
+    sanitized: { to, message: sanitizedMessage },
+  };
+}
+
+// Seed queue for demonstration (with validation)
 for (let i = 0; i < 50; i++) {
-  smsQueue.enqueue(`+155512345${i.toString().padStart(2, '0')}`, `Test message ${i}`);
+  const phone = `+155512345${i.toString().padStart(2, '0')}`;
+  const message = `Test message ${i}`;
+  const validation = sanitizeAndValidateSMS(phone, message);
+  if (validation.valid) {
+    smsQueue.enqueue(validation.sanitized!.to, validation.sanitized!.message);
+  }
 }
 
 export const startSMSClusterWorker = () => {
   if (cluster.isPrimary) {
     console.log(`Primary ${process.pid} is running`);
     console.log(`Setting up cluster with ${numCPUs} workers for SMS processing...`);
+    console.log(`Security config: Max queue size=${SECURITY_CONFIG.MAX_QUEUE_SIZE}, Rate limit=${SECURITY_CONFIG.RATE_LIMIT_MAX_PER_WINDOW}/min`);
 
-    // Fork workers.
+    // Fork workers with resource limits
     for (let i = 0; i < numCPUs; i++) {
-      cluster.fork();
+      const worker = cluster.fork({
+        WORKER_ID: i,
+        NODE_OPTIONS: `--max-old-space-size=${SECURITY_CONFIG.WORKER_MAX_MEMORY_MB}`,
+      });
+
+      // Set worker timeout
+      setTimeout(() => {
+        if (worker.isConnected()) {
+          logSecurityEvent({
+            type: 'worker_timeout',
+            timestamp: Date.now(),
+            details: `Worker ${worker.process.pid} exceeded timeout, restarting`,
+            workerId: i,
+          });
+          worker.kill();
+        }
+      }, SECURITY_CONFIG.WORKER_TIMEOUT_MS);
     }
 
     cluster.on('exit', (worker, code, signal) => {
       console.log(`Worker ${worker.process.pid} died with code: ${code}, and signal: ${signal}`);
+      logSecurityEvent({
+        type: 'worker_timeout',
+        timestamp: Date.now(),
+        details: `Worker ${worker.process.pid} exited unexpectedly. Code: ${code}, Signal: ${signal}`,
+      });
       console.log('Starting a new worker...');
       cluster.fork(); // Auto-heal workers
     });
+
+    // Periodic security audit log
+    setInterval(() => {
+      console.log(`[SECURITY AUDIT] Queue size: ${smsQueue.length}, Active workers: ${Object.keys(cluster.workers || {}).length}`);
+      console.log(`[SECURITY AUDIT] Total security events: ${securityEvents.length}`);
+    }, 60000); // Every minute
   } else {
     // Workers can share any TCP connection
     // In this case it is an HTTP server or a message queue listener
-    console.log(`Worker ${process.pid} started for SMS processing`);
+    const workerId = process.env.WORKER_ID ? parseInt(process.env.WORKER_ID) : process.pid;
+    console.log(`Worker ${process.pid} (ID: ${workerId}) started for SMS processing`);
 
     const processQueue = async () => {
-      // Basic mock of polling a queue
       const messageJob = smsQueue.dequeue();
       if (messageJob) {
+        const startTime = Date.now();
         try {
           console.log(`[Worker ${process.pid}] Processing SMS for ${messageJob.to}...`);
+          
+          // Validate before processing (double-check)
+          const validation = sanitizeAndValidateSMS(messageJob.to, messageJob.message);
+          if (!validation.valid) {
+            console.error(`[Worker ${process.pid}] Validation failed: ${validation.reason}`);
+            return;
+          }
+
           // Note: In a real app we'd use sendSMS(messageJob.to, messageJob.message)
           // For now we just mock the delay
           await new Promise((resolve) => setTimeout(resolve, Math.random() * 500 + 100));
-          console.log(`[Worker ${process.pid}] Successfully sent SMS to ${messageJob.to}`);
+          
+          const processingTime = Date.now() - startTime;
+          console.log(`[Worker ${process.pid}] Successfully sent SMS to ${messageJob.to} in ${processingTime}ms`);
         } catch (error) {
           console.error(`[Worker ${process.pid}] Failed to send SMS:`, error);
+          logSecurityEvent({
+            type: 'validation_failure',
+            timestamp: Date.now(),
+            details: `SMS processing failed for ${messageJob.to}: ${error}`,
+            workerId,
+          });
         }
       }
 
@@ -71,6 +248,28 @@ export const startSMSClusterWorker = () => {
   }
 };
 
+// Export security functions for external use
+export { sanitizeAndValidateSMS, getSecurityEvents };
+
+export function getSecurityEvents(): SecurityEvent[] {
+  return [...securityEvents];
+}
+
+export function getQueueSize(): number {
+  return smsQueue.length;
+}
+
+export function getRateLimitStatus(phoneNumber: string): { remaining: number; resetTime: number } {
+  const now = Date.now();
+  const timestamps = rateLimitTracker.get(phoneNumber) || [];
+  const validTimestamps = timestamps.filter(t => now - t < SECURITY_CONFIG.RATE_LIMIT_WINDOW_MS);
+  const remaining = Math.max(0, SECURITY_CONFIG.RATE_LIMIT_MAX_PER_WINDOW - validTimestamps.length);
+  const oldestTimestamp = validTimestamps.length > 0 ? Math.min(...validTimestamps) : now;
+  const resetTime = oldestTimestamp + SECURITY_CONFIG.RATE_LIMIT_WINDOW_MS;
+  
+  return { remaining, resetTime };
+}
+
 // In a real entrypoint file, you'd call this:
 // if (require.main === module) {
 //   startSMSClusterWorker();