The file-based
Node.js platform
Made by V25, Exis brings the convention-over-configuration experience of modern frontend frameworks to Node.js backend development.
Why building backends in Node.js was broken.
Today, building an API in Node.js or TypeScript forces engineering teams into an uncomfortable compromise between two bad extremes: the unorganized chaos of micro-libraries, or the suffocating boilerplate of legacy enterprise frameworks.
ExisJS eliminates this false trade-off by delivering the intuitive, convention-driven developer experience of modern frontend frameworks with native performance and built-in essential primitives.
The Chaos Camp
- Zero conventions or folder rules; manual wiring everywhere
- Must glue 30+ disparate packages (cors, helmet, rate-limit, validator)
- Type-safety breaks at middlewares, forcing
(req as any).user - Every team reinvents a custom, fragile directory layout
The Enterprise Bloat Camp
- Heavy, slow cold-starts (5–10s) and large runtime memory footprint
- 50+ files required just for a simple CRUD endpoint
- Over-engineered Java-style OOP and endless decorators
- Excessive boilerplate just to output a clean JSON response
The ExisJS Standard
- File-based Radix routing: create a folder, get an API endpoint
boundary.tsscopes CORS, rate limits, and auth recursively- Strict end-to-end middleware context typing without
as any - Instant < 15ms cold start with a lean, modular ~2MB core
Built for performance and developer velocity.
Everything you need to build scalable, high-throughput Node.js applications out of the box.
Routing and nested layouts
Create routes using the file system, including native support for dynamic parameters, catch-all wildcards, and route groups.
Folder-scoped boundaries
Configure CORS, security headers, rate limiting, and authentication recursively across directory trees with boundary files.
Rust-native validation
Validate incoming request payloads off-heap at native speed with zero garbage collection pause overhead.
End-to-end type safety
Strict TypeScript type inference from incoming schemas down to route handlers without manual casting.
Zero configuration
Create a route file to immediately get a production-ready API endpoint with automatic route discovery.
Instant cold starts
Sub-15ms startup times with a lean, modular 2MB core footprint designed for high-concurrency workloads.
Dual Paradigm. Choose your team's style.
Whether your team prefers sleek functional route handlers or structured class-based decorators, ExisJS compiles both into the exact same high-speed internal Radix execution tree with zero reflect-metadata bloat.
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 };
},
}),
});Matured through real-world production stress.
ExisJS was not designed in an academic vacuum or tested with synthetic benchmarks. It is hardened by building real software on top of the engine during active development.
Tested under heavy asynchronous I/O and rapid file changes to eliminate memory leaks, unhandled exceptions, and event-loop lag in production container environments.
Built-in native handling for container health-checks (such as automated HEAD / probes) and internet bot scanner sweeps without requiring custom middleware glue.
Every addition must eliminate repetitive boilerplate, prevent process crashes, or improve raw I/O throughput. Zero speculative features, focusing 100% on stability and performance.