Tech Leader
Conventions, not meetings.
You own standards, onboarding, and code quality. Primebrick enforces conventions in the framework — decorators for auth, RBAC, caching and audit are the standard. New developers read one entity file and understand the whole pattern. No 50-page wiki, no "ask Bob how this works."
What changes for you
Standards enforced by the framework
Auth, RBAC, caching, audit, multi-tenancy — all handled by decorators. The framework won't let you forget a permission check or skip an audit log. Standards are code, not comments. You don't review for "did you add @RBAC?" — the compiler does that.
Onboarding in hours, not weeks
A new developer reads one entity file and understands auth, RBAC, caching, audit, and the API contract — all in one place. The conventions page documents the rest. First PR on day one, not week two. You spend onboarding time on business domain knowledge, not on "how our framework works."
Consistent code across the team
Generated CRUD, consistent file structure, type-safe entities. Every developer produces code that looks the same. Code reviews focus on business logic, not on "why did you structure this differently?" The framework is the style guide.
Open source means the team can fix things
MIT-licensed, public code, public ADRs. When something doesn't work, your team reads the source and fixes it — or files a PR. No support ticket SLAs, no "we'll add that to the roadmap." Your team has the same access as the maintainers.
AI-assisted development follows your conventions
The agentic GUI reads your existing code and generates new entities, services, and routes that follow the same patterns. No "the AI wrote it differently than we do." The agent's output is consistent with the team's style because it learned from the team's code.
Compliance without the overhead
ISO 27001, NIS2, OWASP reports are generated from scan data on every build. You don't maintain spreadsheets, you don't schedule consultant rounds. The compliance posture is a build artifact, not a project. Your team focuses on features, not on audit prep.
Scale the team without scaling the meetings
Conventions are in the code. Onboarding is self-service via the docs and the entity files. New team members are productive without a week of pair-programming. You scale from 5 to 15 developers without adding a layer of coordination meetings.
No per-seat license to budget for
MIT license. Add developers without adding license costs. Your budget goes to salaries and infrastructure, not to per-seat SaaS subscriptions. The framework cost stays at zero whether you have 3 developers or 30.
Onboarding a new developer
Read the conventions
Read the conventions page. Understand decorators, file structure, naming.
Scaffold an entity
Define a test entity, run generate-crud, explore the generated files.
Open a PR
Add a field to an existing entity, update tests, push, CI passes, PR opened.
Ship a feature
Build a full feature end-to-end: entity, service, route, UI, tests, deploy.
Standards matrix
Migrating from legacy
Coexist
Run Primebrick alongside the legacy stack. New features in Primebrick, old features untouched.
Migrate entities
Move entities one by one. The agentic GUI can scaffold from existing database schemas.
Decommission
Once all entities are migrated, decommission the legacy stack. No big-bang rewrite.
Optimize
Now on Primebrick, leverage caching, multi-tenancy, and compliance scanning.
Capabilities you'll use
Code reviews got shorter. We stopped reviewing boilerplate and started reviewing business logic. The new hire opened a PR on day one — I didn't believe it until I saw the CI pass.
Tech Leader FAQ
How do we enforce team-specific conventions on top of the framework?
The framework's decorators are the baseline. You can add ESLint rules, custom decorators, and CI checks for team-specific patterns. The agentic GUI also respects your custom conventions when generating code. Your team's standards layer on top of the framework's standards.
Can we migrate incrementally from an existing codebase?
Yes. The migration path is designed for coexistence: run Primebrick alongside your legacy stack, move entities one at a time, and decommission the old code when ready. No big-bang rewrite, no freeze on new features during migration.
How does the agentic GUI handle team conventions?
The agent reads your existing codebase to learn patterns before generating new code. It follows your decorator usage, file structure, and naming conventions. You approve every plan before code is written, so you can reject anything that doesn't match your standards.
What's the learning curve for developers new to the framework?
Developers familiar with TypeScript and decorators pick it up in hours. The conventions page and the entity files are the documentation — read one entity and you understand the pattern. No week-long training, no certification program. The framework is designed to be readable, not magical.
How do we handle framework upgrades?
The SDK is published to npm with semantic versioning. Breaking changes come with migration guides and codemods where possible. Since the framework is open source, you can also pin a version and upgrade on your own schedule. ADRs document every architectural decision and its rationale.
Developer
Ship code, not ceremony.
Solution Architect
Architecture that survives.
Ready to enforce standards without meetings?
Read the docs or get in touch — we'll show you how to onboard a developer in hours.