One self-hosted layer in front of your app — or inside it — that caches what can be
cached, stops what should be stopped, tells you when something changes, and runs your own code.
The engine is open source and free forever.
The layer between the internet and your origin that you own and run: a reverse proxy in front
of your app, or a servlet filter inside its JVM. It sees every request before your app does
— which is why one layer can answer from cache, refuse abuse, challenge a bot, know who
each visitor is and tell you what happened.
Self-hosted, open source.
Your HTML and your visitors’ data stay on your infrastructure. The engine is
Apache-2.0, on GitHub, and free forever.
In front of your app, or inside it.
A standalone reverse proxy for an app in any language, or a servlet filter in a Java app.
Not a CDN, not a WAF.
No global network, no TLS or DDoS service, no attack-signature set — put a CDN in
front if you need one. Frontcache is the edge behind it, next to your app.
Frontcache in production — a walkthrough of the cache features running in front of
hobbyray.com (13 mins)
A short introduction — what Frontcache caches, and where it sits in the request
path (5 mins)
Performance
Your Origin Renders a Page Once, Not Once per Visitor
Frontcache caches fragments of a page rather than whole pages, so a personalized
page can still be almost entirely cached — and your app decides what is cacheable, with
a response header.
Fragment cache, per-fragment TTLs. The one block that has to be fresh stops forcing a miss on the rest of the page.
Includes, resolved in parallel.<fc:include url="…"/> markers are fetched concurrently and stitched into the response.
TTLs per visitor type. Crawlers get long-lived HTML, guests fresher content, signed-in customers their own — types you declare.
Memory and disk tiers, invalidation by tag or URL. One call clears everything tagged product.
Circuit breaking with fallbacks. When the origin fails, URI-matched fallback content is served instead of an error page.
ProCache warmer. Fills the cache from a URI list before the traffic arrives, as any visitor type, at a pace you set.
# set by your app, on the page or on a fragment
x-frontcache-component-maxage: bot:30d, guest:1h, customer:0
x-frontcache-component-tags: product|catalog
Crawlers from cache for 30 days, guests for an hour, signed-in customers never —
customer being a visitor type you declare. Invalidate by tag when the product changes.
Security
Bots and Abuse Are Stopped Before They Cost a Render
Application-layer bot and abuse control, in the same place as the cache: a request refused or
challenged at the edge is a page your origin never builds.
Guard rules and rate limits. Reject, redirect or allow by path, header, address or visitor type — with a dry run first.
Honeypot paths. A hidden path only scrapers fetch, logged with the address the node resolved behind your proxies.
Challenges with a pass that cannot be forged. A rule can send a suspicious visitor to a challenge instead of a 429; the pass is signed with your node’s secret.
Verified crawler lists. Googlebot, Bingbot and Applebot address lists kept current, so a fake Googlebot is not a Googlebot.
ProChallenge pages. A proof-of-work puzzle the browser solves in well under a second — no third party, no cookie banner, nothing leaves the site — or Cloudflare Turnstile, if you prefer it.
ProAdaptive defence. Addresses that keep tripping limits, fetch a honeypot or fail challenges are banned for a while, automatically, and released when their time is up.
ProA console for a team. Several users with roles, single sign-on and a tamper-evident audit log.
Every decision about a visitor’s request is made by open-source code you can read.
Pro features watch, serve their own pages and manage lists — your rules, run by the
open-source engine, decide.
Guests without a pass who search more than 30 times a minute solve a puzzle instead of getting a
429. Whoever fetches the honeypot — or keeps failing the puzzle — lands on the ban
list for a while (Pro), and the last rule refuses it.
Intelligence
Know Who Is at Your Edge — and Hear About It When It Matters
The edge sees every request first, so it is where you learn what your traffic is: who is a
crawler, who is a customer, which rule acted and on what.
Visitor types. Bot and guest, plus up to 16 types you declare — “customer”, “verified crawler”, “passed a challenge” — each with its own TTLs and rules.
Metrics and a request log. Prometheus / OpenTelemetry export, and a request log that names each request’s visitor type.
A realtime console. Live request rates and circuit state per node, cache inspection and invalidation, with a single-user sign-in.
Events, after the fact. Rule matches, rate limits, origin errors, fallbacks and invalidations, for any plugin to act on.
ProAlerts. To Slack, Microsoft Teams, PagerDuty, Opsgenie, a webhook, mail or syslog — with the rule, the URL and the (hashed) address that no metric carries.
ProA fleet view. The request rate of a whole cluster on the realtime monitor, and one console for many sites, each team seeing only its own.
# META-INF/frontcache-plugin.properties
id = geo
class = com.example.GeoPlugin
version = 1.0.0
plugin-api = 1
kinds = decide
# conf/guard-rules.conf
checkout-eu | uri~^/checkout ; !ext:geo:country=DE,FR | reject:403 Forbidden
A plugin of your own adds a condition; your rule uses it. If the plugin is absent or has no
answer, the rule simply does not match.
Subscriptions
Priced Per Node
The engine is free. Subscriptions add what a team needs to run the edge in production:
defence that acts on its own, alerts, warming, a console for many users and many sites,
and support with an SLA.
Community
Evaluation, side projects, and single-node deployments.
Fragment decomposition, TTL design, guard rules and header instrumentation are where the
results actually come from. We do that work, and we quantify it first.
Start here
Cacheability Assessment
$9,500 fixed fee · 2 weeks
We replay your own access log and report how it works for you — no generic benchmark.
Now with a bot-traffic section.
Origin-offload projection and the app-tier capacity it frees
Your bot share, the “crawlers” that are not, and which guard rules would have acted
A concrete fragment plan: what to split, what TTL, what tags
The plugin your edge needs, written by the people who wrote the plugin API — delivered as
a jar in your repository, under your license, tested with the public testkit.
A live session on your stack: how Frontcache fits in front of your app, a demo of fragment
caching and invalidation, and a first look at your pages. Book a weekday slot and pay with PayPal.
The $200 is credited toward an Assessment or a first-year Pro subscription ordered within 90 days.
Not against other caches. A 6× throughput gain means roughly one sixth of the app
tier — and the database, search tier, and third-party API calls behind it see the same
cut.
Pro at $3.6k per node sits deliberately below "call for a quote" territory, so it can be
bought without a committee. Enterprise sits where an MSA is worth the paperwork.
Comparable commercial caches land in the low tens of thousands per year; enterprise CDN
contracts run $50k–$500k and up.
The security side is the same arithmetic: every bot request refused or challenged at the edge
is a render your origin did not do — for traffic you did not want.
Free is everything a request needs; paid is what a team needs to run it — defence that
acts on its own, alerts, warming, many users and many sites, and an SLA.
Always free — Apache-2.0
Performance: the cache engine in both modes, includes, per-type TTLs, memory and disk tiers, invalidation, fallbacks, the benchmark harness
Security: guard rules, rate limits, honeypot rules, challenge rules and the pass check, live address lists, the verified-crawler example
Intelligence: visitor types, metrics export, the request log, the single-user console
Development: the plugin API, dropped-in plugins, the testkit and examples
Development: nothing — Pro is built on the same API you get
Support with an SLA
Every decision about a visitor’s request is open-source code you can read.
Pro features watch, serve their own pages and manage lists; whether a request is served, refused or
challenged is decided by your rules, run by the Apache-2.0 engine. And the 98.7% number has to be
reproducible by anyone with Docker, so the caching itself is never behind a paywall.
On the roadmap, not yet included: multi-region invalidation, a Helm chart and Kubernetes operator,
Java 17 and 21 LTS builds, signed artifacts and SBOM. The LTS build will be the cleanest example of the
line we draw — the open build targets the current JDK, most enterprise JVM fleets are on 17 or 21,
and a supported backport is a legitimate paid artifact, not a crippled free one.
Downloads
Get Frontcache 2.13.0
Every artifact is public read — no account, no token, no login. Pick the channel
that matches how you want to run it.
Quickest
Container image
Kubernetes, Compose, or a five-minute trial — and the supported route on Windows.
Multi-arch (amd64 + arm64), each image with a HEALTHCHECK. Carries its own
runtime, so no JDK on the host.
Serves plain HTTP on 9080 and terminates no TLS — a front door on
80/443 is a separate, deliberate step. There is no Windows build; use the container.
Installer script
The same server as a systemd service on a VM, with the JDK and a service
user included. --with-runtime takes the bundled-runtime build,
--with-console adds the console as a second service, and
--archive PATH installs from a file you staged yourself for air-gapped
hosts.
The -home.zip is not optional: configuration comes from a
FRONTCACHE_HOME directory rather than your app's config, and two
CHANGE_ME values in it must be edited before first run.
Console
Realtime stats and cache invalidation across the fleet. A separate process from the
server, on 7080.
The open build signs in a single user while being able to invalidate
cache fleet-wide — keep it on loopback or an internal network. Several users with
roles (RBAC), SSO and an audit log are part of Pro.
2.13.0 is current and is what a new install should take; 2.12.0
stays published for a rollback or a pinned fleet. Both are Java 25 bytecode
and Jakarta EE 10 (Servlet 6.0) — they will not load on an older JVM
or in a javax.servlet container, except for the container images and
bundled-runtime archives, which carry their own runtime. Every file above has a companion
checksum: append .sha256 to any link.
Plugins:org.frontcache:frontcache-plugin-api:2.13.0 (compile-only) and
org.frontcache:frontcache-plugin-testkit:2.13.0 (tests) are in the same repository —
start from the plugin template.
One running Frontcache instance in production — a standalone process or an application
instance with the filter enabled. Non-production environments are not counted.
Do I have to buy anything to run Frontcache?
No. The Community tier is free and genuinely complete for caching, guard rules and plugins.
Run the Docker quickstart, replay your own access log, and read the headers before you talk
to us.
Is the Assessment fee wasted if we do not proceed?
You keep the report either way — your hit ratio, your fragment plan, and your projected
saving. If you do subscribe, the full $9,500 is credited against your first year.
How do we pay?
Card or invoice for Pro. Enterprise is invoiced against a PO with an MSA. Partner and OEM
arrangements are contracted per agreement.
Does our HTML leave our infrastructure?
No. Frontcache is self-hosted, including under Managed Eternita Edge, which runs in your own
cloud account. That is the point for data-residency and regulated buyers. The proof-of-work
challenge calls no one; Cloudflare Turnstile and alert destinations are outbound calls only
if you configure them.
Is this a CDN or a WAF?
Neither. There is no global network, the node terminates no TLS and absorbs no DDoS, and it
ships no attack-signature set. Put a CDN in front if you need one: Frontcache is the edge
behind it, next to your app — where it can see what your pages are made of and who your
visitors are.
Who decides whether a visitor is blocked?
Your rules, run by the open-source engine. Pro features watch, serve their own pages and
manage lists — a challenge page, a ban list — but whether a request is served,
refused or challenged is decided by Apache-2.0 code you can read. Remove a Pro jar and the
node keeps serving under the same rules: a challenge rule with no challenge page becomes a dry
run, and the ban list the defence plugin kept is emptied.
Can we write our own plugin?
Yes. The plugin API is Apache-2.0, with a template, a testkit and two example plugins in the
public repository; a plugin is a jar in the node’s plugins/ directory,
enabled by name and pinned by its SHA-256. Or we write it for you.
Get In Touch
Start With Your Own Numbers
Send us an access log and we will tell you what fraction of your traffic is cacheable, how
much of it is bots, and what that is costing you. We respond within one business day.