Your origin renders a page once, not once per visitor.

A cache of page fragments, not whole pages, in front of your app or inside it — so a personalized page can still be almost entirely cached, and your app decides what is cacheable with a response header.

  • Per-fragment TTLs. The one block that has to be fresh stops forcing a miss on the rest of the page.
  • Includes, fetched in parallel. <fc:include> markers are resolved concurrently and stitched into the response.
  • TTLs per visitor type. Crawlers get long-lived HTML, guests fresher pages, signed-in customers their own.
  • Any origin language. A reverse proxy in front of anything that can set a response header, or a servlet filter inside a Java app.
98.7%

fewer origin renders, measured on a replay of 100,000 production requests against a live app — cache on vs. off, byte-identical responses. How it was measured

Know your hit ratio before you buy anything

Send us an access log and we tell you what fraction of your traffic is cacheable and how much of it is bots. Free; we reply within one business day.

Up to 50 MB — gzip it first. A day of traffic in combined log format is plenty.

Your log is used only for this review — privacy policy.

A Page Is a Composition

Your origin returns a page with <fc:include url="…"/> markers in it. The edge fetches each fragment through the same cache — in parallel — and stitches the answers into the response. Every fragment has its own TTL, its own tags and its own cache level, so a miss on one does not cost the others.

That is what makes a personalized page cacheable. The cart badge stays dynamic while the header, navigation, footer and product body cache for hours.

A fragment can be for some visitors only — crawlers, guests, or a type you declare. And fragments that miss together can be fetched from your origin in one call, if your origin opts in, each still cached under its own key.

Nothing is cached until your app says so. The default TTL is zero, so an origin that sets nothing gets a pure pass-through — a safe place to start.

<!-- the page your origin returns -->
<fc:include url="/common/header" />
<fc:include url="/product/42/body" />
<fc:include url="/cart/badge" />
<fc:include url="/store/cell?id=42" combine="true" />
<fc:include url="/seo/footer" client="bot" />

Each marker is a fragment with its own lifetime; combine batches misses into one origin call, client limits who sees one.

# response headers your app sets on a page or a fragment
x-frontcache-component-maxage: bot:30d, guest:1h, customer:0
x-frontcache-component-tags: product-42|catalog
x-frontcache-component-refresh: soft

Crawlers from cache for a month, guests for an hour, customers always fresh; tagged for invalidation; refreshed in the background while the stale copy is served.

A Slow Fragment Degrades. It Does Not Fail the Page.

Every call to your origin goes through a circuit breaker, and every fragment has somewhere to fall back to.

Fallbacks, not error pages

When the origin answers 5xx or its circuit is open, content matched by URI pattern is served instead. A fragment that times out falls back the same way, and the rest of the page is served.

Stale while it refreshes

With refresh: soft an expired entry is served once more while a fresh copy is fetched in the background, so the visitor is not kept waiting on the render.

Invalidation by tag or URL

One call clears every fragment tagged product-42, on every page that includes it — through the management API, or the Java agent that sends it to every node of a cluster.

Memory and disk

A memory tier in front of an on-disk index under the node’s home, so the working set is not limited by the heap. A fragment can be held in memory only.

Two ways in, one behaviour

A reverse proxy to an origin in any language, or a servlet filter inside your Java app — JSP and Spring included. Everything after the request arrives is the same engine.

What the Benchmark Shows — and What It Doesn’t

A replay of 100,000 real production requests against a live app, run twice back to back: once with the cache on, once with it switched off. Same app, same machine, same request stream, byte-identical responses.

98.7% Fewer origin renders (79,900 → 1,003)
41.3 → 1.6 ms Median response time
6.1× Throughput, same concurrency

Whose site

hobbyray.com, a site we operate. The mechanism generalizes; the exact multiplier does not.

Whose hit ratio

98.7% is that replay’s working set — a hot set by construction. Over the site’s full 681k-request log the same harness measures about 66.7%. Yours will depend on your TTLs and traffic shape.

What got worse

The worst case. p99 improved only 42% and the single slowest request got slower: the uncached remainder queues behind 6× the throughput. Size the origin for that fraction.

A Full Cache Before the Traffic Arrives

Fill the cache from a list of URLs — after a deploy, before a sale, on a new node — at a pace you set, so the origin is rendering at your speed, not the crowd’s.

Warmed exactly as a visitor would be served. Each URL goes through the node’s own front door, as the visitor type you choose — crawler, guest or one you declare — so what is stored is what that visitor reads. A refresh run overwrites entries without removing them first, so nobody meets an empty cache halfway through.

From the console. Edit or upload the list, check sample keys before the run, start it and watch it.

Cluster request rate

Each node’s card on the realtime monitor shows what its whole cluster is taking, beside the node’s own — the traffic a site takes, summed.

And with every Pro node

Challenge pages, adaptive defence, alerts, a console for many users and many sites, and support with a 1-business-day response.

The Cache Is Free. Warming It Is Pro.

The whole cache engine is Apache-2.0, in both modes. Pro adds the warmer and the fleet view — $3,600 per node per year, 2-node minimum.

Capability Community — free Pro
Fragment cache, includes, combining Included, reverse proxy and servlet filter Included
TTLs per visitor type Bot, guest and up to 16 declared types Included
Memory and disk tiers Included Included
Invalidation, fallbacks, circuit breaking Included Included
The benchmark harness In the repository — replay your own node’s request log Included
Cache warmer — From a URL list, as any visitor type, at your pace, from the console
Cluster request rate Per node Per node and per cluster

Origin Offload, Not a CDN

Know where the line is before you buy anything.

Not a CDN

It composes with one. Keep your CDN for TLS, static assets, global points of presence and DDoS absorption; this sits at the origin and takes the page rendering off your app.

Not automatic

It caches what your app marks cacheable, and nothing else. Getting the most from it means setting TTLs per fragment — which is what the Assessment and the implementation work are for.

A cache per node

Each node keeps its own cache. Invalidation reaches every node through the API or the Java agent; entries are not shared between nodes.

Start With Your Own Numbers

Send an access log for a free first look at what is cacheable — or have us replay it and write the plan: the $9,500 Cacheability Assessment, credited toward a first-year subscription.