In e‑commerce, speed is revenue.

A study by Deloitte found that reducing mobile site load times by just 0.1 seconds can increase conversion rates by 8.4% for retail sites and 10.1% for travel sites. Another by Portent shows that site speed under 1 second results in 3x higher conversions than sites loading in 5 seconds.

It’s no wonder every millisecond is scrutinized—by engineers, marketers, and even search bots. However, the faster you try to go, the more you encounter a significant challenge: dynamic content.

Prices, inventory, promotions, local availability, flash sales. These are the lifeblood of e‑commerce, and they change constantly. Which has led to a frustrating trade-off:

• Either you prerender your pages for maximum speed,
• Or you load them dynamically to reflect real-time data.

At Harper, we’re helping retailers erase that trade-off entirely.

‍

The Old Excuse: “My Pages Change Too Often to Prerender”

We’ve heard this line again and again from retailers, travel brands, marketplaces, and SaaS companies alike:

“I love the idea of prerendering, but my pages are just too dynamic. My [price/inventory/promo slots] change every few minutes.”

It’s a fair concern—most prerendering tools weren’t designed for live commerce. They’re built to generate HTML ahead of time and cache it, but they don’t control the underlying data layer. This means that if the price changes, you have to re-render the entire page, invalidate caches, and hope the update propagates globally before a bot (or worse, a buyer) sees stale data.

But what if you could prerender most of the page, cache it for a long time, and inject just the dynamic attributes at the moment of the request?

That’s exactly what Harper enables.

‍

A New Pattern: Prerendered Shell + Dynamic Attributes

Let’s break it down.

1. Prerender the shell. Generate and cache the bulk of the page, including layout, product descriptions, imagery, SEO metadata, reviews, and other content. This is the stable stuff that rarely changes.
   
   
2. Store dynamic fields separately. Place fast-changing data (like price, inventory, sale status, availability) in a small attributes table in the database.
   
   
3. Inject on request. When a customer or bot loads the page, those dynamic fields are fetched from the database embedded in Harper and injected into the page in real time—usually in single-digit milliseconds.
   
   

This pattern solves the “too dynamic to prerender” problem. And it’s only possible because Harper combines the applications, database, cache, and messaging functions into one distributed runtime.

Instead of bouncing between SaaS layers (CDN ➝ origin ➝ DB ➝ back again), everything happens inside a unified environment—where logic, data, and distribution are tightly integrated.

While frameworks like Next.js use approaches like Incremental Static Regeneration (ISR) to blend static and dynamic rendering, they still rely on external APIs or origin data sources to fetch live content. This introduces latency and complexity—especially at scale. In contrast, Harper brings the data layer into the same runtime as the application, enabling dynamic attribute injection with significantly lower overhead and faster response times.

What Needs to Stay Dynamic?

You don’t need to dynamically render everything—just the parts that drive action or reflect real-time availability.

According to Google’s Merchant Center product data spec, there are 15+ baseline data attributes needed for SEO/SEM-rich snippets and product listing ads (PLAs). These include:

• id
• title
• description
• link
• image_link
• availability
• price
• brand
• GTIN / MPN
• condition
• sale_price
• shipping
• product_category

In many enterprise use cases—especially B2B—this list expands. A Fortune 100 retailer we’ve worked with added 12–15 custom attributes to their business portal to distinguish it from their direct-to-consumer (D2C) experience. These include negotiated pricing, stock at distribution centers, customer segment visibility, and more.

By dynamically injecting just these fields at runtime, you can cache the rest of the page for hours, days, or even weeks without worrying about stale data.

‍

CDNs Can’t Do This Alone

This isn’t something a traditional CDN can pull off.

They’re great at serving static content. But they don’t own the app tier, can’t connect to your live database in milliseconds, and can’t process business logic inline.

That’s why most prerendering solutions stop at “generate + cache.” They offer speed, but at the cost of flexibility.

Part of the issue is that traditional CDNs treat caching as an all-or-nothing operation—either the whole page is cached or it isn't. This forces developers into brittle cache-invalidation strategies or frequent rebuilds. Modern frameworks have tried to solve this at the rendering layer, but without owning the underlying data infrastructure, these workarounds can’t match the speed or cost efficiency of Harper’s native dynamic prerendering.

Harper breaks that ceiling by collapsing the stack into one runtime:

• Database for storing structured dynamic attributes
• Cache for keeping both static shells and attribute values regionally distributed
• MQTT / APIs for real-time updates across regions
• App tier to merge and serve content inline

This setup enables global distribution without the latency tax. Your customer in Frankfurt sees fresh prices as fast as your customer in San Francisco—because their data is already there.

‍

What This Unlocks Next

Once you’ve mastered dynamic attribute injection, you open the door to true micro-personalization at scale.

Imagine identifying individual divs on a page by id—and tying them to live queries that reflect:

• Loyalty-tier-specific discounts
• Store-level inventory
• Location-based messaging
• AI-recommended bundles

Beyond performance, this expands what’s possible. You can deliver hyper-relevant experiences without compromising your architecture or introducing seconds of latency.

And because all of it lives in a distributed fabric with linear scaling, the cost and complexity remain predictable, even at enterprise scale.

‍

How to Get Started

Unlike other solutions that require re-platforming or deeper integration with custom caching layers, Harper can sit in front of your existing stack. You don’t have to rewrite your app or re-architect your frontend. Just plug in attribute injection and start delivering dynamic content at static speeds.

You don’t need to rewrite your app to take advantage of this.

Here’s a simple roadmap:

1. Audit your PDPs or landing pages. Which fields are dynamic? Which aren’t?
2. Split your templates. Create a “static shell” and define “dynamic slots” for attribute injection.
3. Set up a lightweight attributes table. Use Harper’s built-in DB (this is the lowest latency option) or connect your own via API or MQTT.
4. Prerender your shells. Cache them globally with Harper’s infrastructure.
5. Inject live data at request time. Keep the experience fast and fresh.

You’ll instantly benefit from improved Core Web Vitals, better SEO crawl efficiency, and a faster path to conversion—without rebuilding your front end.

‍

Final Thoughts

The traditional trade-off between speed and flexibility is fading.

Thanks to Harper’s integrated architecture, prerendering is no longer just for blogs or marketing pages. It’s now viable—and essential—for high-velocity commerce sites where milliseconds matter.

By separating what’s dynamic from what’s stable, and bringing data closer to your customers, you get the best of both worlds: static speed and live accuracy.

It’s the next step in the evolution of performance—and the path is ready for you to walk.

→ Want to see it in action? Reach out to our team to learn more.

‍