Version 3.2 is now live|Read Release Notes

The unified data engine for modern tech products

Empower your engineering and operations teams with high-density data tables, granular role-based access control, real-time telemetry, and end-to-end type safety. From day-one prototype to enterprise scale.

pnpm dlx create-acme-platform@latest

Architected with modern industry standards

Next.js 16 (React 19)NestJS Modular CoreTailwind CSS v4TypeScript StrictTanStack Table v8Turborepo Monorepo
Interactive Product Showcase

Experience the control plane in action

Test-drive the high-density grid, switch roles to inspect live RBAC enforcement, or preview the TypeScript SDK.

Status:
Resource IdentifierService TypeRegionThroughputEdge LatencyHealth Status
prod-edge-gateway-usNext.js Edge Proxyus-east (Virginia)24,890 /s6msHealthy
auth-rbac-clusterNestJS Identity Coreeu-west (Frankfurt)8,420 /s11msHealthy
data-table-pipelineTanStack Virtual Gridap-southeast (Singapore)15,100 /s14msHealthy
audit-stream-replicaPostgres Event Storeus-west (Oregon)5,230 /s19msSyncing
telemetry-metrics-busKafka Broker Hubsa-east (São Paulo)3,800 /s24msHealthy
Showing 5 of 5 edge clusters
100% SLA MaintainedView full live table
< 12ms
Edge Latency
Global median response time
99.999%
SLA Availability
Engineered for zero downtime
250M+
Queries Handled Daily
Across multi-tenant workloads
100%
Type Contracts
Next.js 16 to NestJS parity
Core Architecture

Built for velocity, scale, and enterprise security

Every layer of Acme is engineered to remove operational friction so your engineering team can focus on shipping core digital product features.

Data Grid Engine

Dynamic High-Density Data Tables

TanStack Table v8 with seamless browser URL state syncing, multi-column sorting, faceted filters, column visibility toggles, and server/client pagination built-in.

Active DatasetsURL Synced
Columns (8 active)
Alex MercerRole: Admin● ActiveEdit
Sarah ChenRole: Manager● ActiveEdit
David MillerRole: Member● PendingEdit
Zero Trust

Granular RBAC Engine

Centralized permission registry with role definitions, decorator-driven API guards, and declarative UI gating.

Role inheritance & permissions matrix
Client & server verification decorators
Dynamic route protection middleware
Multi-Tenant

Workspace Isolation

Seamlessly context-switch between organizational domains with strict tenant scoping and tailored permissions.

Acme Inc.Enterprise
Acme Corp.Startup
Evil Corp.Free
Monorepo

Turborepo Core

Blazing fast build pipelines with shared TypeScript configurations, unified ESLint rules, and isolated workspace packages.

apps/frontend (Next.js 16)
apps/backend (NestJS)
packages/auth (@repo/auth)
Type Safety

Strict Contract Parity

Shared DTOs, schemas, and authentication states across client and server prevent runtime drift and catch bugs in CI.

Strict TypeScriptZod SchemasZero Runtime Overhead
Engineering Deep Dive

Modular fullstack architecture

Engineered as a cohesive Turborepo monorepo. The Next.js 16 frontend provides instantaneous edge rendering, while NestJS powers heavy enterprise computation.

Next.js 16 App Router

React 19 Server Components, streaming hydration, Server Actions, and Tailwind CSS v4 styling with zero client JS runtime bloat.

NestJS Microservices

Enterprise DI container, declarative decorators, guards, interceptors, and modular domain architecture for scale.

Shared @repo/auth

Unified permissions, roles, and cryptographic token verification shared across the entire stack without code duplication.

Stack Implementation Code
// apps/frontend/actions/users.ts
'use server';

import { requirePermission, PERMISSIONS } from '@repo/auth';
import { dataProvider } from '@/lib/data';

export async function fetchUserRoster(params: {
  page: number;
  pageSize: number;
  search?: string;
}) {
  // 1. Strict server-side permission assertion
  await requirePermission(PERMISSIONS.USERS_READ);

  // 2. High-performance data query via unified provider
  const response = await dataProvider.users.findMany({
    page: params.page,
    limit: params.pageSize,
    query: params.search,
  });

  return response;
}
Enterprise Zero-Trust

Defense-in-depth security built into every layer

Security isn’t an afterthought. Acme enforces cryptographic access policies across edge middleware, Next.js Server Actions, NestJS API guards, and database queries.

Zero-Trust Permission Matrix

Granular permission tokens (`users:read`, `roles:write`, etc.) evaluated instantaneously on every state mutation.

Strict Session Isolation

HTTP-only, SameSite strict session cookies with rotating JWT signatures and token revocation list checks.

Tamper-Proof Audit Logging

Every admin action, permission change, and session initiation is recorded with timestamped telemetry.

Active Security Inspector
Policy Guard Active
Route Policy: /rbacRole: ADMIN only

Enforced via middleware and Server Action guards before render.

Mutation: deleteUser()requirePermission('users:delete')

Rejects non-privileged mutations with immediate 403 Forbidden.

Multi-Tenant ScopingTenantKey = acme_inc

Automatic row-level database partitioning across isolated org IDs.

All 62 security policies verified0 Vulnerabilities
Social Proof

Loved by engineering teams worldwide

See how forward-thinking software organizations accelerate product delivery with Acme.

“The dynamic data tables and instant RBAC saved our team 4 months of heavy engineering boilerplate. The Next.js 16 and NestJS cohesion is truly best-in-class.”

MV

Marcus Vance

Head of Engineering · Synthetix Cloud

“Acme provides the most cohesive monorepo setup we’ve ever deployed. Turborepo caching and shared auth contracts cut our CI/CD pipeline runtimes by over 70%.”

ER

Elena Rostova

Principal Platform Architect · DataVanguard

“Zero-friction permission management. We were able to launch multi-tenant enterprise tiers for our SaaS product in days rather than quarters.”

JC

Julian Chen

Co-Founder & CTO · Krypton Labs

Simple, Transparent Pricing

Predictable plans that scale with you

Start completely free with zero friction. Upgrade only when your product demands enterprise isolation and multi-tenancy.

Starter

Open Core

Ideal for indie hackers, prototypes, and individual engineers.

$0/ forever

What's Included:

  • Full Next.js 16 + NestJS source code
  • TanStack high-density data tables
  • Basic RBAC (Admin & User roles)
  • Local mock data provider
  • Standard Turborepo monorepo setup
  • Community Discord & GitHub support
Most Popular

Team Pro

Built for high-velocity software teams scaling production products.

$39/ per month

What's Included:

  • Everything in Starter
  • Multi-tenant workspace isolation
  • Dynamic RBAC custom permission matrix
  • Faceted filters with persistent URL state
  • Shared type contracts & validation schemas
  • Automated route & permission generation
  • 99.99% edge uptime SLA
  • Priority technical support

Enterprise

Custom Security

Tailored for compliance-driven enterprises requiring dedicated scale.

Custom

What's Included:

  • Everything in Team Pro
  • Enterprise SAML / SSO / SCIM provisioning
  • Custom role hierarchies & dynamic policies
  • Dedicated NestJS microservice cluster
  • SOC2 Type II & GDPR compliance telemetry
  • Immutable cryptographic audit retention
  • 99.999% SLA with financial guarantee
  • 24/7 dedicated solutions architect
Got Questions?

Frequently asked questions

Everything you need to know about the platform architecture, security, and deployment.

Unlike basic UI kits, Acme is an enterprise-grade fullstack monorepo built with Turborepo. It features Next.js 16 (React 19) on the frontend, NestJS on the backend, a shared zero-trust RBAC package (@repo/auth), and high-density TanStack data tables with URL state synchronization.
Production Ready Architecture

Start building your high-velocity product today

Stop reinventing role permissions, table pagination, and fullstack monorepo setups. Get the complete enterprise foundation out of the box.

No credit card required • 100% open-source core • MIT licensed