Philosophy

If you're evaluating AdonisJS or curious about our approach to building a full-stack framework, this page explains the "why" behind our decisions.

We bring coherence, simplicity, and stability to full-stack JavaScript development without sacrificing the flexibility and power of the platform.

The JavaScript ecosystem problem

The JavaScript ecosystem is incredibly innovative, but it suffers from decision paralysis.

Want to build a web application? You'll spend days choosing between dozens of ORMs, endless authentication solutions, competing validation libraries, and build tools. Then you'll spend weeks making them work together. Every project becomes a bespoke integration nightmare.

The "do one thing well" philosophy works for libraries, but frameworks need to do everything well, and do it cohesively.

• Fragmentation fatigue: Multiple ORMs, dozens of authentication libraries, competing validation solutions, none designed to work together. You become an integration engineer instead of an application developer.
• Implicit knowledge debt: Your project's architecture lives in the heads of whoever set it up. New developers spend weeks understanding why this specific combination of packages was chosen and how they're wired together.
• Update paralysis: Upgrading one package breaks three others. Your carefully balanced house of cards can't move forward without days of testing and fixes.
• No cohesive vision: Your validator doesn't know about your ORM. Your ORM doesn't know about your API serializer. Your auth system is isolated from everything. You're constantly writing glue code.

The JavaScript ecosystem needed something different, something that works as a unified system, not a collection of parts.

Our approach

• We eliminate fragmentation: AdonisJS provides one excellent ORM, one authentication system, one validator—all designed to work together. You stop evaluating packages and start building features. There's no integration work because everything is already integrated.
• We encode architectural decisions: Project structure, where things go, how they connect—it's all documented and consistent across every AdonisJS application. New developers onboard in hours, not weeks, because the patterns are universal.
• We own the integration: When we update the validator, we test it with the ORM. When we update the ORM, we test it with auth. You upgrade AdonisJS, run your tests, and move on. No cascading breakage, no dependency hell.
• We build cohesive systems: Our auth system, rate limiter, and session store all seamlessly integrate with the ORM. Our caching solution works with Redis out of the box. We've built an architecture that allows these integrations to happen cleanly, without leaking implementation details into your application code. Everything just works together
• TypeScript-first, not TypeScript-bolted-on: We're written in TypeScript, for TypeScript. Full type safety across your entire application, from database queries to HTTP responses to your frontend. End-to-end type safety means your API changes break at compile time, not in production. No any soup, no type gymnastics, no runtime surprises.
• Modern primitives, not legacy baggage: We embrace ESM modules, top-level await, and modern Node.js features. No CommonJS compatibility shims, no transpilation overhead unless you need it. We build for the JavaScript of today, not the JavaScript of 2015. If the platform provides it natively, we use it.
• Documentation as a first-class feature: If it's not documented, it doesn't exist. Our docs are comprehensive, searchable, and actually maintained. Every feature, every API, every decision is explained. We don't assume you'll read the source code. We write docs like they're the only way you'll learn the framework.
• Stable, not stagnant: We move fast between major versions, but we take semver seriously. Your v7 application won't break when you npm update. We introduce new features aggressively, but we never break your code without a major version bump and a clear migration path.

Long-term sustainability

AdonisJS is independently funded through our Insiders program, community sponsors, and premium products like AdonisJS Plus.

• We're intentionally not VC-backed: Our success is measured by building the best framework for developers, not preparing for an exit strategy or hitting growth metrics for the next funding round. This independence keeps our incentives aligned with yours.
• This is my full-time job: As the creator and maintainer, I work on AdonisJS every day. This isn't a side project that might get abandoned when life gets busy—it's my career and my craft.
• The model already works: We're not seeking sustainability—we're already sustainable. Thousands of developers and companies trust AdonisJS for production applications, and that trust funds continued development.
• Core team and community: While I provide technical direction, a talented core team and vibrant community contribute to the ecosystem, build packages, help users, and ensure AdonisJS keeps evolving.

Considering AdonisJS for your team?

If you're evaluating AdonisJS for a company project and have questions about architecture, scalability, long-term support, or whether it's the right fit. I'm happy to chat.

No sales pitch. Just an honest conversation about whether AdonisJS makes sense for what you're building.