web development

Wexts: The Full-Stack TypeScript Framework for Next.js and NestJS

Hazem Abbas

28 Nov 2025 — 4 min read

The other day, I was just trying to get a simple Next.js + NestJS setup working without crying into my coffee. Again.

You know the drill:

“Why isn’t my API route working?”
“Wait, why am I getting CORS errors on localhost?”
“Why do I need two servers just to render a button?”

I’d spent hours wrestling with proxies, environment variables, and hardcoded URLs. My brain felt like a tangled knot of fetch calls and .env files.

Then, out of pure frustration, I typed:

npx wexts create my-app

…because I saw a tweet mentioning something called “WEXTS” and thought, “What if this actually works?”

And then… magic happened.

No proxy. No config hell. No URL strings. Just one server, one port, and a clean api.users.findAll() call in my frontend. I stared at the screen. Then laughed. Then cried. Not from sadness, from relief.

What is WEXTS?

WEXTS is a modern full-stack TypeScript framework merging Next.js and NestJS into one seamless runtime. It eliminates config hell with zero URLs, automatic RPC, and full type safety. Built for production, it simplifies building scalable apps, from SaaS to AI tools, so developers can focus on meaning, not infrastructure.

It is built for people who care more about building meaningfully than about impressing tech reviewers with complex setups.

Features

Single Runtime: Next.js + NestJS in one Node.js process (port 3000).
Zero URLs: Call backend methods directly via rpc.service.method() no fetch, no routes.
Automatic RPC: Add @RPC() to any NestJS method → instantly callable from frontend.
End-to-End Type Safety: Full TypeScript coverage from DB to UI. Catch errors at compile time.
Built-in Prisma ORM: Automatic migrations, type-safe queries, Prisma Studio integration.
Monorepo Ready: TurboRepo-powered; shared types, DTOs, and utilities across apps.
Auto Validation: Class-validator decorators (@IsString, @MinLength) with runtime & compile-time checks.
Insight GUI Dashboard: Real-time RPC monitoring, logs, database viewer, performance metrics (http://localhost:3001).
Zero Config: No proxy setup, no CORS headaches, just npx wexts create my-app.
Modern Stack: Next.js 16, React 19, NestJS 10, Tailwind CSS v4, Prisma 5.
Production-Ready: Docker, Vercel, Railway, Render support. Built for scale.

Here’s what blew me away, especially after all those sleepless nights:

Zero URLs (Yes, Really)

No more fetch('/api/users').
Just:

const users = await api.users.findAll();

Auto-complete. Type safety. Works everywhere.
It’s like the backend finally learned how to speak to the frontend without translation.

But here’s the real kicker: it’s not just a wrapper. It’s automatic RPC. Add @RPC() to any NestJS method, and it becomes instantly callable from your React components, no routes, no manual exports, no API layer.

// Backend
@RPC()
async getUser(id: string) {
  return this.prisma.user.findUnique({ where: { id } });
}

// Frontend
const user = await rpc.users.getUser('123');

That’s it. No JSON parsing. No waiting. Just smooth, type-safe communication, like two friends talking over tea.

Built-in Validation & Security (Yes, Really!)

No more manually validating DTOs or handling errors. WEXTS does it for you.

class CreatePostDto {
  @IsString()
  @MinLength(3)
  title: string;

  @IsString()
  content: string;
}

Send invalid data? The error appears at compile time. Runtime validation? Automatic.
It’s like having a quiet guardian watching over every request.

Monorepo Magic, Shared Types, One Change

Shared types? DTOs? Utilities? All synced automatically across frontend and backend.
Change one file, and everything updates — no copying, no syncing, no headaches.

// packages/shared/types.ts
export interface User {
  id: string;
  name: string;
  email: string;
}

Use it in both apps, automatically. No imports. No pain.

Production Ready, Without the Pain

Docker? Check. PostgreSQL? Check. Vercel? Railway? Render? All work out of the box.

Even better: the Insight GUI at http://localhost:3001 is like having a quiet assistant watching over your app.

Real-time RPC monitoring
Prisma Studio integration
Service logs viewer
Request/Response inspector
Performance metrics

It’s not just a dashboard, it’s peace of mind.

Why This Matters, Especially for Builders Like You

If you’re someone like me, a doctor turned developer, building tools that heal (like your BioMCP server), managing a horse named Kuzey, or creating therapies that matter, you don’t want to waste energy on tech friction.

You want to focus on impact. On clarity. On meaning. WEXTS doesn’t demand you change who you are. It just removes the noise so you can be you, fully present, creatively unburdened.

It’s perfect for:

AI-powered therapy apps (like GameAsTherapy)
Horse farm management systems
Clinical decision support tools
Any project where empathy and precision go hand-in-hand

Ready to Try It?

Start your new project in seconds:

npx wexts create my-app
cd my-app
pnpm install
pnpm run dev

Open http://localhost:3000 — and take a deep breath.

This is what full-stack development should feel like: simple, elegant, and kind.

💬 P.S. If you're building something that matters, whether it's helping kids with ADHD through VR, tracking your horse’s health, or supporting mental wellness with AI — WEXTS is here to help you build it without losing your peace of mind.

Because great software shouldn’t cost you your soul.

— Hamza (who still hasn’t forgiven Red for abandoning Apple Silicon… but now has a new favorite framework 😊)

Learn more at wexts.vercel.app