Frontend dashboard built on Next.js 16 App Router, React and Shadcn UI
uiframe — Next.js Admin dashboard Template
By theblueprintcode
uiframe, the frontend dashboard of The Blueprint Engine, is built on Next.js App Router, React and Shadcn UI, and connects to the NestJS backend engine through environment variables.
Explore the design
Compare the page layouts and mobile experience. Open any screenshot for a closer look.
Actual screenshot captured by the server browser.
All pages & views 3
Screenshots show visual appearance; interactive behavior may differ.
What stands out
A quick read of the recorded project description.
Connects to the NestJS backend engine through NEXT_PUBLIC_API_BASE_URL, with the default backend address at http://localhost:5201
Built-in multi-tenant architecture: login requires an accountId, and the JWT carries the tenant scope that is automatically applied to subsequent API calls
Provides a dynamic form generator that generates Zod schemas and react-hook-form components from JSON metadata
The development server runs on port 5200 by default to avoid conflicting with the backend port 5201
Template Details
uiframe is the frontend part of The Blueprint Engine, and the README positions it as a dashboard interface that connects to the NestJS backend engine. The tech stack is Next.js 16 (App Router), React and Shadcn UI; Bun is recommended for dependency installation, and Node.js v20+ is also supported.
Before use, the backend engine needs to be running at http://localhost:5201, and NEXT_PUBLIC_API_BASE_URL must be configured in .env.local to point to the backend API. The development server runs on port 5200 by default to avoid conflicting with the backend.
Multi-tenant support is built into the frontend: login requires an accountId (platform administrators use __root__), the JWT token carries the tenant scope, subsequent API calls automatically inherit that scope, and the interface conditionally renders tenant-level or platform-level operations based on the user's role and account scope.
The project also provides a dynamic form generator that can generate Zod validation schemas and react-hook-form components from JSON metadata, outputting to src/components/forms/. The README does not provide instructions for production builds, deployment processes or testing.
Is it right for your project?
Use Cases
- Building a matching frontend admin dashboard for The Blueprint Engine's NestJS backend
- Running frontend and backend locally at the same time to develop user, role, authentication and settings pages in multi-tenant scenarios
- Quickly generating form components with Zod validation from JSON schema
Suitable For
- Developers using The Blueprint Engine backend who need a corresponding frontend interface
- Admin panel projects that require multi-tenant login and tenant-scope isolation
- Frontend developers using Bun or Node.js v20+ and familiar with Next.js App Router
Getting started & customization
Use these recorded setup notes alongside the repository instructions for your chosen version.
- 1
Install dependencies: run bun install in the uiframe directory
- 2
Create .env.local and set NEXT_PUBLIC_API_BASE_URL=http://localhost:5201/api/v1
- 3
Ensure the backend engine is already running at http://localhost:5201, otherwise API calls will fail
- 4
Run bun run dev to start the development server, default port 5200
- 5
Generate forms: after preparing schema.json, run bun run generate:form --schema=schema.json
License & source material
Usage conditions & limitations
Free to use · keep license noticeThis listing covers the free version in the public repository under the MIT license; the free scope is the code of that version and does not mean external services or third-party assets are free.
Must comply with when using
- Free use, modification, commercial use and distribution of that version's code are permitted.
- When distributing copies or substantial portions of the code, retain the original author's copyright notice and the full MIT license notice.
- The code is provided as is; warranties and limitations of liability are governed by the original license and applicable law.
Additional costs & items to verify
- Demo images, fonts, icons and other third-party assets need to be checked against their respective licenses and cannot be judged solely by the code's MIT license.
- External services such as domains, hosting, databases, payments or AI may incur separate charges.
- Before use, the engine backend must be running at http://localhost:5201, otherwise API calls will fail.
- You need to create .env.local in the uiframe root directory and configure the backend address, otherwise the frontend cannot connect to the backend.
- NEXT_PUBLIC_API_BASE_URL must be set to point to the NestJS backend API address.
- Login must provide an accountId, and platform administrators need to use __root__.
View Original Text Basis
Permission is hereby granted, free of charge
Original License Text
- The `engine` backend should be running on `http://localhost:5201` for the API calls to succeed.
Original README
Create a `.env.local` file in the root of the `uiframe` directory. The primary configuration needed is pointing the dashboard to the backend engine.
Original README
NEXT_PUBLIC_API_BASE_URL=http://localhost:5201/api/v1
Original README
https://github.com/theblueprintcode/uiframe/blob/main/LICENSEhttps://github.com/theblueprintcode/uiframe/blob/main/README.md- **Login Flow**: When users log in, they must provide an `accountId` (or `__root__` for platform admins).
Original README
Compiled by DeepSeek based on repository license and README ·2026-10-14. Results only cover the materials read; dependencies, images, fonts, and subsequent term changes are subject to their respective original texts.
Project checks & description sources
Template Information
- Source platforms
- GitHub
- Documentation and maintenance reference score
- More documented · 88 / 100
- Technologies
- Next.js · React
- Website type
- Admin dashboard · Tool Site
How this score is calculated
Our heuristic uses license records (up to 30), a demo link (12), a preview (10), stars (15), recorded maintenance (15), description completeness (8), feature records (5) and classification data (5). It is not a code, security or performance test, or a Google score. A link does not establish tested functionality.
What to verify for this project
- Repository update recorded
- 2026-09-04
- Screenshot last checked
- 2026-10-14
A demo link is listed. Check it with your own content and viewport sizes; its presence does not confirm that forms, authentication or payments work.
The catalog identifies Next.js as the primary stack. Check the actual dependency manifest and lockfile for versions and hosting requirements. These notes use recorded metadata, not a code audit or a deployment test.
Use a selection guide →How this description was prepared
AI-assisted description based on catalog records and repository material. Repository authors are not automatically the reviewers of this description.
Review declaration: codex-user-requested-batch-review-20261015 · 2026-10-15
Inspect the recorded source material
SHA-256: c99b48eb19f8affa233174e0566c6b288ec366871c6af85bc018e4ed09054f0d
2026-10-14T23:05:49.028Z
Source file / repository
# The Blueprint Engine - UI Frame (Frontend)
Welcome to the **uiframe** of The Blueprint Engine! This frontend is built using Next.js 16 (App Router), React, and Shadcn UI. It is designed to connect seamlessly to the NestJS engine backend.
This README focuses strictly on setting up and configuring the frontend dashboard environment.
## 🚀 Getting Started
### Prerequisites
- [Bun](https://bun.sh/) (Recommended) or Node.js (v20+)
- The `engine` backend should be running on `http://localhost:5201` for the API calls to succeed.
### 1. Installation
Clone the repository and install the dependencies using Bun:
```bash
cd uiframe
bun install
```
### 2. Environment Configuration
Create a `.env.local` file in the root of the `uiframe` directory. The primary configuration needed is pointing the dashboard to the backend engine.
```env
# Point to your local NestJS Engine instance
NEXT_PUBLIC_API_BASE_URL=http://localhost:5201/api/v1
```
### 3. Running the Development Server
Start the development server. By default, we have configured it to run on port `5200` to avoid conflicts with the backend.
```bash
bun run dev
```
Open [http://localhost:5200](http://localhost:5200) in your browser. You should see the dashboard!
## 🏢 Multi-Tenancy Architecture
This frontend supports a multi-tenant architecture out-of-the-box, matching the backend engine's tenant capabilities.
- **Login Flow**: When users log in, they must provide an `accountId` (or `__root__` for platform admins).
- **Session Management**: Once authenticated, the JWT token provided by the backend contains the tenant scope. All subsequent API calls automatically inherit this scope.
- **Tenant Context**: The UI conditionally renders tenant-specific actions versus platform-wide actions depending on the user's role and account scope.
## 🛠️ Built-In Generators
We have created specialized CLI tools to speed up your frontend development.
### Dynamic Form Generator
Generate full Zod validation schemas and `react-hook-form` UI components instantly using JSON metadata.
1. Create a `schema.json`:
```json
{
"entityName": "Product",
"fields": [
{ "name": "title", "type": "string", "required": true, "ui": "input" },
{ "name": "price", "type": "number", "ui": "number-input" }
]
}
```
2. Run the generator:
```bash
bun run generate:form --schema=schema.json
```
This automatically outputs a wired-up React component and Schema into `src/components/forms/`.
## 📁 Project Structure
- `src/app/(main)`: The primary dashboard pages (Users, Roles, Auth, Settings, CRM, etc.).
- `src/lib/api-client.ts`: The core Fetch wrapper configuring JWT tokens, interceptors, and error handling for the backend engine.
- `src/components/ui`: The Shadcn UI primitive components.
- `scripts/`: Custom CLI tools for code generation.
## 🤝 Need Help?
Ensure your backend engine is running. For any UI-specific component modifications, refer to the [Shadcn UI documentation](https://ui.shadcn.com/).
Explore similar templates
Compare previews and descriptions within the same stack and category.

next-shadcn-dashboard-starter
An MIT-licensed admin dashboard starter built with Next.js 16, shadcn/ui, Tailwind CSS v4, and TypeScript.
Next.js · Admin dashboard

Studio Admin · Radix UI
Studio Admin is an admin dashboard template built with Next.js 16, TypeScript, Tailwind CSS v4, and Shadcn UI.
Next.js · Admin dashboard

free-nextjs-admin-dashboard
A free, open-source admin dashboard template built on Next.js 16, React 19, TypeScript, and Tailwind CSS v4. It provides a collapsible sidebar, charts, tables, authentication forms, modals, dropdowns, and dark mode, with internationalization and RTL support since version 2.4.0.
Next.js · Admin dashboard

materio-mui-nextjs-admin-template-free
Materio Free is a Next.js admin dashboard template based on App Router and MUI, integrating Tailwind CSS and available in TypeScript and JavaScript versions.
Next.js · Admin dashboard

tiktokenizer
tiktokenizer is an open-source online tool site built with Next.js, TypeScript, and React that calculates token counts for text using the openai/tiktoken library.
Next.js · Tool Site

nextjs-postgres-nextauth-tailwindcss-template
A Vercel-maintained Next.js App Router admin dashboard starter with Auth.js GitHub OAuth, Postgres, Tailwind CSS, and Shadcn UI, plus a sample products table, seed endpoint, and CRUD interface.
Next.js · Admin dashboard
