Persona 01 / 06

Developer

Ship code, not ceremony.

You write business logic. The framework handles auth, RBAC, caching, audit logs, multi-tenancy, and the admin UI. Scaffold an entity, generate CRUD, ship a feature — all before lunch. The boring infrastructure is already done; your job is the interesting part.

Read the docs Get in touch

customer.entity.ts — Primebrick SDK

import { Entity, Field, Auditable, Cached, RBAC } from '@primebrick/sdk';

@Entity({ name: 'customers' })
@Auditable()
@Cached({ ttl: 300 })
export class Customer {
  @Field({ type: 'uuid', primary: true })
  id: string;

  @Field({ type: 'string' })
  @RBAC({ read: ['admin', 'sales'], write: ['admin'] })
  name: string;

  @Field({ type: 'email', unique: true })
  email: string;
}

// One command generates CRUD, API routes, admin UI, tests, migrations:
// $ pnpm primebrick generate-crud Customer

What changes for you

Scaffold in minutes, not sprints

Define an entity with decorators. Run one command. Get CRUD, API routes, admin UI, tests and migrations — all generated, all type-safe, all passing CI. No boilerplate, no copy-paste from the last project, no "I'll fix the tests later."

Auth, RBAC and audit are built in

OIDC, passkeys, MFA, role-based access control, and tamper-evident audit logs ship with the framework. Annotate a field with @RBAC and access is enforced everywhere — API, UI, exports. No hand-rolled auth middleware, no "did we remember to check permissions?"

Type-safe end to end

Entities, API routes, DTOs, and the admin UI are all generated from the same schema. Change a field type and the compiler tells you everywhere that breaks — before your users do. No runtime surprises, no "it worked in dev but prod has different data."

Open source, inspectable, forkable

MIT-licensed. Read the source, understand the magic, fix it if you need to. No black-box framework, no "trust us, it works." If a decorator doesn't do what you expect, you can read the code that implements it — and change it.

AI-assisted development

Describe a feature in natural language. The agentic GUI writes the entity, the service, the route, the tests — all following your project's conventions. You approve the plan, the agent writes the code, CI runs, you ship. It's pair programming with an AI that actually knows your codebase.

No per-seat license, no vendor lock-in

MIT license. Use it, fork it, modify it, ship a commercial product with it. No per-seat fees, no per-request fees, no "contact sales for enterprise pricing." Your build is your build.

Deploy anywhere

Docker, Kubernetes, AWS (ECS/EKS), Azure Container Apps, GCP Cloud Run, Alibaba Cloud ACK, or a single VPS. The same codebase runs everywhere. No vendor-specific adapters, no lock-in. Move when you want, stay where you want.

Onboarding in hours, not weeks

Conventions are enforced by the framework, not by a 50-page wiki. A new developer reads the entity, sees the decorators, and understands the access rules, the audit trail, and the caching strategy — all in one file. No archaeology, no "ask Bob, he wrote that in 2019."

A day in the life

09:00

Scaffold

Define a Customer entity with decorators. Run generate-crud. 14 files created.

10:30

Customize

Add a custom validation rule and a computed field. Type-safe, compiler-checked.

11:00

Test

12 scaffolded tests pass. Add 3 edge-case tests for the validation rule. All green.

11:30

Ship

Push to CI. Compliance scanner runs. PR merged before lunch.

Before vs. with Primebrick

Before (DIY)

With Primebrick

Write auth middleware, RBAC checks, audit logger

Annotate with @RBAC, @Auditable — done

Build CRUD UI by hand for every entity

Generated from schema, type-safe, consistent

Write migrations, seed data, test fixtures

Generated, versioned, reproducible

Hope the cache invalidation is correct

@Cached decorator, framework-managed invalidation

Capabilities you'll use

@Entity decoratorsgenerate-crud CLI@RBAC@Auditable@CachedType-safe SDKOpenAPI auto-genAgentic GUIPasskeys / MFADocker / K8sMIT LicenseOpenTelemetry

I stopped writing boilerplate and started writing features. The first time I ran generate-crud and got 14 passing files, I thought it was a mistake. It wasn't.

— Senior developer, SaaS startup

Developer FAQ

Is the generated code readable and editable?

Yes. The generated code follows the same conventions as hand-written code in the project. You can read it, modify it, and delete what you don't need. The generator is a starting point, not a black box. If you regenerate after changing the schema, the tool respects your customizations in protected regions.

Can I use my own auth provider?

Yes. The built-in auth uses OIDC and supports passkeys/MFA. If you have an existing Identity Provider (Keycloak, Auth0, Azure AD), you can configure it as the OIDC issuer. The @RBAC decorator works regardless of where the roles come from.

What databases are supported?

PostgreSQL is the primary target, with pgvector support for AI features. The DAL layer is abstracted, so other databases can be supported — but Postgres gives you the full feature set including JSONB, full-text search, and vector embeddings.

How does the agentic GUI know my project's conventions?

The agent reads your existing entities, services, and routes to learn the patterns. It also reads the framework's convention rules. When it generates code, it follows the same decorator patterns, file structure, and naming conventions as the rest of your project. You approve the plan before it writes anything.

Can I contribute to the framework?

Yes — it's MIT-licensed open source. PRs are welcome. The repo has contributing guidelines, ADRs for architectural decisions, and public issue tracking. You can also fork it and maintain your own version if you prefer.

Previous persona

SOC Team

Evidence, not promises.

Next persona

Tech Leader

Conventions, not meetings.

Ready to ship code, not ceremony?

Read the docs or get in touch — we'll show you how to scaffold your first entity in minutes.

Read the docs Get in touch