One source. Every channel. Every past state, one query away. AI that does real work — not just chat — and a published artifact you can roll back with a pointer.
Your content team moves faster — without waking up engineering.
Content is source code.
Your site is a compiled artifact.
Here's what changes once you accept that.
Each of these is a consequence of the thesis above, not a separate feature we shipped. Most CMSes pick one and call it a product. We built all four onto the same compiler — and let you take the static output anywhere.
Because compiled artifacts don't crash. The output is plain HTML, CSS, and assets — sitting in storage, served globally. There's no runtime database, no app server, no edge compute, no request-time rendering. Every page is already built before it goes live; requests just fetch files.
Because compiled artifacts can be versioned. Releases bundle content, templates, types, routes, theme, and settings into immutable artifacts that move across environments unchanged. Same release in staging and production. No drift. Ever. Reviews gate every deploy. Schedules, A/B tests, and drip publishing all fall out of the same primitive.
Because source code can be transformed. Configure your voice once. Every AI surface in the system speaks in it: drafts, image generation, bulk rewrites, visual edits, expand-thin-content, SEO descriptions. Drop a document and walk away — article, social posts, email draft, hero image, SEO metadata waiting when you come back.
Because every release is preserved forever. Every state of your site is a fact in a graph. Nothing gets overwritten. Replay any past day. Roll back the entire site — content, theme, routes, settings — atomically. Who changed it, when, what was live on a specific date, which version was approved — all answerable as graph queries. SOX, HIPAA, FDA Part 11 answered natively, not bolted on.
Site(env, time) renders the historical site in full fidelity
A Release is a pointer fact.
→ Deploy = one pointer. Rollback = the same pointer backwards. A/B = multiple pointers with weights. Drip = N pointers with staggered validFrom.
If the failure mode doesn't have a thing to fail, it can't fail. Most CMSes ship the things; we shipped the absence.
| Traditional CMS | StaticOwl |
|---|---|
| App server crash | No server |
| Database outage | No database |
| Slow queries | No queries |
| Traffic spike overload | No compute to overload |
| Cold-start delay | No cold start — files are already at the edge |
| Bad deploy bricks the site | Instant pointer-flip rollback |
The same compiler that emits HTML emits social posts, print flyers, QR-coded yard signs, email blasts, and ad creative — all derived from the same content, all versioned in the same Release, all replayable as part of the same audit chain.
HTML on a CDN. Already shipping.
One source → IG / Twitter / LinkedIn / story formats. Aspect-ratio aware.
300 DPI, CMYK-ready PDFs. Letter, legal, A4, custom.
Print-resolution PNG/PDF for any size. Real-estate, event, retail.
Native generator, scannable at print scale. Points wherever you want.
Cross-client-safe HTML. Same content, channel-appropriate template.
Display-ad sized images. Banner, square, rectangle, tower.
Plain text or SEO-friendly HTML for video / podcast / talk content.
"Show me every public-facing asset derived from Product X during the recall window."
One graph query. Web pages, flyers, social posts, ad creative, signage — every artifact, every version, every approval. That's the audit trail every other CMS handwaves.
// Web pages ship today. Phase 2 brings social, flyer, sign, email, ad compilers online.
We built StaticOwl for teams who want to publish, not for teams who want to shop for CMS features.
Train a Voice Profile once — style guide, tone, words you use, words you never use, sample posts — and every AI surface in the system speaks in your site's voice. Document import, bulk rewrites, visual edit, expand-thin-content, all of it.
Drop a podcast, talk, or interview. We transcribe it, then derive a blog post, show notes with chapter timestamps, three Twitter posts, a LinkedIn post, and an SEO transcript page in one pass. One upload, six outputs.
Drop a 50-page document. The AI matches its sections to your content types, drafts a hierarchy of pages with the right field values, and lets you approve what to keep. Manual re-keying is the killer of CMS migrations — we handle it.
Visual edit mode: click any text on the rendered preview, type "make this shorter" or "rewrite as a question," approve the AI's proposal. Cursor for content. Voice profile applied automatically.
Bundle the changes you want to ship into a Release. AI checks it for problems. Schedule the deploy for a specific time. Promote the same Release through staging to prod — no copying, no drift.
One click scans every page for missing alt text, broken internal links, thin content, missing SEO descriptions, stuck drafts, duplicate slugs. Most issues are AI-fixable in one more click. The dashboard becomes an active operator, not an analytics page.
Writers and marketers drop hero sections, CTAs, image galleries, and testimonials straight into the page — no Figma ticket, no dev sprint. The template decides where things can go; they fill it in.
The site is static HTML on a CDN. No runtime database, no edge functions, no "why is my app server melting?" There's nothing for traffic spikes to knock over.
Every content type, every page, every template is a node in a graph you can export. Build output is plain HTML in a bucket you own if you want it. If we ever disappear, you keep your site.
Compiling content is the architecture decision. Everything below is what we ship on top of it — and what you actually pay for. This is the inventory.
BM25 fulltext + flat vector + HNSW vector. Auto-rebuild on compaction with lineage stamping. POST /api/public/search from any static page, CORS-friendly, rate-limited per IP — ranked results in single-digit milliseconds.
Customer-authored JavaScript runs in a hardened V8 isolate (isolated-vm) with a 32MB cap, wall-clock timeout, and zero ambient globals. Execution modes: build-transform (runs at compile) + inbound-webhook (HMAC-authed external events). Capability-scoped, versioned, audited.
Voice profile per site — style guide + tone + preferred/forbidden words + sample posts. Every AI surface speaks in it: drafts, image generation, bulk rewrite, document import, visual edit, expand-thin-content, SEO descriptions. Drop a PDF, get a hierarchy of structured pages.
Cryptographic hash chain over every mutation at the engine layer. Every state of every record preserved as a graph fact, indexed bitemporally (valid-time + transaction-time). Replay the site exactly as it appeared on any past instant — content, theme, routes, settings.
A release is an immutable bundle: content, templates, content types, routes, theme, settings — all of them, all together. Reviews (AI / automated / manual / compliance) gate every release with blocking findings. Deploy and rollback are the same operation in opposite directions: one pointer write.
One compile, many outputs. HTML to a CDN. Social posts. Email bodies (cross-client-safe). Print-resolution flyers (CMYK PDF). QR codes at scannable scale. Display-ad sized images. Plain-text transcripts. All derived from the same content records, all in your voice.
Native Model Context Protocol surface. Claude, Cursor, or any MCP-aware client drives the platform: list sites, query content, mutate records, trigger builds, run algorithms, fast-import data, perform vector search. The full admin API as a tool catalog.
Static Export (free): emits plain HTML/CSS/JS to a bucket you own. Your CDN, your IAM, your downstream services. GitHub Mirror (free): pushes compiled site + JSON sidecars to a repo per deploy. Managed Atomic-Release (paid): content-addressed artifacts + Lambda@Edge resolver, blue/green pointer-flip deploys at the CDN.
Adopting StaticOwl shouldn't mean a platform migration. We swap the authoring + compile layer; we leave the rest of your stack alone. Use what you have. Add what helps.
Compile is the page render — not the whole stack. Your Lambdas, your origin compute, your auth API, your gamification / leaderboard / analytics services keep doing their thing. We never see them.
Your JWT issuer, your session store, your login UI all stay where they are. We don't require Cognito or a particular identity provider. Customer sites are unaware of our admin auth.
Same EventBridge / Mixpanel / Plausible / Pinpoint setup. We don't insert tracking and don't request the data. Your dashboards keep showing your numbers.
Content types are yours; you declare the fields. Liquid templates emit anything text. Free Static Export tier writes to your bucket — your CDN, your invalidation logic, your TLS certs.
// The pattern: use us as the authoring + compile layer; keep the rest of your infrastructure exactly as it is. Free static export → your S3 bucket → your CDN → your Lambdas.
An editor wants to publish a blog post with a hero image and a call-to-action. Here's what that looks like on the stack you have today vs. on StaticOwl.
Same compiler. Three output targets. Your call which fits today — switch any time, or run more than one in parallel.
Plain HTML, CSS, JS, and assets at predictable URLs. Compatible with anything that serves files: S3 + CloudFront, Netlify, Vercel, Cloudflare Pages, your own nginx.
Push the compiled site plus a JSON sidecar for every page + _meta/ definitions to a repo you own. One commit per deploy. Fork it, host it, leave us — your content + metadata live in your repo.
_meta/types.json, _meta/theme.json, _meta/release.json — the site is self-describinggit cloneContent-addressed artifacts + sharded manifest + Lambda@Edge resolver. Adds atomic blue/green deploys and instant rollback at the CDN layer.
// Operators choose with one env var. Switch modes any time.
A customer files a claim on August 15. The policy was retroactively endorsed on August 10. Legal asks: "What exactly was on the portal when our customer took action on August 13?"
Most CMSes can't answer that question. StaticOwl can — because every state of your site is a fact in a bitemporal graph that can never lose history, indexed separately by what was true and what you knew when. Full architecture for compliance officers →
// The wedge
| Auditor asks | Most CMSes | StaticOwl |
|---|---|---|
| "Show me the customer portal exactly as it appeared at 2:14 pm on August 13." | Can't reconstruct. Best case: a database snapshot from that night, missing every change between snapshot and 2:14 pm. | Single query against the deployment fact log. Renders the historical site in full fidelity — content, templates, theme, settings, linked assets. |
| "Prove that nobody — including admins — silently rewrote our legal disclosure." | "Trust our audit log." (Same admins can edit the audit log.) | Hash chain over every mutation. Tampering breaks the chain in a way an external auditor can verify with read-only access. verify-audit-chain ships as a binary. |
| "Who specifically approved this content for production, and when?" | "Check the project tracker." (Maybe the right ticket; maybe not.) | Named signer is a graph fact on the Release. Reviewer + findings + decision recorded with the Release ID. Direct query, no archaeology. |
| "GDPR Article 17: erase this customer's data without breaking the audit trail." | Database delete — the row is gone, and so is the proof you ever had it. Article 30 audit fails. | destroySubjectKey replaces PII with an opaque marker. Chain integrity preserved. The fact that an erasure happened remains. Articles 17 + 30 both satisfied. |
| "SOX §404 evidence: prove your internal controls over published financial reporting." | PDFs of change-management procedures. Hope the auditor accepts process documentation. | The release log is the control evidence. Every release: who, when, which reviewers, which findings, which approvals, all signed and chained. Hand over the export bundle. |
| "When was this disclosure first published, and what was its exact wording on day one?" | Git-blame the Markdown file. Hope the Git history wasn't rewritten. | Bitemporal query — both valid-time (when the disclosure took effect) and transaction-time (when you recorded it). Backdated edits show as backdated; retroactive corrections preserve the original. |
// Every claim above is a query we'll run for you on a sample dataset before you commit. Send us your auditor's questionnaire — we answer with citations, not marketing.
Built on InvariantDB. Every record carries valid-time (when it applied in the real world) and transaction-time (when you recorded it). The claim-on-August-15 / endorsement-on-August-10 question is a single query — not a subpoena-response archaeology project. Same primitive answers backdated contract amendments, predated trades, retroactive HIPAA changes.
AI review + automated review + manual approval + compliance checks all attach to the same Release. Blocking findings prevent deploy with a 409. Stale reviews trigger automatic re-runs when dependencies shift.
The graph engine maintains a hash chain over every mutation. You can prove the version of any content node at any past instant — and prove that nobody (including admins) tampered with the trail.
"Show me the site as it appeared to a user on March 12 at 2:14pm." A single graph query against the deployment fact log. Render the historical site in full fidelity — content, templates, theme, settings.
Every deploy is an immutable record: who, when, which Release, which Reviews passed, which findings were dismissed and by whom. SOX-relevant. HIPAA-relevant. FDA Part 11-relevant.
Not "restore from backup." Not "redeploy old code." A new deployment fact pointing at an older Release. Atomic at the CDN layer. Audit-stamped. Reversible with the same operation in reverse.
Every heading, paragraph, FAQ entry, and CTA on this page is a content record in a graph. This page is a compiled artifact, produced by the same engine you're evaluating. You aren't imagining the product — you're using it.
// Sign in as an editor and the page lights up an edit-bar. Click any heading to rewrite it in place.
We're in early access. Here's what that actually means.
{ order, topic, lessons[], quiz, search_keywords, html_content }, your template emits exactly that shape. We don't impose a proprietary structure on either the input or the output.isolated-vm, not node:vm — actual security boundary), 32MB memory cap, wall-clock timeout, zero ambient globals. Curated capabilities only: graph.query (read-only), utils.http.get/post, console, host helpers. Two execution modes: build-transform (runs at compile time on content records) and inbound-webhook (runs on HMAC-authenticated external events at /api/hooks/<site>/<slug>). Capability + secrets model is declarative — your script opts in to what it can reach. Versioned at the graph layer; rollback is a pointer flip. Honest framing: this isn't Cloudflare Workers in feature breadth — no per-request HTTP at every edge POP — but it covers content-compile + audit-lifecycle code that most teams currently run as a Lambda. Functions architecture →_meta/ definitions to a repo you own (one commit per deploy) — auto-publishes via GitHub Pages, Cloudflare Pages, or Vercel on push. The managed atomic-release tier is the optional upgrade for pointer-flip deploys at the CDN layer; you can run any combination side-by-side.Software-grade deployment, rollback, approvals, AI production, and audit history — for every piece of content you publish. Marketing site, customer portal, knowledge base, regulated publishing workflow — same primitive. Early access is free; we'll help you migrate.
// Or email founders@staticowl.com. We read every one. Usually reply same day.