Skip to content

About

Butwhy?

The long version of what kept breaking, what finally clicked, and why this stack ships the way it does - open source, edge-first, and type-safe.

  1. 2014Base on CodeIgniterBase on CodeIgniter2014Rudimentary: a handful of generic helpers, shared between pet projects so the next one never started from zero.PHP · CodeIgniter
  2. 2016Base on LaravelBase on Laravel2016Structured this time: real conventions and a proper layout, reused across several projects instead of copied between them.PHP · Laravel
  3. 2018OneBase on ReactOneBase on React2018Object-oriented and far better organised. Less a toolbox, more a framework: the first base that set the shape of the apps built on it.TypeScript · React · React Native
  4. 2023Ottabase on Next.jsOttabase on Next.js2023The heaviest push yet, and most of it went into wrestling the vendor: working around framework quirks instead of building the product.Next.js · TypeScript · App Router
  5. 2025Ottabase.Ottabase.2025The best one yet. An industry-standard, batteries-included framework: auth, data, tenancy, queues, realtime and UI, wired together and yours as source.TypeScript · Turborepo · Cloudflare Workers

Origin

Every new idea started withthe same old work.

I make apps. Weekend projects, internal tools, things I want to exist that do not yet. AI boosted the pace in 2022. Claude changed the game entirely in 2024. Paradigm shifted in 2025. Every time I started one, the first week went the same way. Not building the thing, but rebuilding the scaffolding. Auth again. Deployment setup again. Queues, multi-tenancy, environment config. All of it, again.

Starter templates existed. Design Themes existed. But none of it was truly end-to-end. You would clone something and within a day you had already diverged from it. The gap between having code and having something actually running in production mostly costed multiple weeks.

So I built the base I always needed. Not a template you fork and drift from. A proper foundation - opinionated on purpose, because every open decision is a decision you will re-make on every project. Cloudflare Workers for the runtime. Turborepo for the monorepo. Auth, ORM, RBAC, queues, multi-tenancy - solved once, as packages you reach for, and connected with Infrastructure to deploy!

Now, your next homepage, an API server, a full SaaS, a weekend project - they all start from the same base. The same deployment model, same infra patterns, and same conventions.

You figure it out correctly one time and every project after that just inherits the answer. That is what this is.

It is opinionated because that is the point. The opinions are not in the way. The opinions are the whole value.

~3 yrsof building it, scrapping it, building it right
60+packages, MIT licensed
1Week: your MVP ships, not your first config file
∞apps you can now ship without the scaffolding tax

This problem is not unique. Every developer building real things has paid some version of this tax. The base that was always missing is here now. Open sourced under MIT.

How did we get here

  1. Now

    You are here.

    Ship production SaaS in hours, not weeks. The scaffolding is invisible, your agent already knows the codebase, and the only thing left is your product.

  2. 2026Oct

    The site edits itself.

    Landing sites move into D1 with ottalanding: typed sections, three themes, drafts, lead forms - edited from the admin and rendered at the edge. Then kernel turns every package into one manifest, otta add installs it, nine more packages land, and Ottabase Pro ships seven paid ones on top.

  3. 2026Sep

    Agent-ready.

    Fourteen repo-specific skills, AGENTS.MD, and a generated llms.txt teach coding agents the Ottabase way. The blog goes multilingual and the otta CLI takes over the app lifecycle.

  4. 2026Jul

    Fail closed.

    A multi-tenant security pass rewrites the rules: authorization becomes permission + scope, never a role name. Generic CRUD turns into an allowlist, platform_owner splits from the org owner, and auth drops Auth.js for Web Crypto.

  5. 2026Apr

    v1.0.0 - public.

    All 45+ packages bumped to 1.0.0. Changelog published. The entire monorepo released under MIT - no paywalled tiers, no SaaS wrapper, just code you own.

  6. 2026Feb

    The hard infrastructure.

    Row-level security, wildcard RBAC, audit logging, and full multi-tenant isolation shipped as a single major commit. The brand engine and design token system followed within days.

  7. 2026Jan

    The ecosystem expands.

    Shortlinks, referral tracking, a Laravel-style job queue backed by Cloudflare Queues, and the OttaBlog CMS engine - four production-grade packages in one month.

  8. 2025Dec

    OttaORM and the first template.

    Fat models with auto-migrations from schema definitions. CRUD API auto-generated. Paired with the TanStack Router + Vite + Workers template - the core philosophy in working code.

  9. 2025Nov

    Cloudflare goes first-class.

    The cf package wraps every binding - D1, KV, R2, Queues, Rate Limiting - in one type-safe surface. Real-time WebSocket pub/sub via Durable Objects lands the same month.

  10. 2025Sep

    The monorepo begins.

    First commit. Config, state, and a UI package. The DB and auth layers follow within the week. The shape of a framework, not an app.

  11. 2025Aug

    The discard.

    Twenty-one months in. The App Router fought every abstraction. Code that should have been packages was entangled in the codebase. The architecture was sound but the delivery mechanism was wrong. Restarted from scratch, this time with Turborepo.

  12. 2023Nov

    Version one.

    First attempt at the vision. Auth, ORM, RBAC, queues - all of it, but living inside a Next.js app in a (coreModules) folder. It was highly restrictive and a considerable time was spent adjusting to the nuances than building the product.

Before Ottabase

The fifth base.The first one in the open.

Ottabase is not a first attempt. I have built a base for my own projects four times before, each on the stack of its day, and each one taught the next what to keep. Over a decade of that experience now converges into Ottabase.

  1. Base 1retired
    2014

    Base on CodeIgniter

    PHP · CodeIgniter

    The first time the groundwork under one project got lifted out and kept for the next one.

    Base on CodeIgniter2014Rudimentary: a handful of generic helpers, shared between pet projects so the next one never started from zero.PHP · CodeIgniter
  2. Base 2retired
    2016

    Base on Laravel

    PHP · Laravel

    Rebuilt on Laravel: the same groundwork, with a stronger framework under it.

    Base on Laravel2016Structured this time: real conventions and a proper layout, reused across several projects instead of copied between them.PHP · Laravel
  3. Base 3retired
    2018

    OneBase on React

    TypeScript · React · React Native

    One base under the web and the mobile apps, so both shipped from the same foundation.

    OneBase on React2018Object-oriented and far better organised. Less a toolbox, more a framework: the first base that set the shape of the apps built on it.TypeScript · React · React Native
  4. Base 4rewritten
    2023

    Ottabase on Next.js

    Next.js · TypeScript · App Router

    The first Ottabase: nine months of work inside a Next.js app, until the router fought every abstraction.

    Ottabase on Next.js2023The heaviest push yet, and most of it went into wrestling the vendor: working around framework quirks instead of building the product.Next.js · TypeScript · App Router
  5. Base 5now
    2025

    Ottabase.

    TypeScript · Turborepo · Cloudflare Workers

    Started again from an empty folder: packages instead of folders, Cloudflare first, MIT licensed.

    Ottabase.2025The best one yet. An industry-standard, batteries-included framework: auth, data, tenancy, queues, realtime and UI, wired together and yours as source.TypeScript · Turborepo · Cloudflare Workers

Read the thinking behind the framework.

PhilosophyGitHub