Your own cloud. On one box. Freeloading off the edge.

freeloadr is a self-hostable function-and-content platform where every response picks its own spot on a four-mode cache spectrum — so Cloudflare’s free edge serves the traffic and your cheap home box barely notices.

No ads · No logins · No cost · No traps

The cache spectrum is a cost dial

Every response declares one mode. That single choice slides between free at the edge and fresh from origin.

Free at the edge Fresh from origin
immutable Infinite TTL. Static pubs, fingerprinted assets.
ttl Bounded freshness. Dynamic pubs, cached output.
revalidate Fresh window plus serve-stale-while-refreshing.
no-cache Zero TTL. Per-request, auth-sensitive, personalized.

Static content isn’t a separate product — it’s just the far, most-cacheable end of the same spectrum your dynamic functions live on.

One idea, four ways it pays off

Cache as a cost dial

Every response declares one of four modes — immutable, ttl, revalidate, no-cache — and that choice is a slider between “free at the edge” and “fresh from origin.”

One binary, whole cloud

Functions, CDN, database, and static hosting run from a single Go engine in one container — a mini-AWS you can hold in your head.

Freeload off the edge

Push work toward immutable and Cloudflare serves millions of requests for free; your box only sees the cache misses.

No open ports

A Cloudflare Tunnel reaches the engine outbound-only, so your origin stays hidden with nothing forwarded and nothing exposed.

Not a CDN. Not a serverless bill. Both.

A CDN caches what you hand it; a serverless platform runs your code and bills you per call. freeloadr is both, unified by one idea: a single cache grammar that every function response and page render speaks, writing Cache-Control and CDN-Cache-Control from the same emitter so the engine, the browser, and Cloudflare’s edge never disagree. Static content isn’t a separate product — it’s just the far, most-cacheable end of the same spectrum your dynamic functions live on.

Under the hood

  • Single Go binary. The engine owns routing, the function runtime, the cache emitter, and the PocketBase proxy — docker compose up runs the whole platform.
  • Per-function subprocess isolation. Each function is a compiled Go binary spawned as its own subprocess, talking to the engine over JSON-RPC stdio, kept hot in a warm pool.
  • One cache emitter, two headers. Cache-Control (browser) and CDN-Cache-Control (edge) are written from a single policy, so origin, browser, and Cloudflare agree by construction.
  • PocketBase in the container. Auth, collections, and file storage ship bundled and site-scoped — no external database to stand up.
  • Tunnel, no open ports. Cloudflare Tunnel makes the engine reachable via an outbound-only connection — no port forwarding, origin IP never exposed.