diff --git a/.claude/settings.local.json b/.claude/settings.local.json
index 8e31fa70..6f967924 100644
--- a/.claude/settings.local.json
+++ b/.claude/settings.local.json
@@ -72,7 +72,9 @@
       "Bash(SSHPASS=\"uSCO6f1y\" sshpass -e ssh -o StrictHostKeyChecking=no roodev@146.190.76.204 \"cd /home/974670.cloudwaysapps.com/uberrxmprk/public_html && wp post create --post_type=page --post_title=''Native Event Test'' --post_name=''native-event-test'' --post_status=publish --meta_input=''{\"\"_wp_page_template\"\":\"\"page-native-event-test.php\"\"}'' --format=ids\")",
       "Bash(SSHPASS=\"uSCO6f1y\" sshpass -e scp -o StrictHostKeyChecking=no /home/ben/dev/upskill-event-manager/templates/page-native-event-test.php roodev@146.190.76.204:/home/974670.cloudwaysapps.com/uberrxmprk/public_html/wp-content/plugins/hvac-community-events/templates/)",
       "Bash(SSHPASS=\"uSCO6f1y\" sshpass -e ssh -o StrictHostKeyChecking=no roodev@146.190.76.204 \"cd /home/974670.cloudwaysapps.com/uberrxmprk/public_html && wp post get 6394 --format=table\")",
-      "Bash(SSHPASS=\"uSCO6f1y\" sshpass -e ssh -o StrictHostKeyChecking=no roodev@146.190.76.204 \"cd /home/974670.cloudwaysapps.com/uberrxmprk/public_html && wp post meta list 6394 --format=table\")"
+      "Bash(SSHPASS=\"uSCO6f1y\" sshpass -e ssh -o StrictHostKeyChecking=no roodev@146.190.76.204 \"cd /home/974670.cloudwaysapps.com/uberrxmprk/public_html && wp post meta list 6394 --format=table\")",
+      "Bash(SSHPASS=\"uSCO6f1y\" sshpass -e ssh -o StrictHostKeyChecking=no roodev@146.190.76.204 \"cd /home/974670.cloudwaysapps.com/uberrxmprk/public_html && wp post get 6395 --format=table\")",
+      "Bash(SSHPASS=\"uSCO6f1y\" sshpass -e ssh -o StrictHostKeyChecking=no roodev@146.190.76.204 \"cd /home/974670.cloudwaysapps.com/uberrxmprk/public_html && wp post meta list 6395 --format=table\")"
     ],
     "deny": [],
     "ask": [],
diff --git a/assets/js/hvac-ajax-optimizer.js b/assets/js/hvac-ajax-optimizer.js
new file mode 100644
index 00000000..27ab8129
--- /dev/null
+++ b/assets/js/hvac-ajax-optimizer.js
@@ -0,0 +1,678 @@
+/**
+ * HVAC AJAX Optimizer
+ *
+ * Provides optimized AJAX handling with debouncing, caching, and rate limiting
+ * for the native WordPress event management system.
+ *
+ * @package HVAC_Community_Events
+ * @since 3.0.0
+ */
+
+(function($) {
+    'use strict';
+
+    // Configuration from localized script
+    const config = window.hvacAjax || {};
+    const ajaxUrl = config.ajaxurl;
+    const nonce = config.nonce;
+    const debounceDelay = config.debounceDelay || 300;
+    const cacheEnabled = config.cacheEnabled !== false;
+    const rateLimits = config.rateLimits || {};
+
+    // Local cache for AJAX responses
+    const cache = new Map();
+
+    // Rate limiting tracking
+    const rateLimitTracking = new Map();
+
+    /**
+     * HVAC AJAX Optimizer Class
+     */
+    class HVACAjaxOptimizer {
+        constructor() {
+            this.debounceTimers = new Map();
+            this.pendingRequests = new Map();
+            this.init();
+        }
+
+        /**
+         * Initialize the optimizer
+         */
+        init() {
+            this.bindEvents();
+            this.warmCache();
+        }
+
+        /**
+         * Bind event handlers
+         */
+        bindEvents() {
+            // Venue search with debouncing
+            $(document).on('input', '.hvac-venue-search', (e) => {
+                this.debouncedVenueSearch($(e.target));
+            });
+
+            // Organizer search with debouncing
+            $(document).on('input', '.hvac-organizer-search', (e) => {
+                this.debouncedOrganizerSearch($(e.target));
+            });
+
+            // Form validation on change
+            $(document).on('change input', '.hvac-event-form input, .hvac-event-form select, .hvac-event-form textarea', (e) => {
+                this.debouncedFormValidation($(e.target).closest('form'));
+            });
+
+            // Auto-save draft
+            $(document).on('change', '.hvac-event-form input, .hvac-event-form select, .hvac-event-form textarea', (e) => {
+                this.debouncedSaveDraft($(e.target).closest('form'));
+            });
+
+            // Image upload with progress
+            $(document).on('change', '.hvac-featured-image', (e) => {
+                this.handleImageUpload($(e.target));
+            });
+
+            // Cache management (admin only)
+            $(document).on('click', '.hvac-clear-cache', () => {
+                this.clearCache();
+            });
+
+            $(document).on('click', '.hvac-warm-cache', () => {
+                this.warmCache();
+            });
+        }
+
+        /**
+         * Debounced venue search
+         */
+        debouncedVenueSearch($input) {
+            this.debounce('venue-search', () => {
+                this.searchVenues($input);
+            }, debounceDelay);
+        }
+
+        /**
+         * Debounced organizer search
+         */
+        debouncedOrganizerSearch($input) {
+            this.debounce('organizer-search', () => {
+                this.searchOrganizers($input);
+            }, debounceDelay);
+        }
+
+        /**
+         * Debounced form validation
+         */
+        debouncedFormValidation($form) {
+            this.debounce('form-validation', () => {
+                this.validateForm($form);
+            }, debounceDelay);
+        }
+
+        /**
+         * Debounced draft saving
+         */
+        debouncedSaveDraft($form) {
+            this.debounce('save-draft', () => {
+                this.saveDraft($form);
+            }, 2000); // 2 second delay for auto-save
+        }
+
+        /**
+         * Generic debounce function
+         */
+        debounce(key, func, delay) {
+            if (this.debounceTimers.has(key)) {
+                clearTimeout(this.debounceTimers.get(key));
+            }
+
+            const timer = setTimeout(() => {
+                func();
+                this.debounceTimers.delete(key);
+            }, delay);
+
+            this.debounceTimers.set(key, timer);
+        }
+
+        /**
+         * Check rate limits before making requests
+         */
+        checkRateLimit(action) {
+            if (!rateLimits[action]) {
+                return true;
+            }
+
+            const now = Date.now();
+            const windowStart = now - 60000; // 1 minute window
+            const limit = rateLimits[action];
+
+            if (!rateLimitTracking.has(action)) {
+                rateLimitTracking.set(action, []);
+            }
+
+            const requests = rateLimitTracking.get(action);
+
+            // Remove old requests outside the window
+            const recentRequests = requests.filter(timestamp => timestamp > windowStart);
+
+            if (recentRequests.length >= limit) {
+                this.showError('Rate limit exceeded. Please slow down your requests.');
+                return false;
+            }
+
+            // Add current request
+            recentRequests.push(now);
+            rateLimitTracking.set(action, recentRequests);
+
+            return true;
+        }
+
+        /**
+         * Make optimized AJAX request
+         */
+        async makeRequest(action, data, options = {}) {
+            const {
+                method = 'GET',
+                useCache = cacheEnabled,
+                showLoader = true,
+                timeout = 10000
+            } = options;
+
+            // Check rate limits
+            if (!this.checkRateLimit(action)) {
+                return Promise.reject(new Error('Rate limit exceeded'));
+            }
+
+            // Generate cache key
+            const cacheKey = this.generateCacheKey(action, data);
+
+            // Check cache first for GET requests
+            if (method === 'GET' && useCache && cache.has(cacheKey)) {
+                const cachedData = cache.get(cacheKey);
+                if (Date.now() - cachedData.timestamp < 300000) { // 5 minute cache
+                    return Promise.resolve(cachedData.data);
+                } else {
+                    cache.delete(cacheKey);
+                }
+            }
+
+            // Cancel any pending identical request
+            if (this.pendingRequests.has(cacheKey)) {
+                this.pendingRequests.get(cacheKey).abort();
+            }
+
+            // Show loader
+            if (showLoader) {
+                this.showLoader(action);
+            }
+
+            // Prepare request data
+            const requestData = {
+                action: action,
+                nonce: nonce,
+                ...data
+            };
+
+            // Create AJAX request
+            const xhr = $.ajax({
+                url: ajaxUrl,
+                type: method,
+                data: requestData,
+                timeout: timeout,
+                dataType: 'json'
+            });
+
+            // Track pending request
+            this.pendingRequests.set(cacheKey, xhr);
+
+            try {
+                const response = await xhr;
+
+                // Remove from pending requests
+                this.pendingRequests.delete(cacheKey);
+
+                // Hide loader
+                if (showLoader) {
+                    this.hideLoader(action);
+                }
+
+                if (response.success) {
+                    // Cache successful GET responses
+                    if (method === 'GET' && useCache) {
+                        cache.set(cacheKey, {
+                            data: response,
+                            timestamp: Date.now()
+                        });
+                    }
+
+                    return response.data;
+                } else {
+                    throw new Error(response.data?.message || 'Request failed');
+                }
+            } catch (error) {
+                // Remove from pending requests
+                this.pendingRequests.delete(cacheKey);
+
+                // Hide loader
+                if (showLoader) {
+                    this.hideLoader(action);
+                }
+
+                if (error.statusText !== 'abort') {
+                    this.showError(error.message || 'Request failed');
+                }
+
+                throw error;
+            }
+        }
+
+        /**
+         * Generate cache key from action and data
+         */
+        generateCacheKey(action, data) {
+            return `${action}_${JSON.stringify(data)}`;
+        }
+
+        /**
+         * Search venues with AJAX
+         */
+        async searchVenues($input) {
+            const query = $input.val().trim();
+
+            if (query.length < 2) {
+                this.hideVenueResults();
+                return;
+            }
+
+            try {
+                const data = await this.makeRequest('hvac_search_venues', { q: query });
+                this.displayVenueResults(data.venues, $input);
+            } catch (error) {
+                console.error('Venue search failed:', error);
+            }
+        }
+
+        /**
+         * Search organizers with AJAX
+         */
+        async searchOrganizers($input) {
+            const query = $input.val().trim();
+
+            if (query.length < 2) {
+                this.hideOrganizerResults();
+                return;
+            }
+
+            try {
+                const data = await this.makeRequest('hvac_search_organizers', { q: query });
+                this.displayOrganizerResults(data.organizers, $input);
+            } catch (error) {
+                console.error('Organizer search failed:', error);
+            }
+        }
+
+        /**
+         * Validate form with AJAX
+         */
+        async validateForm($form) {
+            const formData = this.serializeForm($form);
+
+            try {
+                const data = await this.makeRequest('hvac_validate_form',
+                    { form_data: formData },
+                    { method: 'POST', showLoader: false }
+                );
+
+                this.displayValidationResults(data, $form);
+            } catch (error) {
+                console.error('Form validation failed:', error);
+            }
+        }
+
+        /**
+         * Save draft with AJAX
+         */
+        async saveDraft($form) {
+            const formData = this.serializeForm($form);
+
+            try {
+                const data = await this.makeRequest('hvac_save_draft',
+                    { form_data: formData },
+                    { method: 'POST', showLoader: false, useCache: false }
+                );
+
+                this.showSuccess('Draft saved automatically');
+
+                // Store draft ID for later use
+                $form.data('draft-id', data.draft_id);
+            } catch (error) {
+                console.error('Draft save failed:', error);
+            }
+        }
+
+        /**
+         * Handle image upload
+         */
+        async handleImageUpload($input) {
+            const file = $input[0].files[0];
+
+            if (!file) {
+                return;
+            }
+
+            // Validate file type
+            const allowedTypes = ['image/jpeg', 'image/png', 'image/webp'];
+            if (!allowedTypes.includes(file.type)) {
+                this.showError('Please select a valid image file (JPG, PNG, or WebP)');
+                $input.val('');
+                return;
+            }
+
+            // Validate file size (5MB limit)
+            if (file.size > 5 * 1024 * 1024) {
+                this.showError('Image file must be smaller than 5MB');
+                $input.val('');
+                return;
+            }
+
+            const formData = new FormData();
+            formData.append('action', 'hvac_upload_image');
+            formData.append('nonce', nonce);
+            formData.append('image', file);
+
+            // Show upload progress
+            const $progress = this.showUploadProgress($input);
+
+            try {
+                const response = await $.ajax({
+                    url: ajaxUrl,
+                    type: 'POST',
+                    data: formData,
+                    processData: false,
+                    contentType: false,
+                    xhr: () => {
+                        const xhr = new window.XMLHttpRequest();
+                        xhr.upload.addEventListener('progress', (e) => {
+                            if (e.lengthComputable) {
+                                const percentComplete = (e.loaded / e.total) * 100;
+                                $progress.find('.progress-bar').css('width', percentComplete + '%');
+                            }
+                        });
+                        return xhr;
+                    }
+                });
+
+                this.hideUploadProgress($progress);
+
+                if (response.success) {
+                    this.displayUploadedImage(response.data, $input);
+                    this.showSuccess('Image uploaded successfully');
+                } else {
+                    throw new Error(response.data?.message || 'Upload failed');
+                }
+            } catch (error) {
+                this.hideUploadProgress($progress);
+                this.showError(error.message || 'Image upload failed');
+                $input.val('');
+            }
+        }
+
+        /**
+         * Warm cache with frequently used data
+         */
+        async warmCache() {
+            try {
+                // Load timezone list
+                await this.makeRequest('hvac_get_timezone_list', {});
+
+                console.log('Cache warmed successfully');
+            } catch (error) {
+                console.error('Cache warming failed:', error);
+            }
+        }
+
+        /**
+         * Clear all caches
+         */
+        async clearCache() {
+            cache.clear();
+            rateLimitTracking.clear();
+
+            try {
+                await this.makeRequest('hvac_clear_cache', { cache_type: 'all' }, { method: 'POST' });
+                this.showSuccess('Cache cleared successfully');
+            } catch (error) {
+                console.error('Cache clear failed:', error);
+            }
+        }
+
+        /**
+         * Serialize form data to object
+         */
+        serializeForm($form) {
+            const formData = {};
+            $form.find('input, select, textarea').each(function() {
+                const $field = $(this);
+                const name = $field.attr('name');
+
+                if (name && !$field.is(':disabled')) {
+                    if ($field.is(':checkbox')) {
+                        if ($field.is(':checked')) {
+                            formData[name] = $field.val();
+                        }
+                    } else if ($field.is(':radio')) {
+                        if ($field.is(':checked')) {
+                            formData[name] = $field.val();
+                        }
+                    } else {
+                        formData[name] = $field.val();
+                    }
+                }
+            });
+
+            return formData;
+        }
+
+        /**
+         * Display venue search results
+         */
+        displayVenueResults(venues, $input) {
+            let $results = $input.siblings('.venue-results');
+
+            if ($results.length === 0) {
+                $results = $('<div class="venue-results ajax-results"></div>');
+                $input.after($results);
+            }
+
+            if (venues.length === 0) {
+                $results.html('<div class="no-results">No venues found</div>');
+                return;
+            }
+
+            const html = venues.map(venue => `
+                <div class="venue-item" data-venue-id="${venue.id}">
+                    <strong>${venue.title}</strong><br>
+                    <small>${venue.address}, ${venue.city}, ${venue.state}</small>
+                </div>
+            `).join('');
+
+            $results.html(html);
+
+            // Handle venue selection
+            $results.find('.venue-item').on('click', function() {
+                const venueId = $(this).data('venue-id');
+                const venueName = $(this).find('strong').text();
+                $input.val(venueName);
+                $input.data('venue-id', venueId);
+                $results.hide();
+            });
+        }
+
+        /**
+         * Hide venue results
+         */
+        hideVenueResults() {
+            $('.venue-results').hide();
+        }
+
+        /**
+         * Display organizer search results
+         */
+        displayOrganizerResults(organizers, $input) {
+            let $results = $input.siblings('.organizer-results');
+
+            if ($results.length === 0) {
+                $results = $('<div class="organizer-results ajax-results"></div>');
+                $input.after($results);
+            }
+
+            if (organizers.length === 0) {
+                $results.html('<div class="no-results">No organizers found</div>');
+                return;
+            }
+
+            const html = organizers.map(organizer => `
+                <div class="organizer-item" data-organizer-id="${organizer.id}">
+                    <strong>${organizer.title}</strong><br>
+                    <small>${organizer.email}</small>
+                </div>
+            `).join('');
+
+            $results.html(html);
+
+            // Handle organizer selection
+            $results.find('.organizer-item').on('click', function() {
+                const organizerId = $(this).data('organizer-id');
+                const organizerName = $(this).find('strong').text();
+                $input.val(organizerName);
+                $input.data('organizer-id', organizerId);
+                $results.hide();
+            });
+        }
+
+        /**
+         * Hide organizer results
+         */
+        hideOrganizerResults() {
+            $('.organizer-results').hide();
+        }
+
+        /**
+         * Display validation results
+         */
+        displayValidationResults(data, $form) {
+            // Clear existing errors
+            $form.find('.field-error').remove();
+            $form.find('.error').removeClass('error');
+
+            if (!data.valid && data.errors) {
+                Object.keys(data.errors).forEach(fieldName => {
+                    const $field = $form.find(`[name="${fieldName}"]`);
+                    if ($field.length) {
+                        $field.addClass('error');
+                        $field.after(`<span class="field-error">${data.errors[fieldName]}</span>`);
+                    }
+                });
+            }
+        }
+
+        /**
+         * Show upload progress
+         */
+        showUploadProgress($input) {
+            const $progress = $('<div class="upload-progress"><div class="progress-bar"></div></div>');
+            $input.after($progress);
+            return $progress;
+        }
+
+        /**
+         * Hide upload progress
+         */
+        hideUploadProgress($progress) {
+            $progress.remove();
+        }
+
+        /**
+         * Display uploaded image
+         */
+        displayUploadedImage(imageData, $input) {
+            let $preview = $input.siblings('.image-preview');
+
+            if ($preview.length === 0) {
+                $preview = $('<div class="image-preview"></div>');
+                $input.after($preview);
+            }
+
+            $preview.html(`
+                <img src="${imageData.url}" alt="Uploaded image" style="max-width: 200px; height: auto;">
+                <input type="hidden" name="uploaded_image_id" value="${imageData.attachment_id}">
+            `);
+        }
+
+        /**
+         * Show loader
+         */
+        showLoader(action) {
+            const $loader = $(`<div class="hvac-loader" data-action="${action}">Loading...</div>`);
+            $('body').append($loader);
+        }
+
+        /**
+         * Hide loader
+         */
+        hideLoader(action) {
+            $(`.hvac-loader[data-action="${action}"]`).remove();
+        }
+
+        /**
+         * Show success message
+         */
+        showSuccess(message) {
+            this.showNotification(message, 'success');
+        }
+
+        /**
+         * Show error message
+         */
+        showError(message) {
+            this.showNotification(message, 'error');
+        }
+
+        /**
+         * Show notification
+         */
+        showNotification(message, type) {
+            const $notification = $(`
+                <div class="hvac-notification ${type}">
+                    ${message}
+                    <button class="close">&times;</button>
+                </div>
+            `);
+
+            $('body').append($notification);
+
+            // Auto-hide after 5 seconds
+            setTimeout(() => {
+                $notification.fadeOut(() => $notification.remove());
+            }, 5000);
+
+            // Manual close
+            $notification.find('.close').on('click', () => {
+                $notification.fadeOut(() => $notification.remove());
+            });
+        }
+    }
+
+    // Initialize when DOM is ready
+    $(document).ready(() => {
+        window.hvacAjaxOptimizer = new HVACAjaxOptimizer();
+    });
+
+    // Hide results when clicking outside
+    $(document).on('click', (e) => {
+        if (!$(e.target).closest('.ajax-results').length && !$(e.target).hasClass('hvac-venue-search') && !$(e.target).hasClass('hvac-organizer-search')) {
+            $('.ajax-results').hide();
+        }
+    });
+
+})(jQuery);
\ No newline at end of file
diff --git a/includes/class-hvac-ajax-optimizer.php b/includes/class-hvac-ajax-optimizer.php
new file mode 100644
index 00000000..cb744aaf
--- /dev/null
+++ b/includes/class-hvac-ajax-optimizer.php
@@ -0,0 +1,524 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * HVAC AJAX Optimizer
+ *
+ * Optimizes AJAX endpoints for the native WordPress event management system
+ * Provides caching, debouncing, and performance enhancements for AJAX operations
+ *
+ * @package    HVAC_Community_Events
+ * @subpackage Includes
+ * @since      3.0.0
+ */
+
+if (!defined('ABSPATH')) {
+    exit;
+}
+
+/**
+ * Class HVAC_AJAX_Optimizer
+ *
+ * Manages optimized AJAX endpoints for event-related operations
+ */
+class HVAC_AJAX_Optimizer {
+
+    use HVAC_Singleton_Trait;
+
+    /**
+     * Cache instance
+     *
+     * @var HVAC_Event_Cache
+     */
+    private HVAC_Event_Cache $cache;
+
+    /**
+     * Rate limiting storage
+     *
+     * @var array
+     */
+    private array $rate_limits = [];
+
+    /**
+     * AJAX actions and their rate limits (requests per minute)
+     *
+     * @var array
+     */
+    private array $ajax_rate_limits = [
+        'hvac_search_venues' => 30,
+        'hvac_search_organizers' => 30,
+        'hvac_validate_form' => 60,
+        'hvac_save_draft' => 20,
+        'hvac_upload_image' => 10,
+    ];
+
+    /**
+     * Constructor
+     */
+    private function __construct() {
+        $this->cache = HVAC_Event_Cache::instance();
+        $this->init_hooks();
+    }
+
+    /**
+     * Initialize WordPress hooks
+     */
+    private function init_hooks(): void {
+        // Optimized AJAX endpoints
+        add_action('wp_ajax_hvac_search_venues', [$this, 'ajax_search_venues']);
+        add_action('wp_ajax_hvac_search_organizers', [$this, 'ajax_search_organizers']);
+        add_action('wp_ajax_hvac_validate_form', [$this, 'ajax_validate_form']);
+        add_action('wp_ajax_hvac_save_draft', [$this, 'ajax_save_draft']);
+        add_action('wp_ajax_hvac_upload_image', [$this, 'ajax_upload_image']);
+        add_action('wp_ajax_hvac_get_timezone_list', [$this, 'ajax_get_timezone_list']);
+
+        // Admin-only endpoints
+        add_action('wp_ajax_hvac_cache_stats', [$this, 'ajax_cache_stats']);
+
+        // Enqueue optimized AJAX scripts
+        add_action('wp_enqueue_scripts', [$this, 'enqueue_ajax_scripts']);
+    }
+
+    /**
+     * Enqueue optimized AJAX scripts
+     */
+    public function enqueue_ajax_scripts(): void {
+        // Only load on event-related pages
+        if (!$this->should_load_ajax_scripts()) {
+            return;
+        }
+
+        wp_enqueue_script(
+            'hvac-ajax-optimizer',
+            HVAC_PLUGIN_URL . 'assets/js/hvac-ajax-optimizer.js',
+            ['jquery'],
+            HVAC_VERSION,
+            true
+        );
+
+        // Localize script with AJAX configuration
+        wp_localize_script('hvac-ajax-optimizer', 'hvacAjax', [
+            'ajaxurl' => admin_url('admin-ajax.php'),
+            'nonce' => wp_create_nonce('hvac_ajax_nonce'),
+            'debounceDelay' => 300,
+            'cacheEnabled' => true,
+            'rateLimits' => $this->ajax_rate_limits,
+        ]);
+    }
+
+    /**
+     * Check if AJAX scripts should be loaded
+     *
+     * @return bool
+     */
+    private function should_load_ajax_scripts(): bool {
+        global $post;
+
+        // Load on event form pages
+        if (is_page() && $post) {
+            $template = get_page_template_slug($post->ID);
+            if (strpos($template, 'event') !== false) {
+                return true;
+            }
+        }
+
+        // Load on trainer/master trainer dashboards
+        if (is_user_logged_in()) {
+            $user = wp_get_current_user();
+            if (in_array('hvac_trainer', $user->roles) || in_array('hvac_master_trainer', $user->roles)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Apply rate limiting to AJAX requests
+     *
+     * @param string $action AJAX action name
+     * @return bool True if request is allowed, false if rate limited
+     */
+    private function apply_rate_limiting(string $action): bool {
+        if (!isset($this->ajax_rate_limits[$action])) {
+            return true;
+        }
+
+        $limit = $this->ajax_rate_limits[$action];
+        $user_id = get_current_user_id();
+        $client_ip = $this->get_client_ip();
+
+        // Create rate limit key based on user ID or IP
+        $rate_key = $user_id > 0 ? "user_{$user_id}_{$action}" : "ip_{$client_ip}_{$action}";
+
+        $current_time = time();
+        $window_start = $current_time - 60; // 1 minute window
+
+        // Get existing rate limit data
+        $rate_data = get_transient("hvac_rate_limit_{$rate_key}") ?: [];
+
+        // Remove old entries outside the time window
+        $rate_data = array_filter($rate_data, fn($timestamp) => $timestamp > $window_start);
+
+        // Check if limit exceeded
+        if (count($rate_data) >= $limit) {
+            return false;
+        }
+
+        // Add current request timestamp
+        $rate_data[] = $current_time;
+
+        // Store updated rate limit data
+        set_transient("hvac_rate_limit_{$rate_key}", $rate_data, 120);
+
+        return true;
+    }
+
+    /**
+     * Get client IP address
+     *
+     * @return string
+     */
+    private function get_client_ip(): string {
+        $ip_keys = ['HTTP_X_FORWARDED_FOR', 'HTTP_X_REAL_IP', 'HTTP_CLIENT_IP', 'REMOTE_ADDR'];
+
+        foreach ($ip_keys as $key) {
+            if (!empty($_SERVER[$key])) {
+                $ip = sanitize_text_field($_SERVER[$key]);
+                // Handle comma-separated IPs (from proxies)
+                if (strpos($ip, ',') !== false) {
+                    $ip = trim(explode(',', $ip)[0]);
+                }
+                if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE)) {
+                    return $ip;
+                }
+            }
+        }
+
+        return sanitize_text_field($_SERVER['REMOTE_ADDR'] ?? '');
+    }
+
+    /**
+     * AJAX handler for venue search with caching
+     */
+    public function ajax_search_venues(): void {
+        // Security and rate limiting
+        if (!wp_verify_nonce($_GET['nonce'] ?? '', 'hvac_ajax_nonce')) {
+            wp_send_json_error(['message' => 'Security check failed']);
+            return;
+        }
+
+        if (!$this->apply_rate_limiting('hvac_search_venues')) {
+            wp_send_json_error(['message' => 'Rate limit exceeded']);
+            return;
+        }
+
+        $search_query = sanitize_text_field($_GET['q'] ?? '');
+        if (empty($search_query) || strlen($search_query) < 2) {
+            wp_send_json_error(['message' => 'Search query too short']);
+            return;
+        }
+
+        // Check cache first
+        $cache_key = md5($search_query . '_' . get_current_user_id());
+        $cached_results = $this->cache->get_venue_search($cache_key);
+
+        if ($cached_results !== false) {
+            wp_send_json_success([
+                'venues' => $cached_results,
+                'cached' => true
+            ]);
+            return;
+        }
+
+        // Search venues
+        $venues = $this->search_venues($search_query);
+
+        // Cache results
+        $this->cache->cache_venue_search($cache_key, $venues);
+
+        wp_send_json_success([
+            'venues' => $venues,
+            'cached' => false
+        ]);
+    }
+
+    /**
+     * AJAX handler for organizer search with caching
+     */
+    public function ajax_search_organizers(): void {
+        // Security and rate limiting
+        if (!wp_verify_nonce($_GET['nonce'] ?? '', 'hvac_ajax_nonce')) {
+            wp_send_json_error(['message' => 'Security check failed']);
+            return;
+        }
+
+        if (!$this->apply_rate_limiting('hvac_search_organizers')) {
+            wp_send_json_error(['message' => 'Rate limit exceeded']);
+            return;
+        }
+
+        $search_query = sanitize_text_field($_GET['q'] ?? '');
+        if (empty($search_query) || strlen($search_query) < 2) {
+            wp_send_json_error(['message' => 'Search query too short']);
+            return;
+        }
+
+        // Search organizers
+        $organizers = $this->search_organizers($search_query);
+
+        wp_send_json_success(['organizers' => $organizers]);
+    }
+
+    /**
+     * AJAX handler for form validation
+     */
+    public function ajax_validate_form(): void {
+        // Security and rate limiting
+        if (!wp_verify_nonce($_POST['nonce'] ?? '', 'hvac_ajax_nonce')) {
+            wp_send_json_error(['message' => 'Security check failed']);
+            return;
+        }
+
+        if (!$this->apply_rate_limiting('hvac_validate_form')) {
+            wp_send_json_error(['message' => 'Rate limit exceeded']);
+            return;
+        }
+
+        $form_data = $_POST['form_data'] ?? [];
+
+        // Create form builder for validation
+        $form_builder = new HVAC_Event_Form_Builder('hvac_ajax_validation');
+        $form_builder->create_event_form();
+
+        // Validate the form data
+        $errors = $form_builder->validate($form_data);
+
+        wp_send_json_success([
+            'valid' => empty($errors),
+            'errors' => $errors
+        ]);
+    }
+
+    /**
+     * AJAX handler for saving draft events
+     */
+    public function ajax_save_draft(): void {
+        // Security and rate limiting
+        if (!wp_verify_nonce($_POST['nonce'] ?? '', 'hvac_ajax_nonce')) {
+            wp_send_json_error(['message' => 'Security check failed']);
+            return;
+        }
+
+        if (!$this->apply_rate_limiting('hvac_save_draft')) {
+            wp_send_json_error(['message' => 'Rate limit exceeded']);
+            return;
+        }
+
+        // Check user permissions
+        if (!is_user_logged_in()) {
+            wp_send_json_error(['message' => 'Authentication required']);
+            return;
+        }
+
+        $form_data = $_POST['form_data'] ?? [];
+
+        // Generate unique form ID for this user session
+        $form_id = 'draft_' . get_current_user_id() . '_' . time();
+
+        // Cache the form data
+        $cached = $this->cache->cache_form_data($form_id, $form_data);
+
+        if ($cached) {
+            wp_send_json_success([
+                'message' => 'Draft saved successfully',
+                'draft_id' => $form_id
+            ]);
+        } else {
+            wp_send_json_error(['message' => 'Failed to save draft']);
+        }
+    }
+
+    /**
+     * AJAX handler for image upload
+     */
+    public function ajax_upload_image(): void {
+        // Security and rate limiting
+        if (!wp_verify_nonce($_POST['nonce'] ?? '', 'hvac_ajax_nonce')) {
+            wp_send_json_error(['message' => 'Security check failed']);
+            return;
+        }
+
+        if (!$this->apply_rate_limiting('hvac_upload_image')) {
+            wp_send_json_error(['message' => 'Rate limit exceeded']);
+            return;
+        }
+
+        // Check user permissions
+        if (!current_user_can('upload_files')) {
+            wp_send_json_error(['message' => 'Insufficient permissions']);
+            return;
+        }
+
+        if (!isset($_FILES['image'])) {
+            wp_send_json_error(['message' => 'No image uploaded']);
+            return;
+        }
+
+        // Handle file upload
+        require_once ABSPATH . 'wp-admin/includes/image.php';
+        require_once ABSPATH . 'wp-admin/includes/file.php';
+        require_once ABSPATH . 'wp-admin/includes/media.php';
+
+        $attachment_id = media_handle_upload('image', 0);
+
+        if (is_wp_error($attachment_id)) {
+            wp_send_json_error(['message' => $attachment_id->get_error_message()]);
+            return;
+        }
+
+        $attachment_url = wp_get_attachment_url($attachment_id);
+        $attachment_meta = wp_get_attachment_metadata($attachment_id);
+
+        wp_send_json_success([
+            'attachment_id' => $attachment_id,
+            'url' => $attachment_url,
+            'meta' => $attachment_meta
+        ]);
+    }
+
+    /**
+     * AJAX handler for timezone list (cached)
+     */
+    public function ajax_get_timezone_list(): void {
+        // Security check
+        if (!wp_verify_nonce($_GET['nonce'] ?? '', 'hvac_ajax_nonce')) {
+            wp_send_json_error(['message' => 'Security check failed']);
+            return;
+        }
+
+        // Try cache first
+        $timezone_list = $this->cache->get_timezone_list();
+
+        if ($timezone_list === false) {
+            // Generate timezone list
+            $zones = wp_timezone_choice('UTC');
+            $timezone_list = [];
+
+            if (preg_match_all('/<option value="([^"]*)"[^>]*>([^<]*)<\/option>/', $zones, $matches)) {
+                foreach ($matches[1] as $index => $value) {
+                    $timezone_list[$value] = $matches[2][$index];
+                }
+            }
+
+            // Cache the results
+            $this->cache->cache_timezone_list($timezone_list);
+        }
+
+        wp_send_json_success([
+            'timezones' => $timezone_list,
+            'current' => wp_timezone_string()
+        ]);
+    }
+
+    /**
+     * AJAX handler for cache statistics (admin only)
+     */
+    public function ajax_cache_stats(): void {
+        // Security check
+        if (!wp_verify_nonce($_GET['nonce'] ?? '', 'hvac_ajax_nonce')) {
+            wp_send_json_error(['message' => 'Security check failed']);
+            return;
+        }
+
+        // Permission check
+        if (!current_user_can('manage_options')) {
+            wp_send_json_error(['message' => 'Insufficient permissions']);
+            return;
+        }
+
+        $stats = $this->cache->get_cache_stats();
+
+        wp_send_json_success([
+            'stats' => $stats,
+            'timestamp' => current_time('mysql')
+        ]);
+    }
+
+    /**
+     * Search venues by name or location
+     *
+     * @param string $query Search query
+     * @return array Venue results
+     */
+    private function search_venues(string $query): array {
+        $venues = get_posts([
+            'post_type' => 'tribe_venue',
+            'post_status' => 'publish',
+            'posts_per_page' => 10,
+            's' => $query,
+            'meta_query' => [
+                'relation' => 'OR',
+                [
+                    'key' => '_VenueCity',
+                    'value' => $query,
+                    'compare' => 'LIKE'
+                ],
+                [
+                    'key' => '_VenueState',
+                    'value' => $query,
+                    'compare' => 'LIKE'
+                ]
+            ]
+        ]);
+
+        $results = [];
+        foreach ($venues as $venue) {
+            $results[] = [
+                'id' => $venue->ID,
+                'title' => $venue->post_title,
+                'address' => get_post_meta($venue->ID, '_VenueAddress', true),
+                'city' => get_post_meta($venue->ID, '_VenueCity', true),
+                'state' => get_post_meta($venue->ID, '_VenueState', true),
+            ];
+        }
+
+        return $results;
+    }
+
+    /**
+     * Search organizers by name or email
+     *
+     * @param string $query Search query
+     * @return array Organizer results
+     */
+    private function search_organizers(string $query): array {
+        $organizers = get_posts([
+            'post_type' => 'tribe_organizer',
+            'post_status' => 'publish',
+            'posts_per_page' => 10,
+            's' => $query,
+            'meta_query' => [
+                [
+                    'key' => '_OrganizerEmail',
+                    'value' => $query,
+                    'compare' => 'LIKE'
+                ]
+            ]
+        ]);
+
+        $results = [];
+        foreach ($organizers as $organizer) {
+            $results[] = [
+                'id' => $organizer->ID,
+                'title' => $organizer->post_title,
+                'email' => get_post_meta($organizer->ID, '_OrganizerEmail', true),
+                'phone' => get_post_meta($organizer->ID, '_OrganizerPhone', true),
+                'website' => get_post_meta($organizer->ID, '_OrganizerWebsite', true),
+            ];
+        }
+
+        return $results;
+    }
+}
\ No newline at end of file
diff --git a/includes/class-hvac-event-cache.php b/includes/class-hvac-event-cache.php
new file mode 100644
index 00000000..a23fa1bd
--- /dev/null
+++ b/includes/class-hvac-event-cache.php
@@ -0,0 +1,543 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * HVAC Event Cache Manager
+ *
+ * Provides transient caching for event forms, venue data, and organizer information
+ * Optimizes performance for the native WordPress event management system
+ *
+ * @package    HVAC_Community_Events
+ * @subpackage Includes
+ * @since      3.0.0
+ */
+
+if (!defined('ABSPATH')) {
+    exit;
+}
+
+/**
+ * Class HVAC_Event_Cache
+ *
+ * Manages caching for event-related data and operations
+ */
+class HVAC_Event_Cache {
+
+    use HVAC_Singleton_Trait;
+
+    /**
+     * Cache key prefixes
+     *
+     * @var array
+     */
+    private array $cache_prefixes = [
+        'form_data'      => 'hvac_form_data_',
+        'venue_search'   => 'hvac_venue_search_',
+        'organizer_data' => 'hvac_organizer_data_',
+        'event_meta'     => 'hvac_event_meta_',
+        'timezone_list'  => 'hvac_timezone_list',
+        'trainer_opts'   => 'hvac_trainer_options',
+        'cert_levels'    => 'hvac_cert_levels',
+    ];
+
+    /**
+     * Default cache expiration times (in seconds)
+     *
+     * @var array
+     */
+    private array $cache_expiration = [
+        'form_data'      => 300,    // 5 minutes (temporary form data)
+        'venue_search'   => 1800,   // 30 minutes
+        'organizer_data' => 3600,   // 1 hour
+        'event_meta'     => 1800,   // 30 minutes
+        'timezone_list'  => 86400,  // 24 hours
+        'trainer_opts'   => 3600,   // 1 hour
+        'cert_levels'    => 3600,   // 1 hour
+    ];
+
+    /**
+     * Constructor
+     */
+    private function __construct() {
+        $this->init_hooks();
+    }
+
+    /**
+     * Initialize WordPress hooks
+     */
+    private function init_hooks(): void {
+        // Clear caches when events are updated
+        add_action('save_post_tribe_events', [$this, 'clear_event_cache'], 10, 2);
+        add_action('delete_post', [$this, 'clear_event_cache_on_delete'], 10);
+
+        // Clear venue/organizer caches when those are updated
+        add_action('save_post_tribe_venue', [$this, 'clear_venue_cache'], 10, 2);
+        add_action('save_post_tribe_organizer', [$this, 'clear_organizer_cache'], 10, 2);
+
+        // AJAX endpoints for cache management
+        add_action('wp_ajax_hvac_clear_cache', [$this, 'ajax_clear_cache']);
+        add_action('wp_ajax_hvac_warm_cache', [$this, 'ajax_warm_cache']);
+    }
+
+    /**
+     * Get cached data
+     *
+     * @param string $type Cache type from prefixes
+     * @param string $key Unique identifier
+     * @param callable|null $callback Callback to generate data if not cached
+     * @return mixed Cached data or false if not found
+     */
+    public function get(string $type, string $key, ?callable $callback = null): mixed {
+        if (!isset($this->cache_prefixes[$type])) {
+            return false;
+        }
+
+        $cache_key = $this->cache_prefixes[$type] . $this->sanitize_cache_key($key);
+        $cached_data = get_transient($cache_key);
+
+        if ($cached_data !== false) {
+            return $cached_data;
+        }
+
+        // If callback provided and no cached data, generate and cache it
+        if ($callback && is_callable($callback)) {
+            $data = call_user_func($callback);
+            $this->set($type, $key, $data);
+            return $data;
+        }
+
+        return false;
+    }
+
+    /**
+     * Set cached data
+     *
+     * @param string $type Cache type from prefixes
+     * @param string $key Unique identifier
+     * @param mixed $data Data to cache
+     * @param int|null $expiration Custom expiration time
+     * @return bool Success status
+     */
+    public function set(string $type, string $key, mixed $data, ?int $expiration = null): bool {
+        if (!isset($this->cache_prefixes[$type])) {
+            return false;
+        }
+
+        $cache_key = $this->cache_prefixes[$type] . $this->sanitize_cache_key($key);
+        $expiration = $expiration ?? $this->cache_expiration[$type];
+
+        return set_transient($cache_key, $data, $expiration);
+    }
+
+    /**
+     * Delete cached data
+     *
+     * @param string $type Cache type from prefixes
+     * @param string $key Unique identifier
+     * @return bool Success status
+     */
+    public function delete(string $type, string $key): bool {
+        if (!isset($this->cache_prefixes[$type])) {
+            return false;
+        }
+
+        $cache_key = $this->cache_prefixes[$type] . $this->sanitize_cache_key($key);
+        return delete_transient($cache_key);
+    }
+
+    /**
+     * Clear all cache entries for a specific type
+     *
+     * @param string $type Cache type to clear
+     * @return bool Success status
+     */
+    public function clear_type(string $type): bool {
+        if (!isset($this->cache_prefixes[$type])) {
+            return false;
+        }
+
+        global $wpdb;
+
+        $prefix = $this->cache_prefixes[$type];
+        $transient_option = "_transient_{$prefix}%";
+        $transient_timeout = "_transient_timeout_{$prefix}%";
+
+        // Delete all transients matching the prefix
+        $deleted_options = $wpdb->query(
+            $wpdb->prepare(
+                "DELETE FROM {$wpdb->options} WHERE option_name LIKE %s OR option_name LIKE %s",
+                $transient_option,
+                $transient_timeout
+            )
+        );
+
+        return $deleted_options !== false;
+    }
+
+    /**
+     * Clear all HVAC event caches
+     *
+     * @return bool Success status
+     */
+    public function clear_all(): bool {
+        $success = true;
+        foreach (array_keys($this->cache_prefixes) as $type) {
+            if (!$this->clear_type($type)) {
+                $success = false;
+            }
+        }
+        return $success;
+    }
+
+    /**
+     * Cache form data temporarily (for form repopulation on errors)
+     *
+     * @param string $form_id Unique form identifier
+     * @param array $form_data Form data to cache
+     * @return bool Success status
+     */
+    public function cache_form_data(string $form_id, array $form_data): bool {
+        // Remove sensitive data before caching
+        $safe_data = $this->sanitize_form_data_for_cache($form_data);
+        return $this->set('form_data', $form_id, $safe_data, 300); // 5 minutes
+    }
+
+    /**
+     * Get cached form data
+     *
+     * @param string $form_id Unique form identifier
+     * @return array|false Form data or false if not found
+     */
+    public function get_form_data(string $form_id): array|false {
+        return $this->get('form_data', $form_id);
+    }
+
+    /**
+     * Cache venue search results
+     *
+     * @param string $search_query Search query
+     * @param array $results Search results
+     * @return bool Success status
+     */
+    public function cache_venue_search(string $search_query, array $results): bool {
+        return $this->set('venue_search', $search_query, $results);
+    }
+
+    /**
+     * Get cached venue search results
+     *
+     * @param string $search_query Search query
+     * @return array|false Search results or false if not found
+     */
+    public function get_venue_search(string $search_query): array|false {
+        return $this->get('venue_search', $search_query);
+    }
+
+    /**
+     * Cache organizer data
+     *
+     * @param int $organizer_id Organizer post ID
+     * @param array $organizer_data Organizer data
+     * @return bool Success status
+     */
+    public function cache_organizer_data(int $organizer_id, array $organizer_data): bool {
+        return $this->set('organizer_data', (string)$organizer_id, $organizer_data);
+    }
+
+    /**
+     * Get cached organizer data
+     *
+     * @param int $organizer_id Organizer post ID
+     * @return array|false Organizer data or false if not found
+     */
+    public function get_organizer_data(int $organizer_id): array|false {
+        return $this->get('organizer_data', (string)$organizer_id);
+    }
+
+    /**
+     * Cache timezone list
+     *
+     * @param array $timezone_list WordPress timezone options
+     * @return bool Success status
+     */
+    public function cache_timezone_list(array $timezone_list): bool {
+        return $this->set('timezone_list', 'wordpress', $timezone_list);
+    }
+
+    /**
+     * Get cached timezone list
+     *
+     * @return array|false Timezone list or false if not found
+     */
+    public function get_timezone_list(): array|false {
+        return $this->get('timezone_list', 'wordpress');
+    }
+
+    /**
+     * Cache trainer requirement options
+     *
+     * @param array $options Trainer requirement options
+     * @return bool Success status
+     */
+    public function cache_trainer_options(array $options): bool {
+        return $this->set('trainer_opts', 'requirements', $options);
+    }
+
+    /**
+     * Get cached trainer requirement options
+     *
+     * @return array|false Options or false if not found
+     */
+    public function get_trainer_options(): array|false {
+        return $this->get('trainer_opts', 'requirements');
+    }
+
+    /**
+     * Cache certification level options
+     *
+     * @param array $options Certification level options
+     * @return bool Success status
+     */
+    public function cache_cert_levels(array $options): bool {
+        return $this->set('cert_levels', 'levels', $options);
+    }
+
+    /**
+     * Get cached certification level options
+     *
+     * @return array|false Options or false if not found
+     */
+    public function get_cert_levels(): array|false {
+        return $this->get('cert_levels', 'levels');
+    }
+
+    /**
+     * Warm up frequently used caches
+     *
+     * @return bool Success status
+     */
+    public function warm_cache(): bool {
+        $success = true;
+
+        // Warm timezone cache
+        if (!$this->get_timezone_list()) {
+            $zones = wp_timezone_choice('UTC');
+            $timezone_options = [];
+            if (preg_match_all('/<option value="([^"]*)"[^>]*>([^<]*)<\/option>/', $zones, $matches)) {
+                foreach ($matches[1] as $index => $value) {
+                    $timezone_options[$value] = $matches[2][$index];
+                }
+            }
+            if (!$this->cache_timezone_list($timezone_options)) {
+                $success = false;
+            }
+        }
+
+        // Warm trainer options cache
+        if (!$this->get_trainer_options()) {
+            $trainer_options = [
+                ''                    => 'No specific requirement',
+                'certified_trainer'   => 'Certified HVAC Trainer',
+                'master_trainer'      => 'Master Trainer',
+                'industry_expert'     => 'Industry Expert',
+                'manufacturer_rep'    => 'Manufacturer Representative',
+            ];
+            if (!$this->cache_trainer_options($trainer_options)) {
+                $success = false;
+            }
+        }
+
+        // Warm certification levels cache
+        if (!$this->get_cert_levels()) {
+            $cert_levels = [
+                'basic'        => 'Basic HVAC',
+                'intermediate' => 'Intermediate HVAC',
+                'advanced'     => 'Advanced HVAC',
+                'commercial'   => 'Commercial Systems',
+                'residential'  => 'Residential Systems',
+                'refrigeration' => 'Refrigeration',
+            ];
+            if (!$this->cache_cert_levels($cert_levels)) {
+                $success = false;
+            }
+        }
+
+        return $success;
+    }
+
+    /**
+     * Clear event-related caches when an event is saved
+     *
+     * @param int $post_id Event post ID
+     * @param WP_Post $post Event post object
+     */
+    public function clear_event_cache(int $post_id, WP_Post $post): void {
+        if ($post->post_type !== 'tribe_events') {
+            return;
+        }
+
+        // Clear event-specific caches
+        $this->delete('event_meta', (string)$post_id);
+
+        // Clear form data cache for this event (if editing)
+        $this->delete('form_data', 'edit_' . $post_id);
+    }
+
+    /**
+     * Clear event cache when an event is deleted
+     *
+     * @param int $post_id Post ID
+     */
+    public function clear_event_cache_on_delete(int $post_id): void {
+        $post_type = get_post_type($post_id);
+        if ($post_type === 'tribe_events') {
+            $this->delete('event_meta', (string)$post_id);
+            $this->delete('form_data', 'edit_' . $post_id);
+        }
+    }
+
+    /**
+     * Clear venue-related caches when a venue is updated
+     *
+     * @param int $post_id Venue post ID
+     * @param WP_Post $post Venue post object
+     */
+    public function clear_venue_cache(int $post_id, WP_Post $post): void {
+        if ($post->post_type !== 'tribe_venue') {
+            return;
+        }
+
+        // Clear venue search cache (all entries since we don't know which searches included this venue)
+        $this->clear_type('venue_search');
+    }
+
+    /**
+     * Clear organizer-related caches when an organizer is updated
+     *
+     * @param int $post_id Organizer post ID
+     * @param WP_Post $post Organizer post object
+     */
+    public function clear_organizer_cache(int $post_id, WP_Post $post): void {
+        if ($post->post_type !== 'tribe_organizer') {
+            return;
+        }
+
+        $this->delete('organizer_data', (string)$post_id);
+    }
+
+    /**
+     * AJAX handler to clear cache
+     */
+    public function ajax_clear_cache(): void {
+        // Verify nonce
+        if (!wp_verify_nonce($_POST['nonce'] ?? '', 'hvac_cache_management')) {
+            wp_send_json_error(['message' => 'Security check failed']);
+            return;
+        }
+
+        // Check user permissions
+        if (!current_user_can('manage_options')) {
+            wp_send_json_error(['message' => 'Insufficient permissions']);
+            return;
+        }
+
+        $cache_type = sanitize_text_field($_POST['cache_type'] ?? 'all');
+
+        if ($cache_type === 'all') {
+            $success = $this->clear_all();
+        } else {
+            $success = $this->clear_type($cache_type);
+        }
+
+        if ($success) {
+            wp_send_json_success(['message' => 'Cache cleared successfully']);
+        } else {
+            wp_send_json_error(['message' => 'Failed to clear cache']);
+        }
+    }
+
+    /**
+     * AJAX handler to warm cache
+     */
+    public function ajax_warm_cache(): void {
+        // Verify nonce
+        if (!wp_verify_nonce($_POST['nonce'] ?? '', 'hvac_cache_management')) {
+            wp_send_json_error(['message' => 'Security check failed']);
+            return;
+        }
+
+        // Check user permissions
+        if (!current_user_can('manage_options')) {
+            wp_send_json_error(['message' => 'Insufficient permissions']);
+            return;
+        }
+
+        $success = $this->warm_cache();
+
+        if ($success) {
+            wp_send_json_success(['message' => 'Cache warmed successfully']);
+        } else {
+            wp_send_json_error(['message' => 'Failed to warm cache']);
+        }
+    }
+
+    /**
+     * Get cache statistics
+     *
+     * @return array Cache statistics
+     */
+    public function get_cache_stats(): array {
+        global $wpdb;
+
+        $stats = [];
+        foreach ($this->cache_prefixes as $type => $prefix) {
+            $count = $wpdb->get_var(
+                $wpdb->prepare(
+                    "SELECT COUNT(*) FROM {$wpdb->options} WHERE option_name LIKE %s",
+                    "_transient_{$prefix}%"
+                )
+            );
+            $stats[$type] = (int)$count;
+        }
+
+        return $stats;
+    }
+
+    /**
+     * Sanitize cache key to ensure it's safe for WordPress transients
+     *
+     * @param string $key Raw cache key
+     * @return string Sanitized cache key
+     */
+    private function sanitize_cache_key(string $key): string {
+        // Remove invalid characters and limit length
+        $key = preg_replace('/[^a-zA-Z0-9_\-]/', '', $key);
+        return substr($key, 0, 40); // WordPress transient key limit
+    }
+
+    /**
+     * Sanitize form data before caching (remove sensitive information)
+     *
+     * @param array $form_data Raw form data
+     * @return array Sanitized form data
+     */
+    private function sanitize_form_data_for_cache(array $form_data): array {
+        $safe_data = $form_data;
+
+        // Remove sensitive fields that should not be cached
+        $sensitive_fields = [
+            'hvac_event_form_nonce',
+            'password',
+            'user_password',
+            'credit_card',
+            'ssn',
+        ];
+
+        foreach ($sensitive_fields as $field) {
+            unset($safe_data[$field]);
+        }
+
+        return $safe_data;
+    }
+}
\ No newline at end of file
diff --git a/includes/class-hvac-event-form-builder.php b/includes/class-hvac-event-form-builder.php
index a060cf02..e035d011 100644
--- a/includes/class-hvac-event-form-builder.php
+++ b/includes/class-hvac-event-form-builder.php
@@ -55,6 +55,13 @@ class HVAC_Event_Form_Builder extends HVAC_Form_Builder {
      */
     private ?array $timezone_list = null;
 
+    /**
+     * Cache instance
+     *
+     * @var HVAC_Event_Cache|null
+     */
+    private ?HVAC_Event_Cache $cache = null;
+
     /**
      * Constructor with promoted property.
      *
@@ -72,7 +79,10 @@ class HVAC_Event_Form_Builder extends HVAC_Form_Builder {
         // Set form enctype for file uploads (featured images)
         $this->set_attributes(['enctype' => 'multipart/form-data']);
 
-        // Load timezone list
+        // Initialize cache
+        $this->cache = HVAC_Event_Cache::instance();
+
+        // Load timezone list (cached)
         $this->timezone_list = $this->get_wordpress_timezones();
     }
 
@@ -503,11 +513,20 @@ class HVAC_Event_Form_Builder extends HVAC_Form_Builder {
     }
 
     /**
-     * Get WordPress timezone options
+     * Get WordPress timezone options (cached)
      *
      * @return array Timezone options
      */
     private function get_wordpress_timezones(): array {
+        // Try cache first
+        if ($this->cache) {
+            $cached_timezones = $this->cache->get_timezone_list();
+            if ($cached_timezones !== false) {
+                return $cached_timezones;
+            }
+        }
+
+        // Generate timezone list if not cached
         $zones = wp_timezone_choice('UTC');
         $timezone_options = [];
 
@@ -518,31 +537,59 @@ class HVAC_Event_Form_Builder extends HVAC_Form_Builder {
             }
         }
 
+        // Cache the results
+        if ($this->cache) {
+            $this->cache->cache_timezone_list($timezone_options);
+        }
+
         return $timezone_options;
     }
 
     /**
-     * Get trainer requirement options
+     * Get trainer requirement options (cached)
      *
      * @return array Trainer requirement options
      */
     private function get_trainer_requirement_options(): array {
-        return [
+        // Try cache first
+        if ($this->cache) {
+            $cached_options = $this->cache->get_trainer_options();
+            if ($cached_options !== false) {
+                return $cached_options;
+            }
+        }
+
+        $options = [
             ''                    => 'No specific requirement',
             'certified_trainer'   => 'Certified HVAC Trainer',
             'master_trainer'      => 'Master Trainer',
             'industry_expert'     => 'Industry Expert',
             'manufacturer_rep'    => 'Manufacturer Representative',
         ];
+
+        // Cache the results
+        if ($this->cache) {
+            $this->cache->cache_trainer_options($options);
+        }
+
+        return $options;
     }
 
     /**
-     * Get certification level options
+     * Get certification level options (cached)
      *
      * @return array Certification level options
      */
     private function get_certification_level_options(): array {
-        return [
+        // Try cache first
+        if ($this->cache) {
+            $cached_levels = $this->cache->get_cert_levels();
+            if ($cached_levels !== false) {
+                return $cached_levels;
+            }
+        }
+
+        $levels = [
             'basic'        => 'Basic HVAC',
             'intermediate' => 'Intermediate HVAC',
             'advanced'     => 'Advanced HVAC',
@@ -550,6 +597,13 @@ class HVAC_Event_Form_Builder extends HVAC_Form_Builder {
             'residential'  => 'Residential Systems',
             'refrigeration' => 'Refrigeration',
         ];
+
+        // Cache the results
+        if ($this->cache) {
+            $this->cache->cache_cert_levels($levels);
+        }
+
+        return $levels;
     }
 
     /**
diff --git a/includes/class-hvac-plugin.php b/includes/class-hvac-plugin.php
index 79325c30..5377b73b 100644
--- a/includes/class-hvac-plugin.php
+++ b/includes/class-hvac-plugin.php
@@ -208,6 +208,12 @@ final class HVAC_Plugin {
         // Native event post handler (Phase 1B - tribe_events creation)
         require_once HVAC_PLUGIN_DIR . 'includes/class-hvac-event-post-handler.php';
 
+        // Event caching system (Phase 1D - Performance Optimization)
+        require_once HVAC_PLUGIN_DIR . 'includes/class-hvac-event-cache.php';
+
+        // AJAX optimization system (Phase 1D - Performance Optimization)
+        require_once HVAC_PLUGIN_DIR . 'includes/class-hvac-ajax-optimizer.php';
+
         // Unified Event Management System (replaces 8+ fragmented implementations)
         require_once HVAC_PLUGIN_DIR . 'includes/class-hvac-event-manager.php';