Skip to content

Choose your path

The complete production system. Your way.

The OS

Full codebase. Deploy yourself.

One-time purchase

  • Complete source code — all 200+ features
  • Production Kubernetes deployment (Helm + OpenTofu)
  • AI agent framework with MCP server
  • 60+ design system primitives
  • Full CI/CD pipeline (GitHub Actions)
  • Architecture docs and decision records
Stay in the Loop
Recommended

OS + Launchpad

Stay current. Get up to speed fast.

Annual subscription

  • Everything in The OS
  • Continuous updates as the stack evolves
  • Priority support (direct access)
  • Onboarding sessions with Jesse
  • Migration guidance from your current stack
  • Architecture review of your customizations
  • Early access to new features and integrations
Stay in the Loop

Optional add-on

Fractional CPO/CTO

Product and technical leadership on demand. Available as an add-on to any tier.

Monthly subscription

  • Fractional product/technical leadership
  • Architecture reviews and roadmap planning
  • Team hiring and onboarding guidance
  • Technical due diligence support
  • Investor-ready architecture documentation
  • Direct Slack/async access to Jesse
Stay in the Loop

What's included

The complete feature list

Every system, every integration, every workflow. All production-ready.

Authentication & Security

Enterprise-grade auth, MFA, OAuth 2.1, and security hardening

21
  • Session-based auth (httpOnly, SameSite, Secure)
  • API key auth (SHA-256 hashed, shown once at creation)
  • OAuth 2.1 with PKCE + dynamic client registration
  • Google + Microsoft social login
  • TOTP authenticator app MFA
  • WebAuthn / Passkey support
  • Recovery codes
  • Email verification (mandatory)
  • Password reset flow
  • RBAC — Owner, Admin, Member, Viewer
  • CSRF protection on all mutations
  • Rate limiting on all endpoints (read, write, LLM tiers)
  • RBAC role caching (Redis, signal-invalidated)
  • LLM prompt injection prevention — active sanitization at the LLMFactory boundary
  • Request body size limits (5MB)
  • API key tenant mismatch detection
  • Passkey-encouraged signup (progressive registration)
  • Account enumeration prevention
  • Security headers (HSTS, CSP, X-Frame-Options)
  • Dependency vulnerability scanning (Dependabot, pip-audit, npm audit)
  • Non-root container security contexts

Multi-tenancy & Teams

Full tenant isolation, team management, branding, and invitations

15
  • Tenant-scoped data isolation (middleware + model layer)
  • Team invitations with email + token hashing
  • Member role management (change, remove)
  • Extended member profiles (avatar, phone, timezone, title)
  • Tenant branding — OKLCH color customization
  • Tenant logo upload (public CDN URLs)
  • Tenant slug + display name
  • Session version tracking (force re-auth on role change)
  • Cross-tenant context safety via signals
  • MFA enforcement per tenant
  • Onboarding checklist (floating widget, progress ring, confetti)
  • Configurable onboarding steps (admin-defined, auto-progress)
  • APP_NAME whitelabel branding (emails, admin, MFA issuer)
  • Public user profile popovers (click-to-view)
  • Tenant data portability — `manage.py export_tenant` for customer handoff and exit

AI Agents & LLM

5 agent types, tool registry, auto-routing, streaming, HITL

23
  • Web search agent (Serper.dev + synthesis)
  • KB support agent (RAG with citations)
  • Project status agent (read-only analysis)
  • Project creation agent (HITL confirmation)
  • Project ideation agent (brainstorm + web search)
  • Auto-routing via LLM classification
  • Conversation threading (multi-turn)
  • SSE streaming via Redis pub/sub
  • Human-in-the-loop (pause/resume)
  • Tool whitelisting per agent type
  • Cost controls (max iterations + time limit)
  • Agent eval harness — file-based test corpus, `/eval` slash command, side-effect-free runs (no quota burn)
  • Provider-aware LLM caching on supported models
  • LLM factory with multi-provider support (litellm)
  • Model fallback chains
  • Prompt injection sanitization (active filtering of user/tool messages before LLM dispatch)
  • LLM usage tracking per call
  • OpenAI function calling export
  • AI provenance tracking (`<AiBadge>` + EU AI Act Article 50 compliance)
  • Persistent AI memory (dual-scope: tenant-shared facts + user-private preferences, RAG-injected at thread root for cache-stable replies)
  • AI Memory management UI — users curate the shared and personal memory store the agents draw from, with admin-only edit on shared rows
  • Agent chat UI — threaded conversations, markdown rendering (GFM), live SSE streaming, mobile-first responsive (320px+), entered from the help widget or `/agents`
  • Cross-conversation thread memory — replies replay the same memory fence verbatim so the system prompt stays byte-stable for prefix caching

MCP Server

Every endpoint is an MCP tool — Streamable HTTP, OAuth 2.1, stateless

10
  • Streamable HTTP transport (JSON-RPC)
  • OAuth 2.1 Bearer token auth
  • API key auth (works alongside OAuth — backward-compatible Bearer tokens)
  • Dynamic client registration (RFC 7591)
  • PKCE + loopback redirect URIs
  • Platform provisioning (ChatGPT, Copilot Studio, Vertex AI)
  • Stateless per-request auth (horizontal scaling)
  • Token lifecycle (1h access, 30-day refresh + rotation)
  • Stale token + client cleanup (Celery Beat)
  • Connected Apps management UI

Billing & Monetization

Stripe integration, trials, subscription gate, billing portal

12
  • Stripe integration via dj-stripe
  • Checkout session creation
  • Customer portal link
  • Plan + PlanFeature models
  • Trial auto-creation on signup
  • Trial expiring + expired notifications
  • Subscription gate (paywall component)
  • LLM usage tracking per feature
  • Webhook-driven sync (25+ behavioral tests)
  • 3 fixture plans for development
  • Plan quota enforcement (HTTP, MCP, and agent paths)
  • QuotaGate paywall with usage indicators

Notifications & Webhooks

Email, in-app SSE, HMAC-signed webhooks, lifecycle emails

14
  • Email notifications (Resend / any SMTP)
  • In-app SSE real-time notifications
  • Per-category, per-channel preference management
  • Mandatory notification flags
  • HMAC-SHA256 signed webhooks
  • Webhook signing secrets encrypted at rest
  • Webhook retry with delivery log
  • Curated event catalog (internal → public mapping)
  • Branded email templates (dark mode, Outlook VML)
  • Welcome email on verification
  • Trial expiring / expired lifecycle emails
  • Weekly changelog digest (Celery Beat)
  • In-app product changelog page — categorised entries (feature / fix / improvement) with AI provenance badge per EU AI Act Article 50, accessed from the help widget
  • Notification bell with SSE dropdown inbox

Search & Knowledge Base

Hybrid vector search, RAG, help center, in-app help widget

16
  • Hybrid search (vector + keyword, RRF fusion)
  • pgvector embeddings (HNSW index)
  • Stored tsvector with GIN index
  • Keyword fallback (SQLite-compatible)
  • Unified search dispatcher
  • Knowledge base articles (Markdown + frontmatter)
  • Heading-aware chunking (500-token sections)
  • Help center (Docusaurus, Cloudflare Pages)
  • Dual docs (user guides + developer docs)
  • Client-side search (Pagefind)
  • In-app help widget with KB search
  • Contextual help links to articles
  • "Ask AI" button → RAG support agent
  • Cmd+K command palette (global search)
  • 6 locales in app (help center English-only)
  • Persistent AI memory — RAG over user-curated context (cross-listed with AI Agents)

Observability & Operations

Sentry, OpenTelemetry, structured logging, audit trail, PostHog

19
  • Sentry error tracking + structured logs
  • OpenTelemetry distributed tracing + APM
  • Automated error triage + GitHub issue creation (scheduled)
  • Auto-instrumentors (Django, Celery, Redis, psycopg, httpx)
  • Manual spans on LLM calls + tool execution
  • Structured logging (JSON prod, text dev)
  • Audit trail (EventLog with tenant + user attribution)
  • Audit categories (billing, team, projects, agents, system)
  • Audit log UI with filtering + date range picker
  • django-simple-history (field-level change tracking)
  • PostHog analytics (frontend events + tenant/user identity)
  • Live dashboard (animated metrics, sparklines, activity feed)
  • Celery Flower monitoring (opt-in Helm template)
  • Analytics event retention policy (configurable, batch prune)
  • GDPR-safe (no PII in errors or logs)
  • Slow query logging (pg_stat_statements)
  • PostHog feature flags (gradual rollout, A/B testing)
  • Public status page (cloud-agnostic, off-cluster, 90-day uptime history)
  • Live marketing footer status pill (green/amber/red, updates every 60s)

Infrastructure & Deployment

Kubernetes, Helm, OpenTofu, Cloudflare, GitHub Actions, <€10/month

28
  • Kubernetes deployment (k3s on Hetzner)
  • Helm umbrella chart (app, worker, beat, migrations)
  • OpenTofu infrastructure-as-code
  • Cloud-agnostic (Hetzner, GCP, AWS — same Helm chart)
  • Cloudflare CDN + DNS
  • Cloudflare R2 for static/media storage
  • Presigned URL file uploads (S3-compatible)
  • GitHub Actions CI/CD pipeline
  • Docker multi-platform builds (ARM64)
  • Celery worker + dedicated agents queue
  • Celery Beat for scheduled tasks
  • PostgreSQL 16 with pgvector
  • Redis 7 (cache + pub/sub + task broker)
  • Horizontal scaling (stateless pods, shared-nothing)
  • High availability (CloudNativePG, rolling updates)
  • Zero-downtime rolling deploys (Helm + K8s)
  • Under €10/month full-stack cost
  • Marketing website (Astro + Cloudflare Pages)
  • PgBouncer connection pooling (CloudNativePG)
  • Automated database backups (Barman to R2, 6h schedule)
  • Disaster recovery testing scripts
  • Kubernetes liveness + readiness health probes
  • HPA autoscaling templates (CPU/memory, configurable)
  • Pod disruption budgets (rolling update safety)
  • Staging environment config (on-demand deploy from any branch)
  • Declarative backup configuration (Helm values)
  • Redis Sentinel HA mode (documented, config-ready)
  • Read-through Redis cache for hot role lookups — keeps tenant-scoped requests off the primary DB under load

Frontend & Design System

60+ primitives, Storybook, WCAG 2.1 AA, i18n, dark mode, mobile-first

21
  • 60+ shadcn/ui design system primitives
  • Composed components (DataTable, FormField, Sidebar, etc.)
  • Storybook with autodocs + accessibility addon
  • Chromatic visual regression testing
  • WCAG 2.1 AA accessibility (lint + dev + CI)
  • Dark mode (system preference + manual toggle)
  • Mobile-first responsive (320px minimum)
  • OKLCH color tokens (perceptual uniformity)
  • Tenant branding via CSS variable override
  • React 19 with TanStack Query
  • Type-safe API client (openapi-fetch + generated types)
  • Single-RTT cold mount (`/api/bootstrap` collapses user + tenants into one request)
  • i18n with 6 languages — ESLint guard blocks hardcoded JSX strings, per-key untranslated detection in CI (strict mode)
  • Code splitting (route-level lazy loading)
  • Route-level error boundaries
  • PWA / service worker (offline-ready)
  • One-command PWA icon generation (SVG → all PNG sizes)
  • Brand hue sync across 6 surfaces (CI-enforced)
  • Glassmorphism design system (centralized .glass utility)
  • Drag-and-drop file upload component
  • HEIC/HEIF mobile image support

Developer Experience

Claude Code skills, dev.sh CLI, architecture docs, automated workflows

35
  • 13 project-shipped Claude Code skills covering scaffolding, ship loop, deploy, ops, audits, evals, and i18n — listed below
  • `/ship` — full implement loop: code → tests → local CI → DoD + parallel review subagents (security, code, UX, docs) → fix every finding → PR with standardized status report
  • `/deploy` — one command: prod state diff → local CI → build + push + Helm upgrade for every changed surface → cluster health verify
  • `/translate` skill — parallel subagent per locale, enforces glossary + per-locale register, runs after EN key changes or as a periodic sweep (plus CI auto-translate fallback)
  • `/audit-marketing-website` — three-pass audit (strategic narrative → page-job fit → tactical voice/visual/technical) gating marketing copy and visual changes
  • `/eval` — agent eval harness runner (file-based corpus, side-effect-free, scored against a rubric for prompt iteration without regressions)
  • `/lighthouse` — perf + a11y + SEO + best-practices audits on the marketing site, also wired as a pre-deploy gate
  • `/ops-runbook` — production maintenance ops (deploy, changelog, KB embeddings, collectstatic) via kubectl-based runbooks
  • `/make-migrations` — Django migration creation + verification with tenant-scoped checks
  • `/add-primitive` — adds a shadcn/ui primitive (CLI run + import fix + barrel export + autogenerated story + verification)
  • `/generate-ui-component` — composed design-system component with CVA variants, JSDoc, colocated Storybook story, and barrel export
  • `/generate-page` — new SPA page with i18n keys, design-system imports, route registration, and E2E test scaffold
  • `/new-api-endpoint` — tenant-scoped Django Ninja CRUD endpoint with model, schemas, router, RBAC policy, and tests
  • `/commit` — quick CI checks + conventional commit on a feature branch
  • `/create-pr` — DoD verify, full CI, push, GitHub PR with summary + test plan, auto-labelled for the changelog
  • Claude Code hooks + subagents
  • Architecture docs + decision records
  • dev.sh CLI for everything (setup, serve, test, deploy, lint, ci)
  • Worktree-isolated development (parallel branches, isolated ports)
  • `dev.sh worktree-cleanup` — 8-step safety gauntlet (clean tree → branch merged → no containers → confirm → remove)
  • `_ensure_deps` preflight — auto-installs stale `.venv` / `node_modules` on fresh worktrees
  • `dev.sh website` / `help-center` / `status-page` / `sites` — one command per ancillary surface, worktree-isolated ports, single Ctrl+C shutdown
  • Automated changelog from PRs (LLM-rewritten)
  • Management commands (seed, reindex, preview email, etc.)
  • Definition of Done checklist (enforced in CI)
  • Superuser management portal (branded Django admin)
  • Email preview management command
  • Engineering principles documentation (Musk, Beck, McKinley)
  • PostgreSQL + pgvector in CI (real DB, not SQLite)
  • 2,300+ automated tests (backend + E2E + a11y + visual)
  • Agent eval harness for prompt iteration and regression testing
  • `check-e2e-antipatterns.js` — 7-check ESM lint banning known E2E flake patterns (`waitForTimeout`, bare toast selectors, fallthrough route mocks, networkidle, etc.)
  • mypy strict mode end-to-end + Pydantic runtime validation at LLM, Celery, and HTTP boundaries
  • axe-core a11y assertions in CI
  • k6 load testing suite (auth, CRUD, search flows)

GDPR & Compliance

Consent tracking, data export, account deletion, legal pages

14
  • Consent tracking (ConsentRecord + versioned legal terms)
  • Terms of Service + Privacy Policy pages
  • User data export (Art. 20 GDPR)
  • Account deletion with anonymization
  • Ownership guard (prevent orphaned tenants)
  • Admin audit logging (AuditedModelAdmin)
  • Admin tenant deletion with requester metadata
  • No PII in error tracking or logs
  • Session replays disabled
  • No tracking cookies (mandatory-only, no consent banner needed)
  • Tenant data portability export (customer-facing archive)
  • Tenant data erasure (Art. 17 right to be forgotten)
  • EU AI Act Article 50 transparency indicators
  • Who-did-what audit trail — EventLog with full tenant + user attribution (incl. AI agent runs), exportable, retention-policy controlled

Automated Processes

CI/CD, error triage, code reviews, translations, changelogs, documentation

17
  • CI on every push (lint, test, build, type-check, a11y)
  • Automated code, security, UX, and docs review on every PR
  • Definition of Done verification before merge
  • Automated root cause analysis from Sentry errors
  • GitHub issue creation from production errors
  • Automated changelog generation from merged PRs (LLM-rewritten release notes)
  • Automated i18n translations (6 languages, on new keys)
  • OpenAPI schema drift detection in CI
  • Visual regression testing (Chromatic on every PR)
  • API type generation (backend → frontend sync)
  • Knowledge base article generation from PRs
  • KB embedding sync (Markdown → vectors)
  • Stale OAuth token + client cleanup (daily)
  • Webhook delivery log pruning (daily)
  • Analytics event retention pruning (daily, configurable)
  • Trial expiry notifications (daily)
  • Orphaned media file cleanup

224 features across 13 categories. All included in every tier.

Frequently asked questions

What exactly do I get with the codebase?

The complete source code for the entire production system — backend (Django 5.2 + Ninja API), frontend (React 19 + TypeScript), infrastructure (Helm charts, OpenTofu, GitHub Actions), and all 200+ features. No black boxes, no proprietary dependencies. You own the code and can modify anything.

How is this different from a SaaS starter kit?

Most starter kits give you auth and a Stripe checkout, then leave you on your own. Epoch is a complete production system — multi-tenancy, AI agents, MCP server, observability, webhooks, notifications, help center, vector search, and real Kubernetes deployment. It's the gap between "starter" and "production" that usually takes months to bridge.

What does the deployment actually cost?

A single Hetzner CAX21 node (4 vCPU, 8GB ARM64) costs approximately €5/month. Add Cloudflare (free tier for CDN + DNS) and third-party services on free tiers (Sentry, Resend, R2 storage) and you have a production-grade stack for under €10/month. The architecture is designed to scale horizontally when you need it.

Can I use this for multiple products?

Yes. The license covers your use of the codebase. Fork it for each new product — one fork per product, each with its own deployment.

How do updates work?

The OS is a snapshot — you get the full codebase as it exists at purchase. The Launchpad subscription includes continuous updates: new features, security patches, dependency upgrades, and improvements to the AI agent framework and tooling. Cancel anytime and keep what you've received.

What does Fractional CPO/CTO include?

Ongoing product and technical leadership from Jesse (ex-bootstrapped PLG founder with exit, former scale-up CPO). This includes architecture reviews, roadmap planning, hiring guidance, technical due diligence, and direct async access. Available as a flexible monthly add-on — scale up or down as your needs change.

Is the code production-ready?

Yes. This isn't a prototype or proof of concept. It runs in production with 2,300+ automated tests, a fast and stable E2E suite, repeatable agent evals for prompt iteration and regression testing, visual regression testing, structured logging, error tracking (Sentry), OpenTelemetry observability, and provider-aware LLM caching on supported models. Every feature has been built to the standard documented in the Definition of Done.

Ready to ship?

You'll only hear from me when there's something worth reading or trying.

Or see it live — explore the product yourself.