Your rivals aren't rebuildingthe backend.They're shipping past you.
Auth, RBAC, multi-tenancy, audit, billing, files, realtime — the plumbing every serious product needs and no customer pays extra for. Nucleus turns all of it into a single configuration object. Months of backend engineering become 20 documented keys.
1{2 "appId": "storefront",3 "authentication": { "enabled": true },4 "authorization": {5 "enabled": true,6 "autoSeedClaims": true7 },8 "storage": { "enabled": true },9 "entities": [10 { "table_name": "products", "add_base_columns": true },11 { "table_name": "orders", "add_base_columns": true }12 ]13}This is the whole backend — auth, RBAC, storage & typed CRUD, generated.
- 20
- config keys replace months of backend work
- 1
- command scaffolds API, frontend, k8s & pipelines
- 100%
- type-safe from database to frontend
- 0
- lines of auth, RBAC or audit code to write
No magic · no lock-in
Built on the stack you'd have chosen anyway.
Nucleus is a thin, generated layer over boring, battle-tested tools. Your data is plain PostgreSQL. Your API is a plain Elysia app. You can read every table and drop down to raw code whenever you want.
- BunRuntime
- ElysiaHTTP framework
- Drizzle ORMType-safe SQL
- PostgreSQLYour database
- RedisSessions & cache
- TypeBoxRuntime validation
- OpenAPIAuto Swagger
- ReactFrontend kit
- KubernetesShip anywhere
What it actually costs to build it yourself
The most expensive code is the code you never needed to write.
Rebuilding the backend feels like progress. On the balance sheet, it is risk, burn and delay — three lines no one wants to defend in a review.
Undifferentiated burn
Every sprint spent on login, permissions and audit logs is payroll spent on plumbing no customer will ever pay you extra for. It is pure cost of doing business — and you are absorbing all of it.
0% of it is your product
Breach exposure
Hand-rolled authentication and authorization is where incidents begin. One missed token check or scope leak turns into a board-level disclosure, a regulatory letter and a number you will report for years.
one bug, one incident
Opportunity cost
While your team rebuilds the same backend for the third time this decade, your competitors ship the feature that wins the deal. Runway does not pause for plumbing.
months, not features
Forever maintenance
DIY infrastructure is never finished when it ships. It is a permanent line item — patched, on-called and worried about — long after the engineers who built it have moved on.
you own it forever
From config to running API in three steps
Declare it. Generate it. Mount it.
No scaffolding to wire by hand, no boilerplate copied between services. The same loop scales from a weekend prototype to a multi-tenant production system.
Declare your backend as config
One JSON object describes your entities, auth, permissions, storage and integrations. Secrets are env-var names, so the exact same file ships to every environment.
{ "appId": "storefront", "authentication": { "enabled": true }, "authorization": { "enabled": true, "autoSeedClaims": true }, "entities": [ { "table_name": "products", "add_base_columns": true, "columns": [ { "name": "title", "type": "text" }, { "name": "price", "type": "numeric" }, { "name": "published", "type": "boolean" } ] } ]}Generate the schema
One command turns the config into a Drizzle schema, merging your tables with the built-in system tables — users, sessions, roles, claims and audit_logs.
$ npx nucleus-core-ts generate src/config.json src/drizzle ✓ products ✓ users ✓ sessions ✓ roles ✓ claims ✓ audit_logs schema + relations writtenMount one plugin
Hand the schema to NucleusElysiaPlugin. Every enabled feature's routes, validation, claims and OpenAPI docs mount themselves — and you can add your own routes right alongside.
import { Elysia } from "elysia";import { NucleusElysiaPlugin } from "nucleus-core-ts";import * as schema from "./drizzle/schema";import * as relations from "./drizzle/relations"; new Elysia() .use(NucleusElysiaPlugin({ options: "./src/config.json", schema, relations, swagger: true, })) .listen(9000);Show, don't tell
One table declaration. A complete, secured API.
Add an entity and Nucleus generates CRUD routes, a full query language, runtime validation, RBAC claims, OpenAPI docs and a fully-typed client action — all at once, all consistent.
Add a table to your config — columns, base columns, bulk endpoints. That is the entire input.
{ "table_name": "posts", "add_base_columns": true, "bulk_endpoints_enabled": true, "columns": [ { "name": "title", "type": "text" }, { "name": "body", "type": "text" }, { "name": "published", "type": "boolean", "default": false } ]}What one config object already does
Everything below ships the day you start. Not the quarter you finish.
Each of these is a documented config key or a generated surface — production-grade, secured and typed. Open any one to see exactly how it works.
Authentication
JWT, multi-device sessions, magic links, passkeys, OAuth and captcha — the entire credential lifecycle, hardened.
Authorization
RBAC with auto-seeded claims and row-level scopes the instant you declare a table. No permission code to write.
Multi-tenancy
Schema-isolated tenants from day one — not a painful rewrite you postpone until your first enterprise contract.
Audit trail
Every change recorded automatically. Compliance evidence by default, not a frantic project before the audit.
Verification flows
Visual, multi-step approval workflows over any record — drawn once, enforced everywhere.
Payments
Stripe and iyzico wired straight to your entities. Start charging without building a billing service.
Storage & CDN
Uploads, MIME validation and a cache-friendly delivery path — files handled, not hand-rolled.
Query API
Filter, sort, paginate and expand relations over every table. Zero endpoints to write or maintain.
Typed client
Every route becomes a fully type-safe action in your frontend — payloads and responses inferred, end to end.
Frontend kit
Login, profile, RBAC console, data tables and form builders — themeable React components, already shipped.
One command
Scaffold the API, the frontend, Kubernetes manifests and CI pipelines in a single CLI run.
Build vs. buy · line by line
What you'd write yourself vs. what you declare.
Everything on the left is code you own, test, secure and maintain forever. Everything on the right is a configuration key.
- Authentication & sessionsDIY: Weeks of token, cookie & device logicNucleus: authentication: { enabled: true }
- Role-based access controlDIY: Custom middleware on every routeNucleus: Claims auto-seeded per table
- Multi-tenancyDIY: A painful rewrite you postponeNucleus: Schema-isolated from day one
- Audit loggingDIY: Bolt-on, easy to forgetNucleus: Every change recorded by default
- List & query endpointsDIY: Hand-rolled for every entityNucleus: 12-operator query language, free
- Input validationDIY: Manual schemas that driftNucleus: TypeBox generated from the table
- Typed API clientDIY: Hand-maintained, goes staleNucleus: Inferred end-to-end, always in sync
- Time to first endpointDIY: DaysNucleus: Minutes
- Who maintains itDIY: You, foreverNucleus: A versioned package
The AI era doesn't wait for your backend.
Idea-to-product collapsed from quarters to days. The teams pulling ahead treat infrastructure as a solved problem and spend every hour on what's actually different about their product.
If your engineers are still wiring sessions and permission scopes by hand, you're running the AI race on foot — and the gap to whoever isn't doesn't close. It compounds.
The cost of “we'll just build it ourselves” has never been higher, precisely because the alternative has never been this fast.
Before you ask
The questions every engineer asks first.
No. Your data lives in plain PostgreSQL tables you can read, back up and migrate like any other. Nucleus generates a standard Drizzle schema and a normal Elysia app — drop down to raw SQL or hand-written routes whenever you want.
Talk to the team
Ship your backend with Nucleus
Three quick steps. Tell us what you're building and we'll show you the fastest path from config to production.
Reply within 1 business day
A real engineer, not an autoresponder.
Your data stays private
We never sell or share your information. NDA on request.
Talk to the maintainers
Straight to the people who build Nucleus.
- 1Your goal
- 2About you
- 3Your message
Stop rebuilding the backend. Start shipping the product.
Every day spent reinventing infrastructure is a day a faster team spends on what makes them different. Read the reference and see exactly what one config object already does for you.