TOME — THE PLATFORM UNDER EVERY WABBIT BUILD
It’s how we work. Lately, it’s also what we sell.
Tome is the application platform every Wabbit build runs on — dozens of packages and 190,000+ lines of TypeScript, kept in production, under everything we ship. It’s the reason a platform can launch in months instead of years, for a fraction of what building from scratch costs, and keep itself running long after we’ve handed you the keys.
We didn’t build it to sell. We built it because the alternative was watching every client project turn into a fight with the architecture.
For years, we built on other people’s parts.
WordPress, mostly — and we still reach for it when it fits. But our clients kept needing things the parts couldn’t do, and we kept walking into the same three walls.
needed permissions that followed the org chart: a unit leader who could see her own teams and no one else’s, access that flexed as people moved. WordPress offered four flat roles. Binary. Inflexible.
Wall.needed to move atomically — out of one account, into another, every change on the ledger, no half-finished states ever left behind. WordPress offered custom post types and crossed fingers.
Wall.needed courses tied to certifications tied to prerequisites, with progression rules that enforced themselves. WordPress offered a shelf of plugins, each solving ninety percent of the problem and fighting the other two for the last ten.
Wall.We finally named the thing we’d been avoiding: we weren’t fighting our clients. We were fighting our architecture.
One collapse settled it. We’d built a client’s community on the industry-standard stack — the exact plugins the vendors themselves recommend, the setup thousands of sites run on. Launch day brought real load: a quarter-million visitors, twenty thousand of them members trying to log in at once, on a third-party enterprise-grade cluster tuned and paid for to carry exactly that.
It went down in an instant.
You inherit every failure point in software you don’t control.
Our client, our build, our responsibility — and the vendors whose parts had buckled under the very load their stack was sold for wouldn’t touch it. That’s the law we build by now. So we stopped assembling other people’s parts and built our own foundation. We called it Tome, and it’s been under everything we’ve shipped since.
Every package speaks one language.
Tome is composed, not monolithic. Each package owns a single domain — identity, content, training, ledger, governance, operations, realtime, editorial — and every one of them has been hardened against real production demand at organizational scale. Not in theory. In production, today: a hundred-plus collections, 190,000+ lines of strict TypeScript, and whole business engines — Commerce, CRM & Marketing, Learning — released on top of the plumbing.
What holds it together is that they all speak the same language. One identity model. One permission system. One audit trail that every package writes to. Add a new capability and it inherits all three for free, instead of bolting a fourth opinion onto the pile.
Take identity, the foundation the rest stands on. Member identity kept distinct from user accounts. Role-based access with attribute-based extensions, so permissions bend to the org chart instead of the other way around. Sessions, multi-factor, passkeys, and revocation that takes effect the instant someone’s standing changes — with a full record of every access decision behind it. Four packages, one seam.
That’s the pattern everywhere in Tome. Shared foundation, coherent seams — and still, every project we build on it is custom. Tome is a foundation, not a template.
The proof is what it already runs.
Not a demo. Not unshipped code waiting for its first real user. Right now, at organizational scale, Tome runs three things that share nothing with each other except the substrate underneath — and the range between them is the whole point.
A 700-member organization, run on one platform.
A Star Citizen milsim, eight years in the making, that used to live in a dozen disconnected tools. It runs on Tome now: the full order of battle — wings, units, squadrons, billets — with hierarchical command and delegated authority; a training academy with prerequisites and certifications; a double-entry financial ledger; multi-signature governance; a Discord sidecar.
70,000+ lines of TypeScript · 85+ collections · 48 RBAC policiesStatic one-pager to full platform, all on one substrate.
Every Wabbit Static and Platform build. wabbit.com, the site you’re reading right now. The Living Library, with its essays and series and methodology. The same foundation that carries Vanguard’s financial ledger carries a brochure site — and neither one knows the other exists.
A flight trainer for the genre’s hardest-to-please pilots.
WebHID input read straight off HOSAS rigs, three.js scenarios with frame-accurate input traces, stress-tested by exactly the people most likely to break it. Same substrate as the ledger.
A double-entry ledger, a marketing site, and a six-degree-of-freedom flight sim, all standing on the same floor. A platform that holds up across a range that wide is the platform your business would run on.
When we build for you on Tome, four things change.
The hardest, most dangerous parts of a platform — identity, permissions, the ledger, training — are already built and already battle-tested. A build from zero spends eighteen months laying that plumbing before it does anything unique. A build on Tome inherits it and spends its four-to-six months on the part that’s actually yours: the thing your operation does that nobody else’s does.
Type-safe from the database to the interface. The errors that would otherwise surface in production, in front of real users, get caught in the type checker before anything deploys. What you get is real performance and real security instead of a maintenance story that quietly falls apart.
You own the platform and the source code outright, from launch. No renting access to your own data, no lock-in. If you ever decide to part ways, we help you take the whole thing with you — the contract makes that answer easy, and we wrote the promise down where you can hold us to it. The Eject Pledge →
Unmaintained software rots, and you meet the bill when it breaks — the $800 emergency on someone else’s schedule. The connected-project retainer replaces that with security patches, platform updates, and evolution as your business changes. Yours stays current and improving between crises instead of decaying toward the next one.
Tome is unnecessary for a simple website or a basic online store.
WordPress and a good designer handle those beautifully, and we’ll say so on the call — cheerfully, before you’ve spent a dollar with us. But when your organization needs software that matches how it actually operates, when off-the-shelf has stopped being able to hold it, that’s the room Tome was built for.
Is Tome a product we sell? These days — yes, most of it.
For years the honest answer was no: Tome was how we deliver, and the only way to benefit was to hire us. The marketplace changed that. Today you can run Tome without ever hiring us to build — the starter gets you a working site, the capacity plans put the platform under it, the business engines — Commerce, CRM & Marketing, Learning — bolt on as your operation needs them, and the block library is open, some of it free.
For now every paid door opens with a note rather than a checkout — we set each one up by hand, same day. Self-serve is coming for the smaller tiers; Agency and Commerce will stay a conversation by design, because they carry real obligations and we’d rather set them up right than hand you a button.
What still comes only one way is us: the bespoke build, where we model your operation and shape the platform to it. And everything past that — hosting Tome as multi-tenant software, running your deployment for you — stays deliberately undecided. Those turns would make us a software company on top of an agency, and we won’t take them until we’re sure they’re right.
We’d rather sell you the workshop than pretend it’s a museum.
Take the platform for your own build.
The blocks, plans, engines, and packs Tome ships with — the same shelf every Wabbit build pulls from.
- 01BlocksBlocksThe composed band library.
- 02PlansPlansHosted and self-run tiers.
- 03EnginesEnginesCommerce, community, training.
- 04PacksPacksDomain packages, versioned.
Production-grade, observable, ours.
For the engineer in the room, the honest version. The whole library, 190,000+ lines of strict TypeScript end to end, published to a private registry we run ourselves.
React with GSAP motion and Yjs collaborative editing; App Router and server components, client components where they earn it.
TanStack Query and Zustand; server state with real cache invalidation, UI state kept separate.
Better Auth plus payload-auth, server-side sessions, passkeys, 2FA, OAuth. Revocation is instant; rate limiting fails closed.
PayloadCMS 3 and the published @wabbit/tome-* packages. The substrate: identity, content, training, ledger, ops, realtime, all on one identity model and one audit trail.
Next.js, Node, TypeScript in strict mode with null checks throughout. Type-safe from database to UI.
MongoDB, Redis, BullMQ, and a CDN with media isolated per member.
Tuned for Coolify on dedicated bare-metal hardware. Real machines, containerized, predictable cost — not a serverless bill that surprises you.
Compliance isn’t bolted on: data-subject rights are modelled into the schema, security enforcement lives at the database read layer rather than the interface, and every access decision leaves a trail.
Two ways in
Want to build on it? Two ways in.
You don’t have to hire us to get Tome. You can, and most platforms we ship start that way. But the shelf is open now, and the same foundation is under both.
Have it built
We model your operation and shape the platform to it.
The Architecture Sprint, the scoped build, the retainer that keeps it current. You trade your operational details for a real plan — cost, phases, risks — instead of a guess. If you’ve outgrown your tools and you’re ready to scope what comes after, this is the one.
See the offer →Build it yourself
Fork the starter and have a working site running the same day.
Put the platform under it when you outgrow the starter, add an engine when a project calls for one. The block library is open — real source, live previews, some of it free.
See plans and engines →
Either way it’s the same foundation, and everything on the shelf is what we run ourselves. Want to see it carrying a real organization first? The Vanguard case file → /studies/vanguard