Build vs. buy · the backend decision

Your rivals aren't rebuildingthe backend.They're shipping past you.

Auth, RBAC, multi-tenancy, audit, billing, files, realtime, messaging and notifications — 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 a set of documented keys.

See everything it replacesHow it plugs in
config.nucleus.json
1{2  "appId": "storefront",3  "database": { "url": "DATABASE_URL" },4  "redis": { "url": "REDIS_URL" },5  "authentication": { "enabled": true, "mode": "full" },6  "authorization": {7    "enabled": true,8    "autoSeedClaims": true9  },10  "storage": { "enabled": true },11  "entities": [12    { "table_name": "products", "add_base_columns": true },13    { "table_name": "orders", "add_base_columns": true }14  ]15}

This is the whole backend — auth, RBAC, storage & typed CRUD, generated.

config keys replace months of backend work
25
command scaffolds API, frontend, k8s & pipelines
1
type-safe from database to frontend
100%
lines of auth, RBAC or audit code to write
0

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
  • DaprOptional sidecar
  • ReactFrontend kit
  • KubernetesShip anywhere

Trusted in production

Teams shipping on Nucleus.

  • KARSAN
  • TATMETAL
  • TOFAŞ
  • BILTIM
  • FARPLAS
  • HUMANIS
  • VORION

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. One command runs all three — bunx nucleus-core-ts init --preset saas --app-id shop -o ./shop writes the config, generates the schema and mounts the plugin. The steps below are what it produces, and what you wire yourself when Nucleus goes into a service you already have. The same loop scales from a weekend prototype to a multi-tenant production system.

Step 01

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.

config.nucleus.json
{  "appId": "storefront",  "database": { "url": "DATABASE_URL" },  "redis": { "host": "REDIS_HOST", "port": "REDIS_PORT" },  "authentication": { "enabled": true, "mode": "full" },  "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" }      ]    }  ]}
Step 02

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.

terminal
$ bunx nucleus-core-ts generate src/config.json src/drizzle   ✓ products     ✓ users      ✓ sessions  ✓ roles        ✓ claims     ✓ audit_logs  schema + relations written
Step 03

Mount 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.

src/index.ts
import { Elysia } from "elysia";import { NucleusElysiaPlugin } from "nucleus-core-ts"; new Elysia()  .use(await NucleusElysiaPlugin({    options: "./src/config.json",    schema: "./src/drizzle/schema.ts",    relations: "./src/drizzle/relations.ts",    swagger: { path: "/docs" },  }))  .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.

config.nucleus.json
{  "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.

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 & sessions
    Do it yourself: Weeks of token, cookie & device logic
    With Nucleus: authentication: { enabled: true }
  • Role-based access control
    Do it yourself: Custom middleware on every route
    With Nucleus: Claims auto-seeded per table
  • Multi-tenancy
    Do it yourself: A painful rewrite you postpone
    With Nucleus: Schema-isolated from day one
  • Audit logging
    Do it yourself: Bolt-on, easy to forget
    With Nucleus: Every change recorded by default
  • List & query endpoints
    Do it yourself: Hand-rolled for every entity
    With Nucleus: 15-operator query language, free
  • Input validation
    Do it yourself: Manual schemas that drift
    With Nucleus: TypeBox generated from the table
  • Typed API client
    Do it yourself: Hand-maintained, goes stale
    With Nucleus: Inferred end-to-end, always in sync
  • Logging & tracing
    Do it yourself: console.log archaeology
    With Nucleus: Scoped logs + request ids, built in
  • Realtime & chat
    Do it yourself: A WebSocket server, presence & ACK/retry
    With Nucleus: pubsub + chat config keys
  • Notifications
    Do it yourself: Per-channel senders you wire and retry
    With Nucleus: Portal, email, Telegram, webhook — one call
  • File uploads & media
    Do it yourself: Upload handling, MIME checks, image/video jobs
    With Nucleus: Storage + transform config, CDN included
  • Rate limiting & abuse
    Do it yourself: Custom counters and lockout logic
    With Nucleus: Strategy + per-route limits, declared
  • Time to first endpoint
    Do it yourself: Days
    With Nucleus: Minutes
  • Who maintains it
    Do it yourself: You, forever
    With Nucleus: A versioned package
The clock you can't see

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.

  1. Step 1 of 3: Your goal
  2. Step 2 of 3: About you
  3. Step 3 of 3: Your message
Step 1 of 3: Your goal
What brings you to Nucleus?

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. Tell us what you're building and we'll show you exactly what one config object already replaces.

Talk to the team