The Ultimate Guide to Real Estate Website Speed Optimization: Faster Listings, More Leads & Higher Rankings in 2026

In real estate, speed isn't a technical metric — it's the difference between capturing a motivated buyer and losing them to a competitor's faster site. The economics of real estate make speed optimization one of the highest-ROI investments a brokerage or agent can make.

The Lead Economics: Real estate has uniquely high transaction values. A single residential sale generates $8,000–$15,000 in commission (assuming 2.5–3% on a $300K–$500K home). Commercial real estate commissions can reach $50,000–$500,000+. This means every lead matters enormously, and losing leads to slow pages is exceptionally expensive.

Consider a mid-size brokerage driving 15,000 monthly visitors:

• •At 40% bounce rate (fast site): 9,000 engaged visitors → 270 leads (3% conversion) → 27 closings (10% close rate) → $324,000 in commission
• •At 65% bounce rate (slow site): 5,250 engaged visitors → 158 leads → 16 closings → $192,000 in commission
• •Monthly revenue difference: $132,000 from the same traffic

The Local SEO Imperative: Real estate is the most hyper-local industry in digital marketing. Queries like 'homes for sale in Austin TX,' '3 bedroom house Denver,' and 'condos near downtown Seattle' drive enormous commission revenue. Google's local ranking algorithm weighs Core Web Vitals alongside traditional factors like proximity, reviews, and content relevance.

With only 35% of real estate sites passing CWV, the ranking advantage for optimized sites is massive. We've seen brokerages jump 3–5 positions for local search terms after CWV optimization — translating to 40–80% more organic traffic for their highest-value keywords.

The Mobile Reality: The National Association of Realtors reports that 72% of home searches begin on a mobile device. Prospective buyers browse listings during commutes, lunch breaks, and open house visits. Yet mobile performance on real estate sites is abysmal — average mobile LCP exceeds 5 seconds, and INP regularly fails due to heavy map and gallery interactions.

Google Ads & CPL: Real estate Google Ads CPCs range from $2–$15 for organic keywords to $30–$80 for high-intent terms like 'sell my house fast' or 'real estate agent near me.' Google factors landing page experience (including speed) into Quality Score. Faster landing pages = higher Quality Score = lower CPC. We've documented real estate clients achieving 18–30% CPL reduction after speed optimization. See our landing page speed & CPL guide for strategies.

Real estate websites face a perfect storm of performance challenges that don't exist (or are less severe) in other industries. Understanding these unique bottlenecks is the first step to fixing them.

1. High-Resolution Property Image Galleries: The single biggest performance killer. A typical listing page includes 20–40 high-resolution property photos, each uploaded at 3–8MB by agents using phone cameras. Even compressed to JPEG, gallery pages routinely weigh 15–30MB. Without responsive sizing, mobile users download desktop-resolution images they'll never see at full size. Property images account for 70–85% of total page weight on listing pages.

2. Google Maps & Location Embeds: Nearly every listing page, area guide, and office location page embeds Google Maps. A single Google Maps embed loads 500KB–1MB of JavaScript, multiple font files, dozens of map tile images, and establishes connections to 5+ Google domains. On pages with multiple maps (listing + neighborhood + schools nearby), the impact compounds to 2–3MB of additional resources.

3. IDX/MLS Integration Scripts: IDX (Internet Data Exchange) feeds from the MLS (Multiple Listing Service) are essential for displaying property listings. However, most IDX solutions (IDX Broker, Showcase IDX, iHomefinder, Diverse Solutions) inject substantial JavaScript for search functionality, map overlays, listing cards, and saved search features. A typical IDX integration adds 2–4 seconds of load time and 500KB–2MB of JavaScript.

4. Virtual Tour Embeds: Matterport 3D tours, iGuide floor plans, video walkthroughs, and drone footage are increasingly expected by buyers. Each embed loads its own JavaScript runtime, 3D rendering engine, and media assets. A single Matterport embed adds 1–3MB of resources and significant main-thread blocking.

5. Lead Capture & CRM Tools: Real estate sites typically run multiple lead capture systems simultaneously:

• •Chat widgets (LiveChat, Drift, Intercom) — 500KB–1MB each
• •CRM integrations (Follow Up Boss, kvCORE, BoomTown, Real Geeks) — 200KB–500KB each
• •Pop-up/slide-in lead forms (OptinMonster, Sumo) — 200KB–400KB each
• •Property valuation tools ('What's my home worth?' widgets) — 300KB–800KB each

Combined, lead capture tools can add 1–3MB of JavaScript and 2–5 seconds of main-thread blocking.

6. Outdated CMS & Theme Bloat: Many real estate sites run WordPress with real estate-specific themes that bundle extensive features regardless of what's used. Common issues include page builders (Elementor, Divi) adding 1–2MB of CSS/JS, 20+ plugins for various real estate functions, unoptimized theme code with large CSS frameworks, and render-blocking scripts loaded globally across all pages.

Understanding industry benchmarks helps you set targets and quantify your competitive advantage.

Core Web Vitals Pass Rates — Real Estate vs. Other Industries (2026 CrUX Data):

Real estate has the lowest CWV pass rate, driven by heavy images (LCP) and complex map/gallery interactions (INP).

Listing Page Speed Benchmarks:

The gap between top-performing and average real estate sites is the largest of any industry. Top-10% sites load 4x faster than the median. This creates an enormous opportunity — moving from median to top-10% can dramatically improve both rankings and lead generation.

A real estate-specific performance audit must cover listing pages, search/IDX pages, area/community pages, and lead capture flows — they each have distinct bottlenecks.

Step 1: Audit the Right Pages Don't just test your homepage. Real estate sites have vastly different performance profiles by page type:

• •Homepage — Usually the 'lightest' page; misleading if it's the only page tested
• •Individual listing pages — The heaviest pages (image galleries, maps, virtual tours)
• •IDX search results — Heavy JavaScript from IDX provider
• •Area/community pages — Maps, neighborhood data, school ratings
• •Agent profile pages — Headshots, testimonials, contact forms
• •Blog/content pages — Usually fastest; least optimization needed

Test at least 2–3 examples of each page type in PageSpeed Insights.

Step 2: Identify Your LCP Elements On listing pages, the LCP element is almost always the hero property image. On search results, it's often the first listing card image or the IDX container. On area pages, it's frequently the neighborhood hero image or map. Knowing your LCP element for each page type drives optimization priorities.

Step 3: Image Audit Open Chrome DevTools → Network tab → filter by 'Img' → load a listing page. Record:

• •Total number of images loaded (not lazy-loaded)
• •Total image weight (transferred vs. resource size)
• •Image formats (JPEG, PNG, WebP?)
• •Whether responsive srcset is used
• •Which images are above-the-fold vs. below

Most real estate sites will show 20–40 images loading immediately (not lazy-loaded), totaling 5–15MB, in JPEG format, at desktop resolution regardless of device.

Step 4: Third-Party Script Inventory Chrome DevTools → Network tab → filter by domain. List every external script:

• •IDX/MLS provider scripts (size, execution time)
• •Google Maps API (number of loads per page)
• •Chat/CRM widgets (size, when they load)
• •Analytics and tracking (GA4, Facebook Pixel, Google Ads)
• •Virtual tour embeds (Matterport, etc.)
• •Lead capture pop-ups

Step 5: Conversion Correlation Use GA4 to segment lead form submissions by page load time. Compare conversion rates for visitors experiencing fast vs. slow pages. Calculate: (bounce rate improvement × monthly traffic × lead conversion rate × average commission) = monthly revenue impact of optimization.

Images are 70–85% of listing page weight. Optimizing them is the single highest-impact change you can make, often cutting page weight by 60–80% without any visible quality loss.

Format Conversion — WebP & AVIF: Convert all property images from JPEG/PNG to WebP (30–40% smaller) or AVIF (50–60% smaller). Property photos compress exceptionally well in modern formats because they contain lots of gradients, textures, and natural scenes.

Implement with the <picture> element for fallback:
<picture>
  <source srcset="listing-hero.avif" type="image/avif" />
  <source srcset="listing-hero.webp" type="image/webp" />
  <img src="listing-hero.jpg" alt="123 Main St — Spacious living room" width="1200" height="800" />
</picture>

Responsive Sizing with srcset: Stop serving 4000×3000px images to mobile screens. Implement responsive images: <img srcset="listing-400w.webp 400w, listing-800w.webp 800w, listing-1200w.webp 1200w, listing-1600w.webp 1600w" sizes="(max-width: 640px) 100vw, (max-width: 1024px) 50vw, 800px" src="listing-800w.webp" alt="123 Main St — Kitchen with granite countertops" width="1200" height="800" loading="lazy" />

Lazy Loading Strategy for Galleries:

• •Hero/featured image: loading='eager', fetchpriority='high' — this is your LCP element
• •Gallery images 2–4 (visible in initial gallery view): loading='eager'
• •All remaining gallery images: loading='lazy'
• •Never lazy-load the hero image — this worsens LCP

Image CDN for Automated Optimization: For sites with thousands of listings, manual optimization isn't feasible. Use an image CDN:

• •Cloudinary ($0–99/mo) — Automatic format negotiation, responsive sizing, quality optimization
• •imgix ($0–600/mo) — Real-time image processing, face-detection cropping for agent headshots
• •Cloudflare Images ($5/mo + usage) — Budget-friendly automatic WebP conversion

Compression Quality: Property photos can be compressed more aggressively than product photography:

• •Hero/featured image: Quality 80% (visitors scrutinize this image most)
• •Gallery images: Quality 72–75% (rarely noticed at viewing sizes)
• •Thumbnail/card images: Quality 65–70% (small display size hides compression)
• •Agent headshots: Quality 80% (people notice face quality)

MLS/IDX Image Pipeline: If your IDX provider serves images from the MLS, you may not control the source quality. Solutions:

• •Use an image CDN proxy that optimizes images on delivery
• •Request WebP versions from your IDX provider (most modern providers support this)
• •Cache optimized versions on your CDN to avoid re-processing
• •Set appropriate cache headers: Cache-Control: public, max-age=86400 (listings change, so 24h is reasonable)

Google Maps is the second biggest performance bottleneck on real estate sites after images. Here's how to eliminate its impact without losing the functionality buyers expect.

The Problem: A single Google Maps JavaScript embed loads:

• •~700KB of JavaScript (Maps API, core library, renderer)
• •Map tile images (100–500KB depending on zoom/area)
• •Google Fonts (Roboto, 50–100KB)
• •Connections to 5+ Google domains (fonts.googleapis.com, maps.googleapis.com, etc.)

On pages with multiple maps (listing location + neighborhood overview + nearby schools), this compounds to 2–3MB and 1–3 seconds of main-thread blocking.

Solution 1: Static Map Facade (Best for Listing Pages) Replace the interactive Google Map with a static map image that loads the full interactive map only when clicked:

1. 1Use the Google Static Maps API to generate a map image: `https://maps.googleapis.com/maps/api/staticmap?center=LAT,LNG&zoom=15&size=600x300&markers=color:red|LAT,LNG&key=YOUR_KEY`
2. 2Display it as a regular <img> with lazy loading
3. 3On click, swap with the interactive Google Maps embed
4. 4Result: 0 JavaScript cost until the user wants to interact with the map

This single change typically saves 500KB–1MB of JavaScript and improves both LCP and INP significantly.

Solution 2: Lightweight Map Libraries For pages needing interactive maps without the Google Maps overhead:

• •Leaflet.js (42KB) — Open-source, uses OpenStreetMap tiles
• •MapLibre GL JS (200KB) — Vector maps, smooth animations, lighter than Google Maps
• •Static maps with markers — For simple location display, a static image is sufficient

Solution 3: Maps on Scroll/Tab If the map is below the fold or in a tab:

• •Use Intersection Observer to load the map when the user scrolls to it
• •If maps are in tabs ('Map' tab on listing page), load on tab click
• •Pre-connect to Google Maps domains on page load so the map loads faster when triggered:

<link rel="preconnect" href="https://maps.googleapis.com" /> <link rel="preconnect" href="https://maps.gstatic.com" crossorigin />

Google Maps API Cost Optimization: Beyond performance, static maps are also cheaper. Google Maps JavaScript API costs $7 per 1,000 loads. Static Maps API costs $2 per 1,000 loads. For a site with 50,000 monthly listing views, switching to static-first saves ~$250/month in API costs while dramatically improving performance.

IDX (Internet Data Exchange) integrations are essential for displaying MLS listings but are notoriously heavy. Here's how to optimize the major providers.

Common IDX Performance Issues:

• •Large JavaScript bundles (500KB–2MB) loaded on every page, not just search pages
• •Synchronous script loading blocking the critical rendering path
• •Inline CSS injected by IDX that conflicts with theme styles
• •Unoptimized MLS images served at full resolution
• •Frequent API calls to MLS servers with poor caching
• •Map overlays loading Google Maps API redundantly (if page already has a map)

Provider-Specific Optimization:

### IDX Broker

• •Move IDX wrapper scripts to load async/defer
• •Use IDX Broker's built-in lazy loading for listing images
• •Enable their CDN-cached pages feature
• •Limit 'recently viewed' and 'similar listings' widgets to listing pages only

### Showcase IDX

• •Configure to load on search/listing pages only (not globally)
• •Use their API mode instead of iframe mode for better performance
• •Implement server-side rendering for listing data when possible

### kvCORE / BoomTown / Real Geeks

• •These all-in-one platforms have limited optimization options
• •Focus on reducing other third-party scripts to compensate
• •Use their built-in lead capture instead of adding additional tools
• •Optimize images outside the IDX system (hero, agent photos, blog)

General IDX Optimization Strategies:

1. 1Load IDX scripts only on pages that need them (search, listings, saved searches) — not the homepage, blog, or about page
2. 2Defer IDX JavaScript: load it async so it doesn't block the hero image and initial content rendering
3. 3Cache IDX API responses: listing data changes infrequently (daily MLS updates), so cache aggressively
4. 4Optimize IDX images separately: if your IDX provider allows custom image URLs, route them through an image CDN
5. 5Minimize IDX widgets: each widget (recently viewed, similar listings, market stats) adds JavaScript weight — use only what drives leads

Virtual tours and video walkthroughs are increasingly expected by buyers — especially since the pandemic normalized remote home shopping. But they're performance disasters when loaded eagerly.

Matterport 3D Tours: A Matterport embed loads a full 3D rendering engine, model data, and navigation UI — typically 1–3MB of resources and significant GPU usage. Optimization:

• •Never auto-load the Matterport iframe — use a facade pattern
• •Show a static preview image with a 'Take Virtual Tour' button
• •On click, dynamically insert the Matterport iframe
• •Use the Matterport SDK's lazy loading options if available
• •Position the tour section below the fold to avoid impacting LCP

Video Walkthroughs:

• •Never autoplay video on listing pages — it blocks LCP, wastes bandwidth, and annoys users
• •Use a poster image with a play button overlay
• •Load the video player (YouTube, Vimeo, or HTML5) only on click
• •For YouTube/Vimeo embeds, use lite-youtube-embed or lite-vimeo (1KB vs. 700KB+)
• •Host walkthrough videos on YouTube rather than self-hosting to leverage their CDN and adaptive bitrate

Drone Footage:

• •Same click-to-play pattern as video walkthroughs
• •Compress drone footage to 1080p (4K is unnecessary for web viewing)
• •Use poster images from key drone angles as the click target

Floor Plans:

• •Serve floor plans as SVG when possible (scalable, small file size)
• •If raster format, use WebP at appropriate resolution (1200px wide max)
• •Lazy-load floor plans — they're typically below the fold
• •Consider interactive floor plans (click-to-zoom) instead of static images for better UX without gallery weight

Implementation Priority: Not all listings need the same media treatment. Prioritize performance investment:

• •Luxury/high-value listings: Full Matterport + video + drone (high commission justifies the effort)
• •Standard listings: Gallery + static map + floor plan (optimize images aggressively)
• •Expired/sold listings: Reduce to 5–10 images, remove virtual tours and active lead capture

Real estate sites often run 3–5 lead capture tools simultaneously, each adding JavaScript weight. Here's how to capture leads without sacrificing performance.

The Lead Tool Bloat Problem: A typical real estate site runs:

• •Chat widget (Drift, LiveChat, or platform-native) — 500KB–1MB
• •Pop-up form (OptinMonster, Sumo, Hello Bar) — 200KB–400KB
• •CRM integration (Follow Up Boss, kvCORE) — 200KB–500KB
• •Home valuation widget — 300KB–800KB
• •Scheduling tool (Calendly, ShowingTime) — 200KB–500KB
• •Exit-intent overlay — 100KB–300KB

Total: 1.5–3.5MB of JavaScript dedicated to lead capture — often more than the actual page content.

Strategy 1: Consolidate Tools Most lead capture functions can be handled by a single tool or your CRM:

• •Use your CRM's built-in chat instead of a separate widget
• •Use native contact forms instead of third-party pop-up tools
• •Combine home valuation and contact into one form
• •Use ShowingTime's lightweight API instead of their full widget

Strategy 2: Defer Everything Except the Primary CTA

• •Primary contact form: Inline on page, load CSS inline, form action via simple fetch
• •Chat widget: Facade pattern — static button, load real chat on click
• •Pop-up forms: Trigger on scroll depth (50%+) or time delay (30s+), not on page load
• •Home valuation: Load on the dedicated valuation page, not globally
• •Scheduling: Load on click ('Schedule Showing' button → load Calendly)

Strategy 3: Lightweight Contact Forms Replace heavy form plugins with simple HTML forms:

• •Native HTML form with CSS styling (0 JavaScript needed for layout)
• •Form submission via fetch API to your CRM endpoint
• •Client-side validation with native HTML attributes (required, type='email', pattern)
• •Success/error handling with minimal JavaScript

This approach reduces form-related JavaScript from 500KB+ to under 5KB.

Strategy 4: Smart Lead Capture Timing Not every visitor needs every lead tool on every page:

• •First-time visitors: Show primary contact form only
• •Return visitors: Enable chat widget (they're more engaged)
• •Listing page visitors: Show 'Schedule Showing' and 'Ask a Question' CTAs
• •Area guide visitors: Show 'Get Market Report' CTA
• •Blog readers: Show 'Subscribe' CTA only

Real estate websites run on diverse platforms. Here are platform-specific optimization strategies:

WordPress (Most Common): WordPress powers 60%+ of real estate websites. Key optimizations:

• •Replace heavy real estate themes with lightweight alternatives (GeneratePress, flavor flavor flavor)
• •Use WP Rocket or LiteSpeed Cache for page caching, critical CSS, and lazy loading
• •Limit plugins to essentials — each plugin adds CSS/JS weight
• •Use ShortPixel or Imagify for automatic WebP conversion
• •Implement object caching (Redis/Memcached) for IDX/MLS database queries
• •See our WordPress speed guide for detailed techniques

Squarespace:

• •Limited optimization options compared to WordPress
• •Focus on image optimization (Squarespace auto-generates some responsive sizes)
• •Minimize custom code injections in the header
• •Use Squarespace's built-in lazy loading
• •Consider migrating to WordPress for more optimization control on high-value sites

Wix:

• •Wix's proprietary rendering adds baseline overhead
• •Focus on image optimization within Wix's media manager
• •Minimize Wix Apps installed — each adds JavaScript
• •Use Wix's built-in contact forms instead of third-party tools
• •Reduce page complexity (fewer sections, simpler layouts)

Custom / Headless CMS:

• •Best performance potential — full control over rendering
• •Use static site generation (SSG) for listing pages with ISR for freshness
• •Implement edge rendering for personalized content
• •Build a custom image pipeline with srcset, WebP, and CDN delivery
• •Use React Server Components for non-interactive sections

kvCORE / BoomTown / Real Geeks (All-in-One Platforms):

• •Limited control over core platform performance
• •Focus on reducing additional third-party scripts
• •Optimize custom content (blog posts, area pages) that you control
• •Use platform-native lead capture instead of adding external tools
• •Advocate for performance improvements with your platform vendor

For real estate sites already passing basic CWV, these advanced techniques push performance further:

Predictive Pre-rendering with Speculation Rules: Pre-render likely next pages based on user behavior. When a buyer is viewing search results, pre-render the top 3 listing pages. When they're on a listing, pre-render the 'Schedule Showing' and 'Contact Agent' pages:

<script type="speculationrules"> { "prerender": [{ "where": { "selector_matches": ".listing-card a" }, "eagerness": "moderate" }] } </script>

This makes listing page navigation feel instant — critical for buyers browsing multiple properties.

Progressive Image Loading for Galleries: Implement a progressive loading pattern for property galleries:

1. 1Load a tiny blurred placeholder (BlurHash, 100 bytes)
2. 2Load a low-quality preview (20KB, visible during scroll)
3. 3Load full-quality image on demand (when user opens in gallery view)

This creates a perception of instant loading while deferring the heaviest resources.

Edge-Rendered Listing Pages: Serve listing pages from the edge with fresh MLS data:

• •Use Cloudflare Workers or Vercel Edge to render listing pages at the edge
• •Cache listing data for 1 hour with stale-while-revalidate for 24 hours
• •Serve personalized content (saved favorites, recently viewed) at the edge via cookies
• •Achieve sub-50ms TTFB globally instead of 500ms+ from a single origin

AI-Powered Image Optimization: Use ML-based image compression that analyzes each property photo individually:

• •Higher quality for rooms with important details (kitchen countertops, bathroom fixtures)
• •Lower quality for exterior shots and landscape views (compression artifacts less noticeable)
• •Automatic cropping/resizing based on aspect ratio and composition
• •20–30% additional savings vs. fixed-quality compression

Offline-Capable Listing Browsing: Implement a service worker that caches recently viewed listings for offline access. Buyers browsing properties in areas with poor cell coverage (rural listings, new construction areas) can continue viewing cached listing data. This also dramatically speeds up return visits.

View Transitions for Listing Navigation: Use the View Transitions API to create smooth, app-like transitions between search results and listing pages. Combined with Speculation Rules pre-rendering, this makes the browsing experience feel like a native real estate app.

For real estate, CWV optimization and local SEO are deeply interconnected. Here's how speed drives rankings for the queries that matter most.

Local Pack Rankings: Google's Local 3-Pack (map results) for queries like 'real estate agent near me' factors in Core Web Vitals alongside proximity, reviews, and business profile completeness. Passing CWV is increasingly necessary to appear in the local pack for competitive markets.

Area/Community Page Strategy: Area guide pages ('Homes for sale in [Neighborhood]') are critical for organic traffic. Optimize them by:

• •Using static map images instead of interactive Google Maps embeds
• •Lazy-loading neighborhood statistics and school rating widgets
• •Pre-rendering area pages with SSG for near-instant loading
• •Including structured data (LocalBusiness, Place) for rich search results
• •Internal linking to related listing search results and blog content

Schema Markup for Listings: Implement RealEstateListing schema on property pages for rich search results:

• •Property type, price, bedrooms/bathrooms, square footage
• •Address and geo-coordinates
• •Images (link to optimized WebP versions)
• •Agent information with BrokerageOrganization schema
• •Open house events with Event schema

Mobile-First Indexing: Google uses mobile page performance for ranking in both mobile and desktop search. Since 72% of home searches are mobile, your mobile CWV scores directly determine your organic visibility. Prioritize mobile optimization over desktop in every decision.

Content + Speed Flywheel: The fastest sites earn more engagement signals (longer dwell time, more pages per session, lower bounce rate), which further improve rankings, which drive more traffic, which generates more engagement data. Speed optimization creates a virtuous cycle for SEO performance.

Image Optimization:

• •Cloudinary ($0–99/mo) — Best for high-volume listing sites, automatic format/size optimization, MLS image proxy support
• •ShortPixel ($4.99/mo) — WordPress bulk image optimization with WebP/AVIF conversion
• •imgix ($0–600/mo) — Real-time image processing, face-detection for agent headshots
• •Imagify (Free–$9.99/mo) — WordPress plugin with automatic optimization on upload

Caching & CDN:

• •Cloudflare (Free–$200/mo) — CDN, HTTP/3, auto-optimization, Polish image compression
• •WP Rocket ($59/yr) — WordPress caching, critical CSS, lazy loading, database optimization
• •LiteSpeed Cache (Free with LiteSpeed hosting) — Server-level caching with CDN integration

Maps Optimization:

• •Google Static Maps API — Static map images for facade patterns
• •Leaflet.js (Free, 42KB) — Lightweight interactive maps with OpenStreetMap
• •MapLibre GL JS (Free, 200KB) — Vector maps, lighter than Google Maps

Performance Monitoring:

• •PageSpeed Insights — Quick CWV checks with field + lab data
• •Google Search Console — Site-wide CWV monitoring
• •SpeedCurve ($15–525/mo) — Continuous monitoring with competitive benchmarking
• •DebugBear ($79–249/mo) — CrUX tracking with Slack alerts

WordPress Real Estate Stack (Recommended):

• •Theme: GeneratePress or Flavor Flavor Flavor Flavor Flavor Flavor
• •Caching: WP Rocket or LiteSpeed Cache
• •Images: ShortPixel + WebP conversion
• •IDX: IDX Broker (most optimization-friendly) with async loading
• •Forms: WPForms Lite or Gravity Forms (lightweight)
• •Chat: Lightweight facade → full widget on click
• •SEO: Rank Math or Yoast SEO
• •CDN: Cloudflare (free tier is sufficient for most agencies)