The edge you own.

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.

98.7% Fewer origin renders
6.1× Throughput increase
41.3 → 1.6 ms p50 response time

Measured on 100,000 real requests — method on GitHub.

The Edge Side of Your App

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.

Internet CDN optional Your edge Frontcache Your app
  • 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)

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.
  • Pro Cache 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.

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.
  • Pro Challenge 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.
  • Pro Adaptive 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.
  • Pro A 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.

# conf/guard-rules.conf
search-challenge | uri~^/search ; client-type:guest ; !cookie-hmac:fc_pass ; rate:30/1m | challenge pow
honeypot         | uri~^/no-crawl/ | reject:404 Not Found | trap
banned           | client-ip:@lists/banned.txt | reject:403 Forbidden

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.

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.
  • Pro Alerts. To Slack, Microsoft Teams, PagerDuty, Opsgenie, a webhook, mail or syslog — with the rule, the URL and the (hashed) address that no metric carries.
  • Pro A 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.
# conf/alerts.conf (Pro)
{ name = challenge-broken, on = challenge.result, provider = pow,
  measure = pass-rate, below = 0.2, min-samples = 50,
  window = 10m, notify = [ops-slack] }

Tell the team when the challenge pass rate falls — an attack, or a broken page — in the channel it already watches.

Extend the Edge in Java, With an Open Plugin API

GeoIP, log shipping, a check against your own fraud signals — as a jar of your own, without a fork. Pro is built on the same API you get.

  • An Apache-2.0 plugin API. org.frontcache:frontcache-plugin-api, compiled against and never bundled.
  • Plugins that do real work. React to what happened, serve a page of their own, run in the background, or add a condition your rules can use.
  • Drop in a jar. Into the node’s plugins/ directory, enabled by name and pinned by its SHA-256.
  • A template, a testkit and two examples. A request debugger and the verified-crawler feeder, both open source.
  • A plugin that fails is a plugin that is absent. The node always starts, and a condition that turns slow is switched off for a while.
# 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.

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.

$0 forever
  • Cache engine, filter & standalone modes, includes, fallbacks
  • Guard rules, rate limits, honeypot and challenge rules, verified crawler lists
  • Visitor types, Prometheus / OpenTelemetry metrics
  • Realtime console with a single-user sign-in
  • Plugin API and dropped-in plugins
  • Community support

Enterprise

Large fleets, regulated buyers, and anyone whose procurement needs an MSA.

from $30,000 / year Site-wide, unlimited nodes

Everything in Pro, plus:

  • Unlimited nodes, site-wide license
  • 4-hour P1 response, named engineer
  • Quarterly edge review: cache and bot traffic
  • Roadmap input

On the roadmap: multi-region orchestration.

Partner / OEM

Agencies, MSPs, and hosting providers running many client sites.

Talk to Us Per-site wholesale from $600 / site / year

Everything in Pro, plus:

  • Redistribution rights
  • Partner support queue
  • One integration, N deployments

The Engineers Who Built It, on Your Edge

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
  • Dollars per year saved, with the arithmetic shown
  • Fully credited against a first-year subscription
  • A $200 demo with an engineer counts toward it

Implementation

$30k–$75k

We do the integration work end to end, then prove it under load before you rely on it.

  • Fragment decomposition
  • Header instrumentation
  • TTL and tag design
  • Guard rules, challenges and defence
  • Rollout and load validation

Custom Edge Plugins

Scoped per project

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 GeoIP or ASN condition from your own database
  • Request-log shipping to your Kafka or Loki
  • An invalidation webhook from your CMS
  • A check against your own fraud signals

Training & Enablement

$5,000 / day

A working session with your platform team so they can own fragment design and invalidation after we leave.

  • Fragment and TTL design workshop
  • Operating and debugging the cache
  • Guard rules, crawler policy and challenges

Demo with an Engineer

$200 / 45 minutes

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.

Priced Against What It Replaces

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.

Read the Benchmark

What Stays Free, and What We Charge For

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

Paid — Eternita Edge Pro

  • Performance: cache warmer, cluster request rate
  • Security: challenge pages, adaptive defence, console roles, SSO and audit log
  • Intelligence: alerts, the multi-tenant console
  • 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.

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.

Standalone server

A reverse proxy in front of an app in any language. Unpack, point it at your origin, run it.

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.

Download it, verify the checksum, then run it as root. Never curl | sudo bash.

Java library

Cache a Java app from inside its own JVM, as a servlet filter. Add the repository and let your build tool fetch it.

repositories {
    mavenCentral()
    maven { url = 'https://repo.eternita.co/maven2' }
}
dependencies {
    implementation 'org.frontcache:frontcache-core:2.13.0'
    implementation 'org.frontcache:frontcache-agent:2.13.0'
}

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.

Common Questions

What counts as a node?

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.

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.

Up to 50 MB — gzip it first. A day of traffic in combined log format is plenty; we can also send you a private upload link.

We reply within one business day. Your log is used only for this review — privacy policy.