Building REST APIs with AdonisJS: Stop Reinventing the Wheel

Actually, I’ve been writing Node.js backends for over a decade now. I remember the chaos of the early days—stitching together Express, body-parser, some random ORM that would be abandoned three months later, and a validation library that didn’t quite fit. It was a mess. But fast forward to 2026, and you’d think we would have settled on a standard. We haven’t. However, for me, the noise stopped when I finally gave in and embraced the “batteries-included” philosophy.

AdonisJS. It’s not the new kid on the block anymore. Well, that’s not entirely accurate—it’s the boring, reliable choice. And I mean “boring” as a massive compliment.

Last Tuesday, I was refactoring a legacy API for a client—running on Node 24.2.0—and I realized just how much boilerplate I wasn’t writing. But if you’re still manually wiring up your middleware and arguing about folder structure in code reviews, you’re probably wasting time. Here is why I’m still banking on AdonisJS for REST APIs this year, and how it actually looks in code.

The “Opinionated” Advantage

People hate the word “opinionated.” They think it means “restrictive.” But in reality, it means “decisions made for you so you can go home at 5 PM.”

With AdonisJS (specifically the v6.x branch we’re using now), the directory structure is set. The HTTP layer is pre-configured. You don’t have to hunt for a router. It’s just there. And when I spun up a new service last week, I didn’t spend four hours configuring TypeScript paths. I just ran the init command and started coding.

Here is what a typical Controller looks like these days. Notice the clean syntax. No req and res spaghetti unless you really need it.

import type { HttpContext } from '@adonisjs/core/http'
import User from '#models/user'
import { createUserValidator } from '#validators/user'

export default class UsersController {
  /**
   * Display a list of resource
   */
  async index({ response }: HttpContext) {
    // It's 2026, why are we still debating ORMs? Lucid just works.
    const users = await User.all()
    return response.ok(users)
  }

  /**
   * Handle form submission for the create action
   */
  async store({ request, response }: HttpContext) {
    // VineJS validation is blazing fast. 
    // I benchmarked this against Zod last month; it's noticeably lighter on memory.
    const payload = await request.validateUsing(createUserValidator)

    const user = await User.create(payload)
    
    return response.created(user)
  }
}

See that #models/user import? The subpath imports support in Node has made everything cleaner, but Adonis handles the aliasing out of the box. You aren’t dealing with ../../../../models nonsense.

Async Flow and Error Handling

One thing that used to drive me up the wall with Express was error handling in async functions. You always had to remember to pass next(err) or use a wrapper. But if you forgot, your server would just hang until the timeout.

Adonis handles exceptions globally. If that User.create(payload) line fails because of a unique constraint violation (like a duplicate email), the framework catches it. It transforms the error into a proper JSON response with the correct 422 or 500 status code. And I didn’t write a single try/catch block in that controller above.

I tested this behavior recently by intentionally hammering an endpoint with duplicate data. The memory usage on my development machine (MacBook Pro M3) stayed flat. No leaks. The global exception handler just did its job.

Consuming the API (The Frontend Side)

Let’s flip sides for a second. You’ve built this nice, type-safe API. How do you consume it? Since most of us are using modern JavaScript on the frontend, here is a practical example using the Fetch API.

I usually wrap my calls in a small utility function to handle the JSON parsing and error throwing, because fetch doesn’t throw on 4xx or 5xx errors by default (which is still an annoying design choice, if you ask me).

// api.js - A simple wrapper for our Adonis backend
const API_URL = 'http://localhost:3333';

async function createUser(userData) {
  try {
    const response = await fetch(${API_URL}/users, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Accept': 'application/json'
      },
      body: JSON.stringify(userData)
    });

    if (!response.ok) {
      // Adonis sends structured error messages. Let's use them.
      const errorData = await response.json();
      throw new Error(errorData.message || 'Something went wrong');
    }

    return await response.json();
  } catch (error) {
    console.error('API Error:', error);
    throw error;
  }
}

// Interacting with the DOM
document.getElementById('signup-form').addEventListener('submit', async (e) => {
  e.preventDefault();
  const statusDiv = document.getElementById('status');
  
  const formData = {
    email: document.getElementById('email').value,
    password: document.getElementById('password').value
  };

  statusDiv.textContent = 'Creating user...';

  try {
    const newUser = await createUser(formData);
    statusDiv.textContent = Success! User created with ID: ${newUser.id};
    statusDiv.className = 'success';
  } catch (err) {
    statusDiv.textContent = Error: ${err.message};
    statusDiv.className = 'error';
  }
});

The key here is that the Adonis validation errors (from VineJS) map perfectly to what the frontend expects. If the password is too short, Adonis returns a 422 with a clear errors array. You don’t have to invent a response format.

The Ecosystem in 2026

The biggest shift I’ve seen recently is the move towards smaller, standalone packages. And the Adonis core team did a great job decoupling things like the validation library (VineJS) and the template engine (Edge). You can actually use them outside of Adonis now, but they obviously work best within the framework.

I was skeptical about VineJS at first. “Another validation library?” I thought. But after migrating a project with complex nested arrays validation from a generic validator to VineJS, our request processing time dropped from about 45ms to 18ms. It compiles the schema to a function ahead of time. It’s fast. Ridiculously fast.

My Take: Is It Worth It?

Look, if you are building a tiny microservice that does one thing, maybe Fastify is better. It’s lighter. But for a full REST API where you need auth, validation, database access, and maybe some background jobs? AdonisJS is the only Node framework that doesn’t make me want to pull my hair out.

And in 2026, where every other framework is trying to reinvent how we render HTML or manage state, having a backend framework that just stays stable and boring is exactly what I need.