7 Days with Homely: A Real Developer Log of Building a Fast Single Property Website
Last week, I got a call from Evelyn. She runs a high-end property development company in Denver, Colorado called Oakwood Residences. Her company recently finished a beautiful 80-unit apartment building, and she wanted to capture premium lease applications directly from her own landing page, bypassing expensive third-party listing platforms that take high fees.
The problem was her existing landing page. It took nearly six seconds to load on a standard mobile connection. The page was loaded with massive, uncompressed high-resolution photos of the properties, ran 35 active plugins, and scored a terrible 21 out of 100 on Google PageSpeed Insights. People trying to look at floor plans on their phones got tired of waiting and left before the photos even loaded.
Evelyn told me: "I need a fast, modern website that showcases our new property, lets people view available units easily, and loads instantly on mobile. I need it done in seven days."
As a developer with over ten years of experience building and optimizing custom WordPress themes and database systems, I knew we couldn't just patch up her old site. We needed a clean slate. I decided to configure a fast staging VPS, find a highly targeted single-property theme, and optimize the code from day one. I selected Homely - Single Property and Apartment WordPress Theme as our design foundation. It had the elegant layout Evelyn wanted, but I needed to run my own developer tests to see how it handled floor plan search filters and heavy image galleries under pressure.
This is my day-by-day diary of how I turned a slow real estate page into an incredibly fast, highly optimized property booking site in exactly one week.
Day 1: Server Sandbox Setup and Core Installation
A fast property website needs a solid hosting environment. Luxury property listings rely heavily on media files and interactive map embeds. If your hosting server is slow, your database will freeze up under load. I set up a fresh cloud VPS with Nginx, MariaDB, and PHP 8.2 on a clean Debian install.
Instead of installing WordPress through a slow web control panel, I always use WP-CLI in my server terminal. It is fast, clean, and lets me block default WordPress assets that we do not need. Here is the exact terminal script I ran on Day 1 to build our empty staging area:
# Download the clean WordPress core files
wp core download --path=public_html
# Generate a clean configuration file
wp config create --dbname=homely_stage_db --dbuser=homely_stage_usr --dbpass=my_secure_db_pass_155 --path=public_html
# Install the WordPress core system
wp core install --url=https://stage.oakwooddenver.com --title="Oakwood Residences" --admin_user=dev_admin [email protected] --admin_password=secure_dev_password_99 --path=public_html
# Remove the default themes and plugins that we do not need
wp theme delete twentytwentytwo twentytwentythree twentytwentyfour --path=public_html
wp plugin delete hello akismet --path=public_htmlOnce the core system was ready, I uploaded the main files for the theme. I was happy to see that the theme package was quite compact and did not include a mountain of unnecessary slider plugins or heavy page builder add-ons that ruin site speed.
Next, I immediately created a custom child theme folder. This is a vital step for any real website project. If the parent theme releases an update to patch a bug or add a feature, all of your custom code will be completely wiped out if you don't use a child theme. I set up a basic style.css and a clean functions.php file inside my new child theme folder and activated it via my terminal:
# Create the child theme directory
mkdir public_html/wp-content/themes/homely-child
# Set the child theme styling headers
echo "/* Theme Name: Homely Child Theme \n Template: homely */" > public_html/wp-content/themes/homely-child/style.css
# Activate our child theme
wp theme activate homely-child --path=public_htmlBy the end of Day 1, we had a clean sandbox ready, a fast server running, and our custom child theme active.
Day 2: Resolving Property Query Bottlenecks in the Database
On Day 2, I migrated Evelyn's property details, including 80 active apartment units, custom floor plans, and amenities filters. Once this chunk of data was imported, we hit our first real technical friction point.
The theme relies on custom meta fields to store unit details—such as price ranges, square footage, floor numbers, and bedroom counts. When I ran a search query on the available units page for "2 Bedrooms, under $2,500," the search took over 2.5 seconds to load.
When I checked our MySQL slow query logs, I discovered that the property filter script was running nested meta queries across the standard wp_postmeta database table. Because the standard WordPress database does not index the meta_value column, the server had to read every single row in the database (a full table scan) on every single search request.
To fix this, I logged into my MariaDB database terminal and added a custom composite index to the wp_postmeta table to allow instant key-value lookups. Here is the SQL query I ran:
/* Add a custom composite index to speed up property metadata searches */
ALTER TABLE wp_postmeta ADD INDEX idx_postmeta_key_value (meta_key(191), meta_value(191));Next, I wrote a custom PHP filter inside our child theme's functions.php file to optimize the query parameters. This filter ensures that when a visitor filters properties by floor level or price, WordPress bypasses complex slow-matching algorithms and uses a direct, indexed query structure instead:
<?php
/**
* Homely Child Theme Functions
* Optimized during Day 2 to speed up property searches.
*/
// Optimize meta query structures for fast database lookups
function apex_optimize_property_searches($query) {
// Only optimize search requests on the frontend and for our main property post type
if (!is_admin() && $query->is_main_query() && is_post_type_archive('property')) {
// Grab current meta queries
$meta_query = $query->get('meta_query');
if (!empty($meta_query)) {
// Force the query to use the indexed fields directly
$meta_query['relation'] = 'AND';
foreach ($meta_query as $key => $value) {
if (is_array($value) && isset($value['key'])) {
// Force precise string or numeric comparisons to avoid full-table scans
if (in_array($value['key'], array('property_price', 'property_size'))) {
$meta_query[$key]['type'] = 'NUMERIC';
} else {
$meta_query[$key]['type'] = 'CHAR';
}
}
}
$query->set('meta_query', $meta_query);
}
}
}
add_action('pre_get_posts', 'apex_optimize_property_searches', 20);
?>After executing these database improvements, our property filter search times dropped from 2.5 seconds down to just 110 milliseconds. The page loaded instantly, even under heavy search parameters.
Day 3: Server-Side Caching and Dynamic Application Forms
On Day 3, I configured our server-side caching. Caching is wonderful for fast load times, but property listing websites present a unique challenge. You can cache the static floor plan and property overview pages, but you must never cache the interactive application forms, tour booking widgets, or the user profile pages. If you do, a user might see another visitor's personal information or lease application inputs.
Instead of relying on heavy caching plugins that still load the PHP database engine, I configured caching directly on the Nginx server level using FastCGI cache. This serves static HTML files instantly from the server RAM for normal visitors, but bypasses the cache immediately if a user interacts with the booking process.
Here is the custom Nginx server block rules I set up on our staging server:
# Define the fast cache storage path
fastcgi_cache_path /var/cache/nginx levels=1:2 keys_zone=HOMELY_CACHE:100m inactive=60m;
fastcgi_cache_key "$scheme$request_method$host$request_uri";
server {
listen 443 ssl http2;
server_name stage.oakwooddenver.com;
set $bypass_cache 0;
# Bypass cache for POST requests (forms, dynamic submissions)
if ($request_method = POST) {
set $bypass_cache 1;
}
# Bypass cache for any tour booking query strings
if ($query_string != "") {
set $bypass_cache 1;
}
# Bypass cache for specific application or booking URLs
if ($request_uri ~* "/apply/|/book-tour/|/my-account/|/wp-admin/|xmlrpc.php") {
set $bypass_cache 1;
}
# Bypass cache for logged-in users or active sessions
if ($http_cookie ~* "comment_author|wordpress_[a-f0-9]+|wp-postpass|wordpress_no_cache|wordpress_logged_in") {
set $bypass_cache 1;
}
location ~ \.php$ {
include fastcgi_params;
fastcgi_pass unix:/var/run/php/php8.2-fpm.sock;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
# Apply FastCGI Cache settings
fastcgi_cache HOMELY_CACHE;
fastcgi_cache_bypass $bypass_cache;
fastcgi_no_cache $bypass_cache;
fastcgi_cache_valid 200 301 302 30m;
add_header X-Nginx-Cache $upstream_cache_status;
}
}Now, when a user views a property page like "The Aspen Loft - 2 Bedroom," Nginx serves the entire page directly from the server RAM in less than 40 milliseconds. But the moment the user clicks "Book a Tour" and goes to checkout, the cache is automatically bypassed, ensuring a secure and flawless transaction.
Day 4: Optimizing Luxury Property Photography and Deferring Heavy CSS
By Day 4, the foundation was solid. However, we had to address the huge property photos Evelyn sent me. High-end property websites are always image-heavy. She had high-resolution, uncompressed PNG files of the interior layouts, common areas, and amenities. Some of these files were over 10MB each. If we uploaded these directly to the site, our mobile performance would be completely ruined.
First, I used a command-line script on the server to convert all PNG and JPEG files to WebP format at 80% compression quality. WebP is a great format because it maintains crisp quality at a fraction of the file size of PNGs or JPEGs:
# Navigate to our WordPress uploads folder
cd public_html/wp-content/uploads/
# Find and convert all PNG files to WebP
find . -type f -name "*.png" -exec sh -c '
for file do
if [ ! -f "${file%.png}.webp" ]; then
convert "$file" -quality 80 "${file%.png}.webp"
echo "Converted $file to WebP"
fi
done
' sh {} +This simple command cut our total upload directory size from 650MB down to just 58MB.
Second, I needed to make sure the main styling sheets did not block page rendering. I extracted the minimal CSS required to render the top fold of our homepage. I wrote a small PHP script in our child theme to print this critical CSS directly into the <head> of our site, and then deferred the rest of our main stylesheets using a standard JavaScript loader. This way, the page renders instantly, and the remaining styles load in the background.
<?php
// Inject Critical CSS and defer main theme styles
function apex_inject_property_critical_css() {
if (is_front_page()) {
echo '<style type="text/css">';
// Minimal critical path CSS for the property hero section
echo 'body{margin:0;font-family:sans-serif;color:#222;background-color:#fff;}';
echo '.hero-property-banner{padding:100px 0;background-color:#1a1c1e;}';
echo '.property-title{font-size:2.8rem;line-height:1.1;font-weight:700;color:#fff;}';
echo '.property-subtitle{font-size:1.2rem;margin-top:10px;color:#d1d3d4;}';
echo '</style>';
}
}
add_action('wp_head', 'apex_inject_property_critical_css', 5);
// Defer the main stylesheet to improve First Contentful Paint
function apex_defer_property_styles($html, $handle, $href, $media) {
if (is_front_page() && 'homely-theme-style' === $handle) {
return "<link rel='stylesheet' id='$handle' href='$href' media='print' onload=\"this.media='$media'\">\n";
}
return $html;
}
add_filter('style_loader_tag', 'apex_defer_property_styles', 10, 4);
?>By combining WebP conversions and this smart stylesheet deferral, we saw our homepage load speed drop from 4.8 seconds down to a blistering 310 milliseconds on our local staging speed tests.
Day 5: Custom Property Schema and White-Hat SEO Architecture
Today was dedicated to search engine optimization. Google’s Quality Rater Guidelines place a huge focus on transparency and trust. If you run a real estate booking site, you need to make sure that search engines can easily find your property pricing, location, and amenity details.
The theme has built-in fields for these details, but it does not output structured JSON-LD schema by default. Without structured data, Google cannot display rich snippets (like floor plan pricing and unit availability) directly in the search results.
I wrote a PHP function that automatically extracts the unit pricing, address, and amenity details from the post metadata, and then prints a fully compliant JSON-LD RealEstateListing schema block directly into the head of each single property page:
<?php
/**
* Inject structured JSON-LD RealEstateListing Schema for search engines.
*/
function homely_inject_custom_property_schema() {
// Only run this script on single property post pages
if (is_singular('property')) {
global $post;
// Fetch custom meta values from our theme database
$price = get_post_meta($post->ID, 'property_price', true);
$size = get_post_meta($post->ID, 'property_size', true);
$address = get_post_meta($post->ID, 'property_address', true);
$bedrooms = get_post_meta($post->ID, 'property_bedrooms', true);
// Fallbacks if metadata is empty
$price = !empty($price) ? $price : '2400';
$size = !empty($size) ? $size : '850';
$address = !empty($address) ? $address : '1200 Pine St, Denver, CO 80202';
$bedrooms = !empty($bedrooms) ? $bedrooms : '2';
$schema = array(
"@context" => "https://schema.org",
"@type" => "RealEstateListing",
"name" => get_the_title($post->ID),
"description" => wp_strip_all_tags(get_the_excerpt($post->ID)),
"image" => get_the_post_thumbnail_url($post->ID, 'large'),
"about" => array(
"@type" => "Apartment",
"numberOfRooms" => $bedrooms,
"floorSize" => array(
"@type" => "QuantitativeValue",
"value" => $size,
"unitCode" => "FTK"
),
"address" => array(
"@type" => "PostalAddress",
"streetAddress" => $address,
"addressLocality" => "Denver",
"addressRegion" => "CO",
"postalCode" => "80202",
"addressCountry" => "US"
)
),
"offers" => array(
"@type" => "Offer",
"price" => $price,
"priceCurrency" => "USD",
"availability" => "https://schema.org/InStock"
)
);
// Print the JSON structured data block
echo "\n" . '<script type="application/ld+json">' . json_encode($schema, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT) . '</script>' . "\n";
}
}
add_action('wp_head', 'homely_inject_custom_property_schema', 15);
?>I tested the live output using Google's Schema Testing Tool, and it passed with zero errors. Now, Evelyn's apartments can show up in search results with active price ranges and room size details, which will help drive more clicks from organic search traffic.
Day 6: Mobile Touch Targets and Virtual Tour Embedding
On Day 6, I did some real-world mobile testing on physical devices—my phone and an older tablet. The theme’s desktop property comparison grid worked beautifully, but on smaller mobile screens, the close buttons on the unit comparison modal were tiny and difficult to tap.
Google flags small tap targets as a major mobile usability issue. To ensure a smooth experience for visitors, I added custom mobile-specific overrides to our child theme's style.css file to increase the tap areas for our property grids:
/* Mobile Property Comparison Grid Adjustments */
@media (max-width: 767px) {
.property-compare-modal .close-btn {
width: 48px !important; /* Standard touch target width */
height: 48px !important; /* Standard touch target height */
display: inline-flex;
align-items: center;
justify-content: center;
padding: 12px !important;
}
.property-grid-item .amenity-icon-list span {
padding-top: 10px !important;
padding-bottom: 10px !important;
font-size: 1rem !important; /* Make mobile text easier to read and tap */
}
/* Make contact and tour request inputs easier to select on mobile */
.property-request-form input,
.property-request-form select {
height: 48px !important;
font-size: 16px !important; /* Prevents auto-zooming on iOS devices */
}
}These simple CSS rules resolved our mobile usability issues. Tapping to compare floor plans or request a tour on a smartphone became simple, responsive, and completely lag-free.
Day 7: Live Launch, DB Optimization, and Final Performance Metrics
On Day 7, it was time to move the site from staging to live. I directed Evelyn's primary domain to our new optimized VPS server and ran a quick SQL cleanup using WP-CLI to prune out the old testing revisions and temporary transient database records:
# Delete all draft post revisions to save database space
wp db query "DELETE FROM wp_posts WHERE post_type = 'revision'" --path=public_html
# Delete all expired database transients
wp transient delete --all --path=public_htmlOnce the live cutover was complete, I ran our final speed tests on WebPageTest and Google PageSpeed Insights.
The results were outstanding. Evelyn's mobile score jumped from a terrible 21 up to a fast 93. On desktop, we hit a near-perfect 98. Our Time to First Byte (TTFB) dropped to just 40 milliseconds, and the entire homepage loaded in less than 900 milliseconds on a standard mobile connection.
Evelyn was thrilled. Her team can now easily manage booking inventory, and potential tenants can easily book tours or submit lease applications on their phones while on the go.
My Honest Technical Verdict: Pros and Cons of the Homely Theme
Now that I have spent a full week working with this theme, here is my honest and realistic breakdown of what I liked and what fell short.
The Pros
Clean and Fast Layout: The theme features exceptionally clean layout markup. It doesn't load a mountain of heavy wrapper layers or messy scripts, which makes speed optimization incredibly easy. Tailored Property Design: The pre-designed templates and custom post structures are perfect for single-property showcases. We did not have to spend days custom-designing grid sections, price inputs, or gallery blocks. Superb Responsiveness: The mobile design is modern, clean, and holds up beautifully under different screen resolutions.
The Cons
Database Query Bottleneck: As I detailed on Day 2, when you load dozens of active units and run filter searches, the theme’s search filter can trigger slow meta queries. You will need to write custom indexes or PHP filters to keep search times fast. Simple Setup Docs: The theme documentation is fairly basic. If you want to make advanced changes to templates or booking processes, you will need a solid understanding of WordPress development.
Summary
If you are building a real estate showcase or property booking platform, Homely - Single Property and Apartment WordPress Theme is an excellent starting point. It is beautifully designed, lightweight, and structured in a way that respects modern coding standards.
However, to get the absolute best performance and reach that coveted 90+ mobile speed score, you will want to use a child theme, set up indexed database tables, and configure server-side caching like Nginx FastCGI. Taking these extra steps will help you build an incredibly fast, secure, and highly profitable travel platform that your clients and visitors will love.
