Next.jsReactAdmin dashboardTool Site

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.

3 previews
Desktop homepage1 / 3
Desktop captureTop of page

Actual screenshot captured by the server browser.

All pages & views 3

Screenshots show visual appearance; interactive behavior may differ.

Recorded 2026-10-14View source

What stands out

A quick read of the recorded project description.

01

Frontend dashboard built on Next.js 16 App Router, React and Shadcn UI

02

Connects to the NestJS backend engine through NEXT_PUBLIC_API_BASE_URL, with the default backend address at http://localhost:5201

03

Built-in multi-tenant architecture: login requires an accountId, and the JWT carries the tenant scope that is automatically applied to subsequent API calls

04

Provides a dynamic form generator that generates Zod schemas and react-hook-form components from JSON metadata

05

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.

Next.jsReactAdmin panelTool site

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

    Install dependencies: run bun install in the uiframe directory

  2. 2

    Create .env.local and set NEXT_PUBLIC_API_BASE_URL=http://localhost:5201/api/v1

  3. 3

    Ensure the backend engine is already running at http://localhost:5201, otherwise API calls will fail

  4. 4

    Run bun run dev to start the development server, default port 5200

  5. 5

    Generate forms: after preparing schema.json, run bun run generate:form --schema=schema.json

Read repository instructions

License & source material

Usage conditions & limitations

Free to use · keep license notice

This 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

- **Login Flow**: When users log in, they must provide an `accountId` (or `__root__` for platform admins).

Original README
https://github.com/theblueprintcode/uiframe/blob/main/LICENSEhttps://github.com/theblueprintcode/uiframe/blob/main/README.md

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](public/assets/banner.png)

# 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/).
Report a correction

Explore similar templates

Compare previews and descriptions within the same stack and category.