Eicrud: The Most Opinionated Node.js Framework

When you're building a large web project, you're likely dealing with developers from a range of backgrounds and experience levels. As team members come and go, the challenge of maintaining the codebase grows exponentially. Without a strong technical lead ensuring consistency and quality, even the best-intentioned teams end up creating technical debt, making the project increasingly difficult to maintain.

The problems don’t stop at technical debt. Security vulnerabilities emerge when developers aren’t rigorous about best practices for authorization and validation. Developers may write code in different ways due to a lack of communication or proper documentation, resulting in duplicated code and inconsistent approaches. Add in the chaos of poorly enforced folder structures, and the project can quickly become a mess.

These issues are magnified when moving to microservices. With different developers handling different services, you run the risk of everyone using different stacks, duplicating utilities, and ultimately decreasing the project’s maintainability.

Enter Eicrud

Eicrud was created with one primary goal: to prevent the common pitfalls that make large web projects so hard to maintain. Whether it’s keeping the project secure or enforcing consistent coding practices, Eicrud is built to manage complexity and keep technical debt in check. Here’s how it does that:

Everything Is Either a CRUD Service or a Command

With Eicrud, all code is neatly organized into either a CRUD service or a command tied to that service. This strict abstraction keeps your code simple, readable, and easy to navigate. There’s no ambiguity about where things should go or how they should be structured; Eicrud enforces order from the start.

Automatic Routing

In most traditional frameworks, you’re stuck writing controllers and setting up endpoints. With Eicrud, you don’t need to write these at all. The framework automatically routes every endpoint, simplifying your API and making it easier to maintain. There’s no need to reinvent the wheel every time you add a new feature; the routing is handled for you, reducing errors and ensuring consistency.

Validation and Security Are Mandatory

One of Eicrud’s core principles is that security comes first, even if it’s not something developers are thinking about. With Eicrud, any field that isn’t explicitly validated is not accessible outside of your service. You need to add validation decorators to every DTO field you want to expose, ensuring that all external input is validated. Additionally, all endpoints are forbidden by default, meaning developers need to manually enable read/write access to any data. This approach forces even less experienced developers to produce secure code by default.

DRY Code by Default

One of the biggest contributors to technical debt is repetitive code. Eicrud focuses on DRY principles (Don't Repeat Yourself), combining database schema, validation, and transformation logic in one place. This makes your code more maintainable over time, ensuring you don’t have to hunt down and update the same logic in multiple places.

Built-In CRUD Boilerplate

Rather than allowing different developers to build CRUD services in different ways, Eicrud handles the basic CRUD boilerplate for you. This means there’s no room for inconsistency; every service is built the same way, with the same stack, saving time and avoiding confusion.

CLI-Generated Structure

Organizing code in a consistent and readable way is a challenge for many teams. With Eicrud, the CLI generates an organized structure for your project automatically. Need to create a new service or command? Just use the CLI, and it will do the heavy lifting for you. This saves you time and ensures that everyone on your team follows the same structure.

Auto-Generated Client

Another pain point for many developers is writing the code to interact with their API. With Eicrud, the client is automatically generated, so you don’t need to write those tedious fetch requests manually. You can even export your DTOs with the client, making everything type-safe and reducing the chances of runtime errors.

Monolith to Microservices, Seamlessly

One of the most powerful features of Eicrud is the ability to build your app as a monolith and later split it into microservices with a simple configuration change. This ensures that all your services use the same stack and minimizes the complexity that often comes with microservice architectures. You can develop locally as a monolith, simplifying the process, and later deploy as microservices when needed.

Built-In Authentication

Finally, Eicrud handles authentication for you, taking care of the often error-prone process of implementing security protocols. This ensures that your app remains secure from the start, without the need for developers to reinvent authentication mechanisms or risk implementation mistakes.

Conclusion

For SaaS owners, project managers, or developers dealing with large-scale web applications, complexity is the enemy. Without a structured, opinionated approach, technical debt builds up, maintenance costs rise, and security becomes an afterthought. Eicrud solves these problems by enforcing best practices, reducing repetitive code, and making security the default.

By using Eicrud, you save time, reduce costs, and ensure that your application is built on a solid, maintainable foundation. Whether you’re building a monolith or microservices, Eicrud offers a solution to the complexity that plagues most web projects; keeping your app clean, secure, and scalable from day one.