ExisJSOpen source · Made by V25

Create a folder. Get an endpoint.

ExisJS is a file-based Node.js platform. It brings the convention-over-configuration experience of modern frontend frameworks to your backend: routing, validation and security, ready from the first file.

Start building GitHub

terminal

You createExisJS serves

src/http/route.tsGET/
src/http/users/route.tsGET · POST/users
src/http/users/[id]/route.tsGET · PATCH/users/:id
src/http/orders/boundary.tsSCOPEauth + rate limit → /orders/**
src/http/files/[...path]/route.tsGET/files/*

Cold start: <15ms
Modular core: ~2MB
Config files to start: 0
End-to-end typed: 100%

The backend dilemma

Between chaos and bloat, there's a better way.

Drag the slider or tap a name to compare the two extremes teams usually choose between with the ExisJS standard.

The golden mean

The ExisJS standard

The convention-driven middle ground: structure without the weight.

File-based radix routing: create a folder, get an endpoint
boundary.ts scopes CORS, rate limits and auth recursively
Strict end-to-end middleware typing, no as any
< 15ms cold start with a lean ~2MB core

Core pillars

Built for performance and developer velocity.

Everything you need for scalable, high-throughput Node.js applications, out of the box.

Folder-scoped boundaries

CORS, security headers, rate limiting and auth applied recursively with boundary files.

// src/http/orders/boundary.ts
export default boundary({
  cors: { origin: ["https://app.acme.com"] },
  rateLimit: { window: "1m", max: 120 },
  auth: requireRole("ops"),
});

Instant cold starts

Sub-15ms startup with a lean, modular ~2MB core built for high concurrency.

15ms

Routing & nested layouts

File-system routes with dynamic parameters, catch-all wildcards and route groups.

Rust-native validation

Request payloads validated off-heap at native speed with no garbage-collection pauses.

End-to-end type safety

Strict TypeScript inference from schemas down to route handlers, with no manual casting.

Zero configuration

Create a route file and get a production-ready endpoint with automatic discovery.

Developer ergonomics

Dual paradigm. Choose your team's style.

Sleek functional route handlers or structured class-based decorators. ExisJS compiles both into the same high-speed radix execution tree, with zero reflect-metadata bloat.

src/http/users/route.ts

import { controller, route } from "exisjs/router";
import { tex } from "exisjs/validator";
import { UserService } from "./user.service";

// Rust-powered off-heap schema
const UserSchema = tex.object({
  name: tex.string({ min: 2 }),
  email: tex.email(),
  role: tex.enum(["admin", "member"]).default("member"),
});

export default controller({
  list: route.get("/", {
    handle() {
      return [{ id: 1, name: "Alice" }];
    },
  }),
  create: route.post("/", {
    schema: { body: UserSchema },
    async handle({ req, ctx }) {
      const userService = ctx.inject(UserService);
      const user = await userService.create(req.body);
      return { status: "created", user };
    },
  }),
});

Production methodology

Matured through real-world production stress.

Not designed in an academic vacuum or tuned for synthetic benchmarks. It is hardened by building real software on the engine.

01
Kernel & concurrency stability
Tested under heavy async I/O and rapid file changes to eliminate leaks, unhandled exceptions and event-loop lag in production containers.
02
Edge probes & traffic resilience
Native handling for container health checks like HEAD / probes and internet bot sweeps, with no custom middleware glue.
03
Zero feature-bloat discipline
Every addition must remove boilerplate, prevent crashes or improve raw I/O throughput. No speculative features.

Get started

Start building in one command.

$npm create exisjs@latest my-backend

Star on GitHub Enterprise support