Recommended backend technology stack for 2024

At Arteco Consulting, we are committed to the implementation of best practices and technologies to ensure the success of our projects. For the year 2024, we recommend the following technology stack for standard management applications, designed to provide robustness, scalability and efficiency in application development.

SPA application architecture

Our recommendation is to apply SPA application patterns (Single Page Applications, or single page applications, where the entire user interface (UI) is delivered to the user's browser). Separating the UI and the REST API server provides numerous benefits that improve both application development and maintenance. By keeping these layers separate, greater flexibility and scalability is achieved, allowing frontend and backend teams to work independently and specialize in their respective domains. This facilitates parallel development and speeds up delivery time. In addition, a decoupled architecture improves security by restricting direct access to data and server logic, allowing stricter security policies to be implemented. It also offers the ability to reuse and share the API with different clients (such as mobile, web and desktop applications), promoting consistency and reducing duplication of effort. Finally, by isolating the business logic on the server, updating and maintaining the system is simplified, as modifications can be made in one place without affecting the user interface.

What components do we need for this? Here we tell you how we do it from Arteco.

Database: PostgreSQL

PostgreSQL is our choice for database management because of its reliability, robustness and broad functionality. It offers excellent performance, JSON support and extensibility capabilities that make it ideal for modern applications. Fully adapted to both Cloud and On-premise environments.

Backend: Spring Boot

Spring Boot is our reference technology for the development of REST APIs because of its speed and ease of configuration. With this framework you can build a Java application that returns validated JSON and connects to a database such as PostgreSQL in a matter of minutes. Additionally, we accompany it with the following libraries to take productivity to the next level:

Building with Maven: Organizing the project into two modules.

Although Maven can be considered a somewhat old build system, we love the way it forces projects to have the same structure, a fact we prefer when many applications need to be maintained. We usually separate projects into at least two modules:

1. model: Contains the JPA entities.
2. api: Spring Boot application with the latest stable JDK version available.

Database access: Using Spring Data JPA Repositories

To facilitate CRUD (Create, Read, Update and Delete) operations. Spring Data repositories natively offer services such as paging and large batch record work.

Security: Implement Spring Security

Spring Security is the official blueprint for building security into any Spring application. When recommending a microservices architecture, it is ideal to implement access via JWT to ensure application security.

API Documentation

We use OpenAPI with Spring Doc to generate documentation automatically based on Spring driver annotations. In addition, OpenAPI will allow us to automatically generate client code as well.

Typed Database Queries

If you don't know the QueryDSL project, don't delay to learn it and incorporate it to all your projects. You will avoid the use of strings in queries by using attributes and methods to define complex queries. Thus, every time you refactor the JPA model, the compiler will help you, long before you see the error in execution.

Database Migrations

Logically, we do not like to execute DDL SQL statements in production. For this, we use script execution management through Flyway to have deterministic and stable environments between environments.

Clean Code with Lombok

Lombok](https://projectlombok.org/) annotations generate Java code for us (such as getters and setters, among other functionalities), leaving the model classes clean as a whistle.

REST controllers with JSON views

This point requires experience. The usual is to create simple classes (DTO, Data Transfers Object) that only contain the getters and setters of the properties that we want to be published outside the controllers. However, we, in order to simplify and shorten times and in a very supervised way, we take the JPA entities directly out where it is feasible using JSON views. This simplifies development and shortens the time to include new functionality.

Conversion from DTO to JPA Entities: Mapstruct

It is not always possible to make JSON views, and when it is not possible, we use Mapstruct to pass the information from the private entities to the public DTOs that will be output in the controllers' responses. It is highly efficient since it does not use reflection!

Testing to verify that the code is correct

We always require the service layer to have 100% coverage of the lines of code and use cases. For this we use any combination of the following libraries: JUnit, Mockito, and MockMVC.

Deployments: Kubernetes our ally

Whenever the customer's infrastructure allows it, we use Kubernetes (K8S) to deploy all services such as API, frontend and database. Kubernetes is a great ally to not depend on any cloud provider and is a tireless worker to ensure that applications are kept running without service outages.

This technology stack is designed to provide efficient development and maintain a high standard of quality in our projects. At Arteco Consulting, we are committed to innovation and excellence, and this stack is a reflection of that philosophy.

❤️ If you liked the post and found it useful, let us know and we will do more like this one, transferring the experience we have accumulated in 20 years of development with Java and HTML.